Java面向对象高级【类与对象】

文章思维导图

前提摘要

访问修饰符

类和对象的内存分配机制

• java内存的结构分析

  1. 栈：一般存放基本数据类型(局部变量)
  2. 堆：存放对象(Cat cat,数组等)
  3. 方法区：常量池(常量,比如字符串)，类加载信息

• java创建对象的流程分析

  Person p = new Person();
  p.name = "jack";
  p.age = 10;
  

  1. 先加载Person类信息(属性和方法信息，只会加载一次)
  2. 在堆众分配空间，进行默认初始化
  3. 把地址赋给p，p就指向对象
  4. 进行指定初始化，比如p.name = “jack”；p.age = 10

类变量(静态变量)

类变量可以通过类名来访问

1. static 变量是同一个类所有对象共享
2. static类变量，在类加载的时候就生成了

类方法(静态方法)

类方法可以通过类名来访问

注意：

• 类方法中不允许使用和对象有关的关键字，比如this和super
• 类方法中只能访问静态变量或静态方法

main方法

1. main方法是虚拟机调用
2. java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public
3. java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static
4. 该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数
5. java执行的程序 参数1 参数2 参数3…

代码块

代码化块称为初始化块，属于类中的成员[即 类的一部分]，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来，可用于对对构造器的一种补充

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

[修饰符]{
    代码
};

注意：

1. 修饰符 可选，要写的话，也只能写static
2. 代码块分为静态代码块和普通代码块
3. 如果只是使用类的静态成员时，普通代码块并不会执行
4. ; 号可以写上，也可以省略。

细节[重点]：

1. static代码块也叫静态代码块，随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行

2. 类的执行：

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

3. 普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次。如果只是使用类的静态成员时，普通代码块并不会执行

4. 创建一个对象时，在一个类调用顺序(重点)

注意:

静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用

  1.  调用静态代码块和静态属性初始化  
  2.  调用普通代码块和普通属性的初始化
  3.  调用构造方法

4. 每个构造器的最前面都隐藏了super()和 调用普通代码块。静态相关的代码块，属性初始化，在类加载时就执行完毕

   1. (难点)存在继承关系时，代码块顺序：
   2. 父类的静态代码块和静态属性
   3. 子类的静态代码块和静态属性
   4. 父类的普通代码块和普通属性的初始化
   5. 父类的构造方法
   6. 子类的普通代码块和普通属性的初始化
   7. 子类的构造方法

5. 静态代码块只能直接调用静态成员，普通代码块可以调用任意成员

---

面向对象概述

封装

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

注意事项：

1. 将属性进行私有化private【不能直接修改属性】

2. 提供一个公共的（public）set方法，用于对属性判断并赋值

   public void setXxx(类型 参数名){// Xxx 表示某个属性
       // 加入数据验证的业务逻辑
       属性 = 参数名;
   }
   

3. 提供一个公共的（public）get方法，用于获取属性的值

   public XX getXxx(){// 权限判断
       return xx;
   }
   

继承

继承是类与类的一种关系，是一种“is a”的关系

注意事项

1. 子类继承了所有的属性和方法，但是私有方法不能再子类直接访问，要通过公有方法去访问

2. 子类必须调用父类的构造器，完成对父类的初始化

3. 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过。

4. 如果希望指定去调用父类的某个构造器，则显式的调用一下:super(参数列表)

5. super在使用时，必须要放在构造器的第一行(super只能放在构造器中使用)

6. super()和this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器

7. java所有类都是Object类的子类，Object是所有类的基类

8. 父类构造器的调用不限于直接父类！将一直往上追溯知道Object类(顶级父类)

9. 子类最多只能继承一个父类(指直接继承)，即java中是单继承机制

10. 不能滥用继承，子类和父类之间必须满足is-a的逻辑关系

多态

对象的多种形态

核心、困难、重点

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

// 案例
Animal animal = new Dog();【animal 编译类型是Animal，运行类型Dog】
animal = new Cat();【animal 的运行类型变成了Cat，编译类型仍然是Animal】

细节

• 多态的前提是：两个对象(类)存在继承关系
• 多态的向上转型(父类指向子类，就像把子类向上提)
  • 特点：
    • 可以调用父类中的所有成员(需要遵守访问权限)
    • 不能调用子类中特有成员(在编译阶段，能调用哪些成员，是由(编译器)编译类型来决定的)
    • 最终运行效果看子类 的具体实现！
• 多态的向下转型
  • 语法：子类类型 引用名 = (子类类型) 父类引用;
  • 只能强转父类的引用，不能强转父类的对象
  • 要求父类的引用必须指向的是当前目标类型的对象
  • 可以调用子类类型中所有的成员

注意

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

java的动态绑定机制(非常重要)

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

多态的应用

1. 多态数组：数组的定义类型为父类类型，里面保存的实际元素类型为子类类型

2. 多态参数：方法定义的形参类型为父类类型，实参类型允许为子类类型

---

抽象类细节

1. 抽象类不能被实例化
2. 抽象类不一定要包含 abstract 方法，抽象类也可以没有abstract方法
3. 一旦类包含了abstract方法，则这个类必须声明为abstract类
4. abstract只能修饰类和方法，不能修饰属性和其他
5. 抽象方法不能有主体
6. 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非他自己也声明为abstract类
7. 抽象方法不能使用private、final和static来修饰，因为这些关键字都是和重写相违背的

---

接口

基本

在jdk7.0前，接口的所有方法都没有方法体，即抽象方法；在jdk8.0后接口可以有静态方法，默认方法，即接口中可以有默认方法的具体实现 (默认方法需要则在前面加上default关键字)

接口就是给出一些没有实现的方法,封装到一起,到某个类要使用的时候,再根据具体的情况把这些方法写出来

interface 接口名{
    //属性
    //方法
}

class 类名 implements 接口{
    自己属性;
    自己方法;
    必须实现的接口的抽象方法;
}

细节

快速实现接口重写：alt+enter

1. 接口不能被实例化
2. 接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰
3. 一个普通类实现接口，就必须将该接口的所有方法都实现
4. 抽象类实现接口，可以不用实现接口的方法
5. 一个类可以同时实现多个接口
6. **接口中的属性，只能说final的，而且是public static final 修饰符。**比如：int a=1；实际上是public static final int a=1；(必须初始化)
7. 接口中属性的访问形式：接口名.属性名
8. 接口不能继承其他的类，但是可以继承多个别的接口
9. 接口的修饰符只能是public和默认的

接口的多态特性

1. 多态参数 (接口引用可以指向实现了接口的类的对象实例)

2. 多态数组

3. 动态传递现象

   如果 IG 继承了 IH 接口，而Teacher 类实现了 IG 接口，那么，实际上就相当于 Teacher 类也实现了 IH 接口

---

内部类

最大特点：可以直接访问私有属性，并且体现类与类之间的包含关系

分类

定义在外部类局部位置上(如方法内)

1. 局部内部类(有类名)
2. 匿名内部类(没有类名，重点！！！)

定义在外部类的成员位置上

1. 成员内部类(没有static修饰)
2. 静态内部类(使用static修饰)

使用

局部内部类(本质仍然是一个类)

定义在外部类的局部位置，比如方法中，并且有类名

1. 可以直接访问外部类的所有成员，包含私有的
2. 不能添加访问修饰符，因为它的地位就是一个局部变量，局部变量是不能使用修饰符的，但是可以使用final修饰，因为局部变量也可以使用final
3. 作用域：仅仅在定义它的方法或代码块中
4. 外部类在方法中，可以创建(必须在作用域内)内部类的对象，然后直接调用方法即可
5. 如果外部类和局部内部类的成员重名时，默认遵守就近原则，如果想访问外部类的成员，使用（外部类名.this.成员）去访问

匿名内部类（！！！！）

1. 本质上是一个类
2. 内部类
3. 没有名字(名字由底层jdk分配)
4. 同时还是一个对象

匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名

语法

new 类或接口(参数列表){
    类体
};

细节

1. jdk底层在创建匿名内部类 Outer01$1，立即马上就创建了 Outer01$1实例，并且把地址返回给对应的类
2. 匿名内部类使用一次，就不能再使用了
3. 可以直接访问外部类的所有成员，包含私有的
4. 不能添加访问修饰符，因为它的地位就是一个局部变量，局部变量是不能使用修饰符的，但是可以使用final修饰，因为局部变量也可以使用final
5. 作用域：仅仅在定义它的方法或代码块中
6. 如果外部类和局部内部类的成员重名时，默认遵守就近原则，如果想访问外部类的成员，使用（外部类名.this.成员）去访问

成员内部类

定义在外部类的成员位置，并且没有static修饰

1. 可以直接访问外部类的所有成员，包括私有
2. 可以添加任意访问修饰符(public、protected、默认、private)，因为它的地位就是一个成员

外部其他类调用内部类的三种方式

1. class 外部其他类{
       外部类.内部类 名称 = 外部类名.new 内部类();
   }
   

2. public static void main(String[] args) {
       test t = new test();
       Inner inner = t.new Inner();
   }
   

3. 在外部类中，编写一个方法，可以返回内部类的对象

静态内部类

定义在外部类的成员位置，并且有static修饰

1. 可以直接访问外部类的所有静态成员，包含私有的，但是不能直接访问非静态成员
2. 可以可以添加任意访问修饰符，因为它的地位就是一个成员
3. 同其他的成员，为整个类体

---

扩展

object类详解

equals方法

==和equals的对比

== 是一个比较运算符

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

hashCode方法

1. 提高具有哈希结构容器的效率
2. 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
3. 两个引用，如果指向的是不同对象，则哈希值是不一样的(有极小概率会一样)
4. 哈希值主要是根据地址号来的，但不能完全将哈希值等价与地址
5. 集合中会用到

toString方法

• 默认返回：全类名(包名+类名)+@+哈希值的十六进制
• 重写toString方法
• 当直接输出一个对象时，toString方法会被默认调用

finalize方法

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

super关键字

基本语法

super代表父类的引用,用于访问父类的属性、方法、构造器

1. 访问父类的属性，但不能访问父类的private属性
   • super.属性名;
2. 访问父类的方法，不能访问父类的private方法
   • super.方法名(参数列表);
3. 访问父类的构造器
   • super(参数列表); 只能放在构造器的第一句，只能出现一句！

注意:

1. 默认情况下不写,则默认调用父类的无参构造器
2. super 不能和 this 写在同一个构造器里

super给编程带来的便利/细节

1. 调用父类的构造器的好处(分工明确，父类属性由父类初始化，子类的属性由子类初始化)
2. 当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super、this和直接访问效果一样

final关键字细节

1. final修饰的属性又叫常量，一般用XX_XX_XX来命名

2. final修饰的属性在定义时必须赋初值，并且以后不能再修改，赋值可以在如下位置：

   1. 定义时
   2. 在构造器中
   3. 在代码块中

3. 如果final修饰的属性是静态的，则初始化的位置只能

   1. 定义时
   2. 在静态代码块中
   3. 不能在构造器中赋值

4. final类不嫩继承，但是可以实例化对象

5. 如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承

6. 一般，如果一个类是final类，就没有必要再将方法修饰成final方法

7. final不能修饰构造方法(构造器)

8. final和static往往搭配使用，效率更高，不会导致类的加载，底层编译器做了优化处理

   class Demo{
       public static final int i = 16;
       static{
           System.out.println("你好");
       }
   }