8.面向对象编程（中级部分）|Java学习笔记

IDEA介绍

1. 删除当前行, 默认是 ctrl + Y 自己配置 ctrl + d
2. 复制当前行, 自己配置 ctrl + alt + 向下光标
3. 补全代码 alt + /
4. 添加注释和取消注释 ctrl + / 【第一次是添加注释，第二次是取消注释】
5. 导入该行需要的类 先配置 auto import , 然后使用 alt+enter 即可
6. 快速格式化代码 ctrl + alt + L
7. 快速运行程序 自己定义 alt + R
8. 生成构造器等 alt + insert [提高开发效率]
9. 查看一个类的层级关系 ctrl + H [学习继承后，非常有用]
10. 将光标放在一个方法上，输入 ctrl + B , 可以定位到方法 [学继承后，非常有用]
11. 自动的分配变量名 , 通过 在后面加 .var [老师最喜欢的]

可以自己去自定义：
快捷键 Keymap
模板 Live Templates

包

包的基本语法：

package com.fw;

说明：1. package 关键字，表示打包； 2. com.fw 表示包名

包的命名：只能包含数字、字母、下划线、小圆点，但是不能用数字开头，不能是关键字或保留字。

---

引用包的语法：

import 包;

我们引入一个包的主要目的是要使用该包下的类，所以也可以只引入一个类，例如：

import java.util.Scanner;	// 只引入一个类
import java.util.*;		// 表示将java.util 包所有都引入

注意事项和使用细节

1. package 的作用是声明当前类所在的包，需要放在类的最上面，一个类中最多只有一句 package。
2. import 指令 位置放在 package 的下面，在类定义前面，可以有多句且没有顺序要求。

包的三大作用

1. 区分相同名字的类
2. 当类很多时，可以很好的管理类
3. 控制访问范围

包的本质分析（原理）

包的本质 实际上就是创建不同的文件夹/目录来保存类文件。

一个包下,包含很多的类,java 中常用的包有:

1. java.lang.* //lang 包是基本包， 默认引入， 不需要再引入.
2. java.util.* //util 包， 系统提供的工具包, 工具类， 使用 Scanner
3. java.net.* //网络包， 网络开发
4. java.awt.* //是做 java 的界面开发， GUI

访问修饰符

java 提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限（范围）:

1. 公开级别:用 public 修饰,对外公开
2. 受保护级别:用 protected 修饰,对子类和同一个包中的类公开
3. 默认级别:没有修饰符号,向同一个包的类公开.
4. 私有级别:用 private 修饰,只有类本身可以访问,不对外公开.

范围从小到大依次是：同类、同包、子类、不同包。

这张图可以背下来！

1. 修饰符可以用来修饰类中的属性，成员方法以及类。
2. 只有默认的和 public 才能修饰类！并且遵循上述访问权限的特点。

面向对象编程三大特征

面向对象编程有三大特征：封装、继承和多态。

封装

封装(encapsulation)就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起,数据被保护在内部,程序的其它部分只有通过被授权的操作[方法],才能对数据进行操作。

封装的理解和好处

1. 隐藏实现细节:方法(连接数据库)<–调用(传入参数…)
2. 可以对数据进行验证，保证安全合理

封装的实现步骤（三步）

1. 将属性进行私有化 private [不能直接修改属性]。
2. 提供一个公共的(public)set方法，用于对属性判断并赋值。
3. 提供一个公共的(public)get方法，用于获取属性的值。

Idea快速创建set和get方法 ：Alt+INSERT

可以将 set 方法写在构造器中代替 this.x = x 的操作。

继承

继承可以解决代码复用,让我们的编程更加靠近人类思维.
当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过 extends 来声明继承父类即可。

继承的基本语法

class 子类 extends 父类 {
}

1. 子类就会自动拥有父类定义的属性和方法。
2. 父类又叫超类，基类。
3. 子类又叫派生类。

继承给编程带来的便利

1. 代码的复用性提高了
2. 代码的扩展性和维护性提高了

继承的深入讨论/细节问题

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

继承的本质分析

子类创建的内存布局：

super关键字

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

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

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

1. 调用父类的构造器的好处(分工明确,父类属性由父类初始化，子类的属性由子类初始化)。
2. 当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super、this、直接访问是一样的效果!
3. super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员;如果多个基类(上级类)中都有同名的成员，使用 super 访问遵循就近原则。A->B->C，当然也需要遵守访问权限的相关规则。

super 和 this 的比较

方法重写/覆盖（override）

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

注意事项和使用细节

1. 子类的方法的形参列表，方法名称，要和父类方法的形参列表，方法名称完全一样。
2. 子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类。
   比如父类返回类型是Object,子类方法返回类型是String
3. 子类方法不能缩小父类方法的访问权限 ： public > protected > 默认 > private

方法的 重写和重载 之间的比较：

多态

从一个问题引入：

多【多种】态【状态】基本介绍：
方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。

方法的多态

重写和重载就体现多态。

A a = new A();
// 传入不同的参数，就会调用不同sum方法，就体现多态
System.out.println(a.sum(10, 20));
System.out.println(a.sum(10, 20, 30));

// 方法重写体现多态
B b = new B();
a.say();
b.say();

对象的多态

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

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

多态的前提是：两个对象（类）存在继承关系。

多态的向上转型

1. 本质:父类的引用指向了子类的对象
2. 语法:

父类类型 引用名= new 子类类型();

3. 特点:编译类型看左边，运行类型看右边。
   可以调用父类中的所有成员(需遵守访问权限)，
   不能调用子类中特有成员;
   最终运行效果看子类的具体实现!

父类的引用指向了子类的对象有什么好处？
A：

• 可以实现动态绑定，即在运行时根据对象的实际类型调用相应的方法，而不是根据引用的类型。这样可以让程序更灵活，也可以避免类型转换的麻烦。
• 可以实现抽象化，即只关注对象能做什么，而不关心对象具体是什么。这样可以让程序更简洁，也可以降低程序的耦合度，提高程序的可复用性和可扩展性。
• 可以实现统一接口，即使用父类类型的引用作为方法的参数或返回值，可以接受任何子类类型的对象。这样可以让程序更通用，也可以利用多态实现一些设计模式，如工厂模式、策略模式等。

多态的向下转型

1. 语法:

子类类型 引用名 = (子类类型)父类引用;

2. 只能强转父类的引用，不能强转父类的对象。
3. 要求父类的引用必须指向的是当前目标类型的对象。

Animal animal = new Dog();      // 必须已经指向Dog类型
Dog dog = (Dog)animal;

当向下转型后，可以调用子类类型中所有的成员。

---

属性没有重写之说！属性的值看编译类型。

instanceOf 比较操作符，用于判断对象的运行类型是否为 XX 类型或 XX 类型的子类型。

Java的动态绑定机制

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

多态的应用

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

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

总结：什么是多态，多态的具体体现有哪些？

1. 方法多态
   1. 重载体现多态
   2. 重写体现多态
2. 对象多态
   1. 对象的编译类型和运行类型可以不一致，编译类型在定义时，就确定，不能变化。
   2. 对象的运行类型是可以变化的，可以通过getClass()来查看运行类型。
   3. 编译类型看定义时 = 号的左边，运行类型看 = 号的右边。

Object类详解

equals方法

【Java】深入理解==和equals的对比

1. ==：既可以判断基本类型，又可以判断引用类型。
2. ==：如果判断基本类型，判断的是值是否相等。实例：
3. ==：如果判断引用类型，判断的是地址是否相等，即判定是不是同一对象。
4. equals：是Object类中的方法，只能判断引用类型。（即int i不能使用.equals方法，但Integer i可以）
5. equals：默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等，比如Integer、String等等。

int i = 10;
double d = 10.0;
System.out.println(i == d);		// true

可以自己重写 Object 的 equals 方法。

public boolean equals(Object obj) {
}

hashCode 方法

1. 提高具有哈希结构的容器的效率！
2. 两个引用， 如果指向的是同一个对象， 则哈希值肯定是一样的！
3. 两个引用， 如果指向的是不同对象， 则哈希值是不一样的
4. 哈希值主要根据地址号来的 ， 不能完全将哈希值等价于地址。

public class TestComment {
    public static void main(String[] args) {
        AA aa = new AA();
        System.out.println(aa.hashCode());		// 输出189568618
    }
}

class AA {

}

toString 方法

1. 默认返回： 全类名（包名+类名）+@+哈希值的十六进制， 【查看 Object 的 toString 方法】
   子类往往重写 toString 方法， 用于返回对象的属性信息。
2. 重写 toString 方法， 打印对象或拼接对象时， 都会自动调用该对象的 toString 形式.
3. 当直接输出一个对象时， toString 方法会被默认的调用,
   比如 System.out.println(monster)； 就会默认调用
   monster.toString()

public class TestComment {
    public static void main(String[] args) {
        AA aa = new AA();
        System.out.println(aa.toString());		// AA@b4c966a
    }
}

class AA {
    
}

finaliza 方法

从Java9开始,finalize方法已被标注为@Deprecated,也就是过期了,再往后这个方法就废了,以后面试再也不会被问到finalize方法是干嘛的了!

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