面向对象（上）
面向对象
1、概念
使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想就是面向对象
2、面向对象的概述
面向过程：强调的是过程。也就是说完成功能的每一个步骤都需要自己来做。
吃烤猪：买头小猪->养大->搭架子->烤猪->吃猪
面向对象：强调的是对象。也就是说由对象去帮助我们完成具体的功能
吃烤猪：去餐馆点烤猪—>吃烤猪
2.1 面向对象的好处：
（1）将复杂的事情简单化
（2）更符合人们思想
…
2.2 面向对象三大特征
（1）封装
（2）继承
（3）多态
3、类与对象的关系
3.1 类
它是一种抽象的泛泛的概念，是事物的属性和行为的一种集合。
例如：动物类、水果类
3.2 对象
对象就是指某一类事物的具体体现
例如：动物类（猫、狗、猪…） 水果类（苹果、香蕉）
3.3 类的定义
（1）在面向对象的思想中，最核心的就是对象
（2）为了在程序中创建对象 ，首先需要定义一个类
（3）类是对象的抽象，它用于描述一组对象的共同特征和行为，例如人都有姓名、年龄、性别等特征，还有学习、工作、购物等行为。
（4）以面向对象的编程思想，就可以将某一类中共同的特征和行为封装起来，把共同行为作为类的方法（也叫成员方法）
public class Person{
//成员变量
String name; //人的姓名
int age; //人的年龄
//成员方法
权限修饰符 返回值类型 方法名（数据类型 参数名1， 数据类型 参数名2...）{
方法体;
return 返回值;
}
//吃饭
public void eat(String food){
System.out.println(name+"正在吃"+food);
}
public void sleep(){
System.out.println(name+"正在睡觉");
}
}
4、对象的创建与使用
4.1 类的使用
（1）创建对象
类名 对象名 = new 类名（）；
（2）使用成员
使用成员变量：对象名.变量名
使用成员方法：对象名.方法名（）
public class Demo02{
public static void main(String[] args){
//创建Person对象
Person p = new Person();
//使用成员变量
System.out.println(p.name); //null
System.out.println(p.age); //0
}
}
（3）对象的内存图解
（4）成员变量的默认初始化值
整数类型：0
浮点类型：0.0
字符类型：空白字符 ‘\u0000’
布尔类型：false
引用数据类型：null
public class Demo02{
public static void main(String[] args){
//创建Person对象
Person p = new Person();
//使用成员变量
System.out.println(p.name); //null
System.out.println(p.age); //0
//为成员变量赋值
p.name="张三";
p.age=23;
//再次输出成员变量
System.out.println(p.name); //张三
System.out.println(p.age); //23
System.out.println("===============");
//使用成员方法
p.eat("米饭");
p.sleep();
}
}
4.2 局部变量和成员变量
访问特点：java遵守的是就近原则。谁近谁优先使用
成员变量和局部变量的区别：
A：定义位置
成员变量：定义在类中方法外
局部变量：定义在方法中的内部或者方法的声明上
B：内存中的位置
成员变量：在堆内存中
局部变量：在栈内存中
C：声明周期的区别
成员变量：随着对象的创建而创建，随着对象的消失而消失
局部变量：随着方法的调用而创建，随着方法的消失而消失
D：默认初始化值的区别
成员变量：有默认的初始化值
局部变量：没有默认初始化，使用之前必须赋值
（6）堆内存垃圾的形成和解决
如果一个对象没有任何引用指向它了，那么就会变成垃圾。由垃圾回收器自动进行回收
5、访问修饰符
5.1 访问控制符
在java中，针对类、成员方法和属性提供了四种访问级别，分别是private、default、protected和public(访问控制级别由小到大)
5.1.1 private(当前类访问级别)
如果类的成员被private访问控制符来修饰，则这个成员只能被该类的其他成员访问，其他类无法直接访问。类的良好
封装就是通过private关键字来实现的。
5.1.2 default(包访问级别)
如果一个类或者类的成员不使用任何访问控制符修饰，则称它为默认访问控制级别,这个类或者类的成员不使用任何访问控制符修饰，则称它为默认访问控制级别，这个类或者类的成员只能被本包中的其他类访问。
5.1.3 protected(子类访问级别)
如果一个类的成员被protected访问控制符修饰，那么这个成员既能被同一包下的其他类访问，也能被不同包下该类的子类（继承的概念）访问。
5.1.4 public(公共访问级别)
这是一个最宽松的访问控制级别，如果一个类或者类的成员被public访问控制符修饰，那么这个类或者类的成员能被所有的类访问，不管访问类与被访问类是否在同一个包中。
6、封装
6.1 什么是封装？
封装就是将对象中的实现细节隐藏。不被外界所直接访问
6.2 封装的好处？
可以提高代码的安全性
通过get/set方法来访问私有变量
public class Person{
//成员变量
private String name; //人的姓名
private int age; //人的年龄
public void setName(String n){
name=n;
}
public String getName(){
return name;
}
public void setAge(int a){
age=a;
}
public int getAge(){
return age;
}
//成员方法
权限修饰符 返回值类型 方法名（数据类型 参数名1， 数据类型 参数名2...）{
方法体;
return 返回值;
}
//吃饭
public void eat(String food){
System.out.println(name+"正在吃"+food);
}
public void sleep(){
System.out.println(name+"正在睡觉");
}
}
public class void main(String[] args){
Person p = new Person();
//为成员变量赋值
p.setName("张三");
p.setAge(23);
//获取值
String name = p.getName();
int age = p.getAge();
System.out.println("姓名是：" + name + "年龄是：" + age);
}
7、方法的重载
7.1 什么是方法的重载
方法名称相同
方法的参数列表不同（参数的个数不同、参数的数据类型不同、参数顺序不同）
与返回值类型无关
public class sum(int num1,int num2){
int rem=num1+num2;
return rem;
}
public class sum(int num1,int num2,int num3){
int rem=num1+num2+num3;
return rem;
}
8、方法的递归
8.1 定义
方法的递归是指在一个方法的内部调用自身的过程。递归必须要有结束条件，不然就会陷入无限递归的状态，永远无法结束调用。
8.2 注意
1、递归次数不宜过多
2、递归一定要有出口（结束条件）
//5到1之间的数字之和
public static int getSum(int num)
{
if(num==1)
{
return 1;
}
return num + getSum(num-1);
}
9、构造方法
9.1 含义
实例化一个类的对象后，如果要为这个对象中的属性赋值，则必须通过直接访问对象的属性或调用setXxx()方法的方式才可以。如果需要在实例化对象的同时就为这个对象的属性进行赋值，可以通过构造方法来实现。
9.2 定义
构造方法（也被称为构造器）是类的一个特殊成员，它会在类的实例化对象时被自动调用。
9.3 构造方法的定义格式
定义格式：
权限修饰符 方法名(){
方法体;
}
1、方法名和类名要保持一致
2、构造方法没有返回值类型。连void都不能写
3、构造方法中不能写return语句
9.4 注意事项
如果我们自己没有写任何的构造方法。系统会默认提供一个无参数的构造方法。供我们创建对象使用。
如果我们自己写了一个构造方法，那么系统就不再提供空参的构造方法了。
9.5 相关代码
public class Person{
public Person(){
....
}
}
10、构造方法的重载
public class Demo{
public static void main(String[] args)
{
//创建对象
Person p = new Person("李四",24);
}
}
public class Person{
private String name;
private int age;
public Person(String n,int a){
System.out.println("有参的构造方法执行了");
name = n;
age = a;
}
}
11、this关键字
1、可以区分局部变量和成员变量同名的问题
2、代表的是当前对象的引用。谁来调用我，我就代表谁。
public class Person{
//成员变量
private String name; //人的姓名
private int age; //人的年龄
public Person(){
this("王五",25); //调用本来的其他构造方法
System.out.println("吃饭啦....");
}
public Person(String name, int age)
{
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
System.out.println("姓名是：" + name + "年龄是：" + age);
public void eat()
{
System.out.println("吃饭啦....");
}
}
toString方法将值转换成字符串，并且返回相应的结果。
12、静态变量(static关键字)
java中的static关键字，用于修饰类的成员，如成员变量、成员方法以及代码块等，被static关键字修饰的成员变量、方法可以被类直接访问，而不需要预先构造类的实例化对象。（不能修饰局部变量）
12.1 作用
修饰变量。变量可以被所有对象所共享
12.2 什么时候将变量定义成静态的呢？
当一个变量需要被类中的所有对象所共享的时候，赋值一次即可。
public class Person{
//成员变量
private String name; //人的姓名
private int age; //人的年龄
static int schoolname;
等等......
}
13、静态方法
静态方法可以直接被类名所访问
静态属于类。随着类的加载而加载
非静态属于对象。随着静态的创建而加载
静态与非静态的访问特点
静态的只能访问静态的
非静态的就可以访问静态的，也可以访问非静态的
14、代码
创建一个Demo1类
public class Utils{
public void method(){
System.out.println("我是一个非静态的方法");
}
public static void function(){
System.out.println("我是一个静态的方法");
}
}
创建一个Demo类
public class Demo{
public static void main(String[] args)
{
Utils.function();
//创建对象
Utils u = new Utils();
u.method();
}
14、静态代码块
java中使用一对大括号包围起来的若干行代码被称为一个代码块。
使用static关键字修饰的代码块称为静态代码块。
当类被加载时，静态代码块会执行，并且只会执行一次。
在程序中，经常使用静态代码块来对类的成员变量进行初始化。
14.1 使用
当类加载时就会被执行了
只会执行一次
14.2 作用
注册驱动，加载资源
14.3 代码
创建一个Demo1类
public class Demo1{
static{
System.out.println("我是静态代码块");
}
}
创建一个Demo类
public class Demo{
public static void main(String[] args)
{
Demo1 p = new Demo1();
}
}
