面向对象笔记

面向对象

封装

访问修饰符

访问级别	访问修饰符	同类	同包	子类	不同包
公开	public	√	√	√	√
受保护	protected	√	√	√	×
默认	无修饰符	√	√	×	×
私有	private	√	×	×	×

封装的步骤

1. 将属性私有化 【不能直接修改属性】
2. 提供一个公共的（public）set 方法，用于对属性判断并赋值
3. 提供一个公共的（public）get 方法，用于获取属性的值

继承

继承说明

1. 子类继承了父类所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问。
2. 子类必须调用父类的构造器， 完成父类的初始化。
3. 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无 参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过。
4. 如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数列表) 。
5. super 在使用时，必须放在构造器第一行(super 只能在构造器中使用)。
6. super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器。
7. Java 所有类都是 Object 类的子类, Object 是所有类的基类。
8. 父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类(顶级父类)。
9. 子类最多只能继承一个父类(指直接继承)，即 Java 中是单继承机制。
10. 不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系。

super 关键字

1. 访问父类的属性，但不能访问父类的private属性

   ​ super.属性名;

2. 访问父类的方法，不能访问父类的private方法

   ​ super.方法名(参数列表)

3. 访问父类的构造器

   ​ super(参数列表);只能放在构造器的第一句，只能出现一句！

super 和 this 的比较

方法重写/覆盖（override）

说明：方法是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的方法重写了父类的方法。

方法重写需要满足的条件：

重写和重载比较

名称	发生范围	方法名	参数列表	返回类型	修饰符
重载(overload)	本类	必须一样	类型，个数或者顺序至少有一个不同	无要求	无要求
重写(override)	父子类	必须一样	相同	子类重写的方法，返回的类型和父类返回的类型一致，或者是其子类	子类方法不能缩小父类方法的访问范围

多态

编译类型和运行类型

1. 一个对象的编译类型和运行类型可以不一致。
2. 编译类型在定义对象时就确定了，不能改变。
3. 运行类型可以变化。
4. 编译类型看定义时 = 的左边，运行类型看 = 的右边。

多态细节

多态的前提是：两个对象(类)存在继承关系

多态的向上转型

1. 本质：父类的引用指向子类的对象
2. 语法：父类类型 引用名 = new 子类类型()
3. 特点：编译类型看左边，运行类型看右边。
4. 可以调用父类中的所有成员（需遵守访问权限），不能调用子类中的特有成员。

多态的向下转型

1. 语法：子类类型 引用名 = (子类类型) 父类引用;
2. 只能强转父类的引用，不能强转父类的对象
3. 要求父类的引用必须指向的是当前目标类型的对象
4. 当向下转型后，可以调用子类类型中所有的成员

属性

1. 属性没有重写之说，属性的值看编译类型，方法的调用看运行类型。
2. instanceOf 比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型。

Java 动态绑定机制

1. 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定。
2. 当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用。

public class DynamicBinding {
   
    public static void main(String[] args) {
   
        //a 的编译类型 A, 运行类型 B
        A a = new B();//向上转型
        System.out.println(a.sum());//30
        System.out.println(a.sum1());//20
    }
}
class A {
   //父类
    public int i = 10;
    //动态绑定机制:看a运行类型调用子类B的getI()方法
    public int sum() {
   //父类 sum()
        return getI() + 10;
    }
    public int sum1() {
   //父类 sum1()
        return i + 10;//属性没有动态绑定机制，直接返回当前类的值
    }
    public int getI() {
   //父类 getI
        return i;
    }
}
class B extends A {
   //子类
    public int i = 20;
    // public int sum() {
   
    // return i + 20;
    // }
    public int getI() {
   //子类 getI()
        return i;
    }
    // public int sum1() {
   
    // return i + 10;
    // }
}

Object类详解

== 和 equals 的对比

1. == ：既可以判断基本类型，又可以判断引用类型。
2. == ：如果判断基本类型，判断的是值是否相等。
3. == ：如果判断引用类型，判断的是地址是否相等，即判断是不是一个对象。
4. equals ：是Object类中的方法，只能判断引用类型。
5. 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。

toString 方法

1. 基本介绍：默认返回：全类名+@+哈希值的十六进制，【查看 Object 的 toString 方法】 子类往往重写 toString 方法，用于返回对象的属性信息。

2. 重写 toString 方法，打印对象或拼接对象时，都会自动调用该对象的 toString 形式。

3. 当直接输出一个对象时，toString 方法会被默认的调用。

   比如 System.out.println(monster); 就会默认调用 monster.toString()

finalize 方法

1. 当对象被回收时，系统自动调用该对象的 finalize 方法。子类可以重写该方法，做一些释放资源的操作。
2. 什么时候被回收：当某个对象没有任何引用时，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用 finalize 方法。
3. 垃圾回收机制的调用，是由系统来决定(即有自己的 GC 算法), 也可以通过 System.gc() 主动触发垃圾回收机制。

类变量

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。

定义类变量

访问修饰符 static 数据类型 变量名;[推荐]
static 访问修饰符 数据类型 变量名;

如何访问类变量

类名.类变量名 对象名.类变量名

类变量细节

1. 当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量（静态变量）
2. 类变量是该类的所有对象共享的，实例变量是每个对象独享的
3. 加上static成为类变量或静态变量，否则成为实例变量/普通变量/非静态变量
4. 类变量是在类加载时就初始化了，及时没有创建对象，只要类加载了，就可以使用类变量了
5. 类变量的生命周期是随着类的加载开始，随着类的消亡而销毁。

类方法细节

1. 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区：类方法中无this的参数
2. 类方法可以通过类名调用，也可以通过对象名调用
3. 普通方法和对象有关，需要通过对象名调用，不能通过类名调用。
4. 类方法中不允许使用和对象有关的关键字，比如this和super。
5. 类方法（静态方法）中只能访问静态变量或静态方法。
6. 普通成员方法，既可以访问非静态成员，也可以访问静态成员。

代码块

基本介绍

代码块又称初始代码块，属于类中的成员，类似与方法，通过{}包围起来。
代码块没有方法名，没有返回，没有参数，只有方法体，而且不用通过类加载或类显式调用，而是随着类加载时，或创建对象时隐式调用。

语法

[修饰符]{}
修饰符只能是 static，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块。

代码块细节

1. static代码块(静态代码块)，作用就是对类进行初始化，她随着类的加载而执行，只会执行一次。普通代码块每创建一个对象，就执行一次。

2. 类什么时候被加载

   • 创建对象实例时(new)
   • 创建子类对象实例，父类也会被加载
   • 使用类的静态成员时(静态属性，静态方法)

3. 普通代码块，在创建对象实例时，会被隐式的调用。

   每创建一次，就调用一次，如果只使用类的静态成员，普通代码块不会执行。

类的调用顺序

1. 静态代码块和静态属性初始化
2. 普通代码块和普通属性初始化
3. 构造器&#