Chapter07

IDEA快捷键

1. 删除当前行 ctrl + y
2. alt + / 补全代码
3. ctrl + d 复制
4. ctrl + alt +L 格式化代码
5. alt + insert生成
6. ctrl + H查看一个类的层级关系
7. sout ⇒ System.out.println()
8. fori ⇒ for循环

包

访问修饰符

用于控制方法和属性(成员变量)的访问范围

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

不同包里的子类也可以访问protected里的

面向对象三大特征

封装

封装（encapsulation）就是把抽象出的

数据[属性]和对数据的操作[方法]封装在一起，

数据被保护在内部，

程序的其它部分只有通过被授权的操作[方法]，才能对数据进行操作。

1. 隐藏实现细节,方法(连接数据库)←- 调用(传参数)
2. 可以对数据进行验证,保证安全合理

封装实现步骤

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

2) 提供一个公共的（public）set方法，

用于对属性判断并赋值

public void setXxx（类型 参数名）{/Xxx表示某个属性

//加入数据验证的业务逻辑

属性 = 参数名;}

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

public 数据类型 getXxx(){//权限判断,Xxx表某个属性
return xx;}

封装与构造器

将构造器与setXxx结合

在构造器里调用set方法,避免了绕过的问题

继承

继承可以解决代码复用

当多个类存在相同的属性（变量）和方法时，

可以从这些类中抽象出父类，

在父类中定义这些相同的属性和方法，

所有的子类不需要重新定义这些属性和方法，

只需要通过extends来声明继承父类即可。

继承细节

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

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

   隐藏了一句super();

   父类的构造器

   

   子类的构造器

   

   对子类创建对象

   

   输出结果

   

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

   父类的无参构造器被覆盖

   

   必须在子类中用super来指定使用父类的自定义的构造器

   

4. 如果希望指定去调用父类的某个构造器，则显式的调用一下！super(参数列表);
5. super在使用时，必须放在构造器第一行
6. super()和this（都只能放在构造器第一行，因此这两个方法不能共存在一个构造器)

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

   

8. 父类构造器的调用不限于直接父类 将一直往上追溯直到object类（顶级父类）

   

9. 子类最多只能继承一个父类（指直接继承），即java中是单继承机制。如何让A类继承B类和C类？

   

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

继承的本质

案例

我们看一个案例来分析当子类继承父类，创建子类对象时，内存中到底发生了什么？

当子类对象创建好后，建立查找的关系

访问规则

继承练习

Super关键字

super代表父类的引用，

用于访问父类的

1. 属性

1. 方法

1. 构造器

Super细节

1. 调用父类的构造器的好处（分工明确，父类属性由父类初始化，子类的属性由子类初始化)

2. 当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super、this、直接访问是一样的效果.

   this和直接访问要先看本类有没有

   super是直接调用父类的方法

   如果查找属性的过程中，找到了，但是不能访问，则报错，cannotaccess

                                    **方法**
   

   

   

   

   

                                   **属性**
   

   

   

   

3. super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类（上级类）中都有同名的成员，使用super访问遵循就近原则。A->B->C

方法重写/覆盖

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

细节

1. 子类的方法的形参列表,方法名称，要和父类方法的形参列表，方法名称完全一样。

2. 子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类 比如父类返回类型是Object，子类方法返回类型是String【演示】

   

   String是Object的子类

3. 子类方法不能缩小父类方法的访问权限

   

   

   但是可以扩大父类的访问权限

   

                  **重载与重写的对比**
   

   

多态

引出多态

这样代码复用性不高,不利于维护

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

1. 方法的多态

   重写和重载就体现多态

   

   

   

   

2. 对象的多态

   1. 一个对象的编译类型和运行类型可以不一致

      父类可以new一个子类

      animal是对象的引用,右边是具体new的对象

      

   2. 编译类型在定义对象时就确定了，不能改变
   3. 运行类型是可以变化的 ⇒⇒ ⇒⇒ ⇒⇒ 编译类型可以变换指向的地址
   4. 编译类型看定义时=号的左边，运行类型看=号的右边

   

多态细节

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

                    多态的向上转型

1) 本质: 父类的引用指向了子类的对象

2）语法：父类类型 引用名=new 子类类型()

3) 特点: 编译类型看左边，运行类型看右边。

可以调用父类中的所有成员（需遵守访问权限），不能调用子类中特有成员(因为在编译阶段，能调用哪些成员，是由编译类型来决定的)最终运行效果看子类的具体实现！

                    多态的向下转型

 向下转型是将父类的引用转换为子类的引用

1）子类类型 引用名 =（子类类型）父类引用；

2）只能强转父类的引用，不能强转父类的对象

3）父类的引用必须指向的是当前目标类型的对象

  ⇒⇒⇒⇒⇒⇒⇒⇒前提(必须是使用了向上转型后)

⇒⇒⇒⇒原本的父类的引用就指向这个目标子类

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

属性不能重写,属性的值看编译类型

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

多态练习

方法的值看运行类型

属性的值看编译类型

动态绑定机制

1. 当调用对象方法的时候，该方法会和该对象的内存地址(运行类型)绑定

1. 当调用对象属性时，没有动态绑定机制，哪里声明，那里使用

多态数组

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

执行子类特殊方法

多态参数

1. 方法定义的形参类型为父类类型，

   实参类型允许为子类类型
   

Object类详解

类object是类层次结构的根类。每个类都使用object作为超类。所有对象（包括数组）都实现这个类的方法。

equals方法

==和equals的对比

== 是一个比较运算符

1. ==既可以判断基本类型,也可以判断引用类型
2. ==如果判断基本类型，判断的是值是否相等。

3. ==如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象

   

equals方法

是Qbject类中的方法，默认只能判断引用类型

但是基本类型对equals方法进行了重写,变成了判断是否值相等

hash Code

1. 提高具有哈希结构的容器的效率

2. 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的.

   

3. 哈希值主要根据地址号来的，不能完全将哈希值等价于地址。
4. 在集合中,hashCode如果需要,也会重写

toString方法

默认返回：全类名(包名+类名)+@+哈希值的十六进制，

重写toString方法,打印对象或者拼接对象时,都会自动调用该对象的toString形式

当直接输出对象时，toString方法会被默认的调用

finalize方法

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

断点调试

重要提示：：在断点调试过程中，是运行状态，是是以对象的运行类型来执行的

F7:跳入方法内

F8:逐行执行代码

SHIFT+F8:跳出方法

F9:跳到下一个断点

可以在debug过程中,动态下断点,Resume跳到下一个断点

本章作业

15.什么是多态，多态具体体现有哪些？（可举例说明）

多态：方法或对象具有多种形态，是OOP的第三大特征，是建立在封装和继承基础之上

多态具体体现

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

16.java的动态绑定机制是什么？

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

• Previous
  Java-Phase01-Chapter06
• Next
  Java-Phase01-Chapter08