面向对象的特征二：继承性


1.为什么要有类的继承性？（继承性的好处）

① 减少代码的冗余，提高了代码的复读性
② 便于功能的扩展
③ 为之后的多态性的使用，提供了前提

图示：
image.png

2.继承性的格式：

class A extends B{}
A：子类、派生类、subclass
B：父类、超类、基类、superclass


3.子类继承父类以后有哪些不同？

3.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类私有的结构。只是因为封装性的影响，使得子类不能直接调用父类的结构而已
3.2子类继承父类之后，还可以声明自己特有的属性或方法，实现功能的拓展
子类和父类的关系，不同于子集和集合的关系
extends：延展、扩展


4.Java中继承性的说明

1.一个类可以被多个子类继承
2.Java中类的单继承性：一个类只能有一个父类
3.子父类是相对的概念
4.子类直接继承的父类称为：直接父类。间接继承的父类称为：间接父类
5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法


图示
image.png

5.java.lang.Object类的理解

1.如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
2.所有的Java类(除java.lang.Object类)都直接或间接继承于java.lang.Object类
3.意味着，所有Java类具有java.lang.Object类声明的功能

方法的重写


1.什么是方法的重写(override/overwrite)？

子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作


2.应用：

重写以后，当创建子类对象以后，通过子类对象调用父类中的同名同参的方法时，实际执行的是子类重写父类的方法


3.举例：

  1. class Circle{
  2.     public double fineArea(){}//求面积
  3. }
  5. class Cylinder extends Cricle{
  6.     public double findArea(){}//求表面积
  7. }
  9. class Account{
  10.     public boolean withdraw(double amt){}
  11. }
  13. class CheckAccount extends Account{
  14.     public boolean withdraw(double amt){}
  15. }


4.重写的规则

方法的声明：权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{
方法体
}
约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符 特殊情况：子类不能重写父类中声明为private权限的方法
③ 返回值类型：
父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能说void
父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类 父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)

④ 子类重写的方法抛出的异常类型不大于父类重写的方法抛出的异常类型（具体放到异常处理来讲）


5.面试题：
区分方法的重载和重写
答：

① 二者的概念：
② 重载和重写的具体规则
③ 重载：不表现为多态性
重写：表现为多态性

image.png

关键字：super


1.super关键字可以理解为：父类的

2.可以用来调用的结构：
属性、方法、构造器

3.super调用属性、方法：

3.1我们可以在子类的方法或构造器中，通过使用“super.属性”或“super.方法”的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略“super.”
3.2特殊情况：当子类和父类中定义了同名的属性时，我们要在子类中调用父类中声明的属性，则必须显式的使用“super.属性”的方式，表明调用的是父类中声明的属性
3.3特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用“super.方法”的方式，表明调用的是父类中被重写的方法


4.super调用构造器：

4.1我们可以在子类的构造器中显式的使用“super(形参列表)”的方式，调用父类中声明的指定的构造器
4.2“super(形参列表)”的使用，必须声明在子类构造器的首行
4.3我们在类的构造器中，针对于“this(形参列表)”或“super(形参列表)”只能二选一，不能同时出现
4.4在构造器的首行，没有显式的声明“this(形参列表)”或“super(形参列表)”，则默认调用的是父类中的空参的构造器：super()
4.5在类的多个构造器中，至少有一个类的构造器中使用了“super(形参列表)”，调用父类中的构造器

子类对象实例化全过程（理解即可）


1.从结果上看：继承性

子类继承父类以后，就获取了父类中声明的属性和方法
创建子类的对象，在堆空间中，就会加载所有父类中声明的属性


2.从过程来看：

  1. 当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类构造器，...直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才看到内存中有父类的结构，子类对象才可以考虑进行调用


图示：
image.png

3.特别说明：

虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象
image.png

面向对象的特征三：多态性


1.多态性的理解：可以理解为一个事物的多种形态

2.何为多态性：对象多态性：父类的引用指向子类的对象
（或子类的对象赋给父类引用）

举例：

  1. Person p = new Man();
  2. Object obj = new Data();


3.多态性的使用：虚拟方法调用

有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法
总结：编译，看左边；运行，看右边


4.多态性的使用前提：

① 要有类的继承关系 ② 要有方法的重写


5.多态性的应用举例：

  1. 举例一：
  2. public void func(Animal animal) {//Animal animal = new Dog();
  3.     animal.eat();
  4.     animal.shout();
  5. }
  7. 举例二：
  8. public void method(Object obj) {
  10. }
  12. 举例三：
  13. public void doData(Connection coon) {
  14. //conn = new MySQLconnection()
  15.             //规范的步骤去操作
  17. }

6.多态性使用的注意点：

对象的多态性：只适用于方法，不适应属性(编译和运行都看左边)


7.关于向上转型和向下转型：

7.1 向上转型：多态

7.2 向下转型：
7.2.1 为什么使用向下转型：

  1. 有了对象的多态性以后，内存中实际上是加载了子类持有的属性和方法的，但是由于变量声明为父类类型导致编译时，只能调用父类中声明的属性和方法、子类持有的属性和方法不能调用。如何才能调用子类特有的属性和方法？使用向下转型

7.2.2 如何实现向下转型：
使用强制类型转换符: ( )

7.2.3 使用时的注意点：

① 使用强转时，可能出现ClassCastException的异常
② 为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型，如果返回false，不进行向下转型

7.2.4 instanceof 的使用：

① a instanceof A : 判断对象a是否是类A的实例，如果是返回true，如果不是返回false
② 如果 a instanceof A返回true，则 a instanceof B也返回true
其中，类B是类A的父类
③ 要求x所属的类与类A必须是子类和父类的关系，否则编译错误


7.2.5图示
image.png

8.面试题：

8.1谈谈你对多态性的理解？

① 实现代码的通用性
② Object类中定义的public boolean equals(Object obj){ }
JDBC: 使用Java程序操作(获取数据库连接、CRUD)数据库(MySQL、Oracle、DB2、SQL Server)
③ 抽象类、接口的使用肯定体现了多态性。(抽象类、接口不能实例化)


8.2多态是编译时行为还是运行时行为？

Object类的使用


1.java.lang.Object类的说明：

1.Object类是所有Java类的根父类
2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
3.Object类中的功能（属性、方法）就具有通用性
属性：无
方法：equals() / toString() / getClass() / hashCode() / clone() / finalize()
wait()、notify()、notifyAll()
4.Object类只声明了一个空参构造器

2.equals()方法

2.1 equals()的使用：

1.是一个方法，而非运算符
2.只能适用于引用数据类型
3.Object类中equals()的定义：

  1. public boolean equals(Object obj) {
  2.     return (this == obj);
  3. }


说明：Object类中定义的equals()和==作用是相同的：比较两个对象的地址值是否相同。即两个引用是否指向同一个对象实体


4.像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的“实体内容”是否相同
5.通常情况下：我们自定义的类如果使用equals()的话，也通常是比较两个对象的“实体内容”是否相同，那么，我们就需要对Object类中的equals()进行重写
重写的原则：比较两个对象的实体内容(即：name和age)是否相同


2.2如何重写equals()

2.2.1手动重写举例：

  1. class User{
  2.     String name;
  3.     int age;
  4.     //重写其equals()方法
  5.     public boolean equals(Object obj){
  6.         if(obj == this){
  7.             return true;
  8.         }
  9.         if(obj instanceof User){
  10.             User u = (User)obj;
  11.             return this.age == u.age && this.name.equals(u.name);
  12.         }
  13.         return false;
  14.     }
  15. }


2.2.2开发中如何实现：自动生成的

  1. @Override  
  2. public boolean equals(Object o) {
  3.     if (this == o) return true;
  4.     if (o == null || getClass() != o.getClass()) return false;
  5.     Customer customer = (Customer) o;
  6.     return age == customer.age && Objects.equals(name, customer.name);
  7. }


2.3回顾 == 运算符的使用：

== ： 运算符

1.可以使用在基本数据类型变量和引用数据类型变量中
2.如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
如果比较的是引用数据类型变量：比较两个对象的地址值是否相同。即两个引用是否指向同一个对象实体
补充： == 符号使用时，必须保证符号左右两边的变量类型一致


3.toString()方法

3.1 toString()的使用：

1.当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
2.Object类中toString()的定义：
public String toString() {
return getClass().getName() + “@” + Integer.toHexString(hashCode());
}
3.像String、Date、File、包装类都重写了Object类中的toString()方法使得在调用对象的toString()时，返回“实体内容”信息
4.自定义类也可以重写toString()方法，当调用此方法时，返回对象的“实体内容”


3.2如何重写toString()
举例：

  1. //自动生成
  2. @Override  
  3. public String toString() {
  4.     return "Customer{" +
  5.             "name='" + name + ''' +
  6.             ", age=" + age +
  7.             '}';
  8. }


4.面试题：

① final、finally、finalize的区别？
② == 和 equals()的区别

单元测试方法


Java中的JUnit单元测试

步骤：
1.选中当前工程 - 右键选择：build path - add libraries - JUnit 4 - 下一步
2.创建Java类，进行单元测试
此时的java类要求：① 此类是public的 ② 此类提供公共的无参构造器
3.此类中声明单元测试方法
此时单元测试方法：方法的权限是pubic，没有返回值，没有形参
4.此单元测试方法上需要声明注解：@Test，并在单元测试类中导入：import org.junit.jupiter.api.Test;
5.声明好单元测试方法以后，就可以在方法体内测试相关代码
6.写完代码以后，左键双击单元测试方法名，右键：run as - JUnit Test
说明：
1.如果执行结果没有任何异常：绿条
2.如果执行结果出现异常：红条

包装类的使用


1.为什么要用包装类（或封装类）

为了使基本数据类型具有类的特征，引入包装类


2.基本数据类型与对应的包装类：
image.png

3.需要掌握的类型间的转换：（基本数据类型、包装类、String）
image.png

简易版：

基本数据类型<—>包装类：JDK5.0新特性：自动装箱与自动拆箱
基本数据类型、包装类  String：调用String重载的valueOf(Xxx xxx)
String  基本数据类型、包装类：调用包装类的parseXxx()
注意：转换时，可能会报NumberFormatException


应用场景举例：

① Vector类中关于添加元素，只定义了形参为Object类型的方法
v.addElement(Object obj);//基本数据类型  包装类  使用多态

Debug调试

image.png