Java学习：面向对象（二）

水深无声 2023-09-30 21:50 48阅读 0赞

#### 目录 ####

*  五、面向对象(二)
 *   *  5.1 关键字：this
     *   *  5.1.1 this使用场景
     *  5.2 特征二：继承(Inheritance)
     *  5.3 方法的重写（override/overwrite）
     *   *  方法的重载与重写
     *  5.4 关键字：super
     *   *  5.4.1 super的使用场景
         *  5.4.2 this与super
         *  子类对象实例化全过程
     *  5.5 特征三：多态性
     *   *  5.5.1 多态的形式和体现
         *  5.5.2 多态的好处和弊端
         *  5.5.3 虚方法调用(Virtual Method Invocation)
         *  5.5.4 成员变量没有多态性
         *  5.5.5 向上转型与向下转型
         *  5.5.6 关键字：instanceof
         *  \*\*练习：笔试&面试\*\*
     *  5.6 Object 类的使用
     *   *  5.6.1 Object类的方法
         *   *  1、(重点)equals()
             *  2、(重点)toString()
             *  3、clone()
             *  4、finalize()
             *  5、getClass()
             *  6、hashCode()
         *  5.6.2 关键字：native

## 五、面向对象(二) ##

### 5.1 关键字：this ###

*  在Java中，this关键字不算难理解，它的作用和其词义很接近。
    
     *  它在方法（准确的说是实例方法或非static的方法）内部使用，表示调用该方法的对象
     *  它在构造器内部使用，表示该构造器正在初始化的对象。
 *  this可以调用的结构：成员变量、方法和构造器

#### 5.1.1 this使用场景 ####

**①实例方法或构造器中使用当前对象的成员**

在实例方法或构造器中，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的可读性。不过，通常我们都习惯省略this。

但是，当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量。即：我们可以用this来区分`成员变量`和`局部变量`。比如：  
![在这里插入图片描述][6aab098af5b94058bc5dd4ef187eb895.png]

另外，使用this访问属性和方法时，如果在本类中未找到，会从父类中查找。

举例1：

class Person{
        		// 定义Person类
    	private String name ;	
    	private int age ;			
    	public Person(String name,int age){
        	
    		this.name = name ;   
    		this.age = age ;  
        }
        public void setName(String name){
        
            this.name = name;
        }
        public void setAge(int age){
        
            this.age = age;
        }
    	public void getInfo(){
        	
    		System.out.println("姓名：" + name) ;
    		this.speak();
    	}
    	public void speak(){
        
    		System.out.println(“年龄：” + this.age);	
    	}
    }

举例2：

public class Rectangle {
        
        int length;
        int width;
    
        public int area() {
        
            return this.length * this.width;
        }
    
        public int perimeter(){
        
            return 2 * (this.length + this.width);
        }
    
        public void print(char sign) {
        
            for (int i = 1; i <= this.width; i++) {
        
                for (int j = 1; j <= this.length; j++) {
        
                    System.out.print(sign);
                }
                System.out.println();
            }
        }
    
        public String getInfo(){
        
            return "长：" + this.length + "，宽：" + this.width +"，面积：" + this.area() +"，周长：" + this.perimeter();
        }
    }

测试类：

public class TestRectangle {
        
        public static void main(String[] args) {
        
            Rectangle r1 = new Rectangle();
            Rectangle r2 = new Rectangle();
    
            System.out.println("r1对象：" + r1.getInfo());
            System.out.println("r2对象：" + r2.getInfo());
    
            r1.length = 10;
            r1.width = 2;
            System.out.println("r1对象：" + r1.getInfo());
            System.out.println("r2对象：" + r2.getInfo());
    
            r1.print('#');
            System.out.println("---------------------");
            r1.print('&');
    
            System.out.println("---------------------");
            r2.print('#');
            System.out.println("---------------------");
            r2.print('%');
        }
    }

**②同一个类中构造器互相调用**

this可以作为一个类中构造器相互调用的特殊格式。

*  this()：调用本类的无参构造器
 *  this(实参列表)：调用本类的有参构造器

public class Student {
        
        private String name;
        private int age;
    
        // 无参构造
        public Student() {
        
    //        this("",18);//调用本类有参构造器
        }
    
        // 有参构造
        public Student(String name) {
        
            this();//调用本类无参构造器
            this.name = name;
        }
        // 有参构造
        public Student(String name,int age){
        
            this(name);//调用本类中有一个String参数的构造器
            this.age = age;
        }
    
        public String getName() {
        
            return name;
        }
        public void setName(String name) {
        
            this.name = name;
        }
        public int getAge() {
        
            return age;
        }
        public void setAge(int age) {
        
            this.age = age;
        }
    
        public String getInfo(){
        
            return "姓名：" + name +"，年龄：" + age;
        }
    }

注意：

*  不能出现递归调用。比如，调用自身构造器。
    
     *  推论：如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(形参列表)"
 *  this()和this(实参列表)只能声明在构造器首行。
    
     *  推论：在类的一个构造器中，最多只能声明一个"this(参数列表)"

### 5.2 特征二：继承(Inheritance) ###

**继承的好处**

*  继承的出现减少了代码冗余，提高了代码的复用性。
 *  继承的出现，更有利于功能的扩展。
 *  继承的出现让类与类之间产生了`is-a`的关系，为多态的使用提供了前提。
    
     *  继承描述事物之间的所属关系，这种关系是：`is-a` 的关系。可见，父类更通用、更一般，子类更具体。

> 注意：不要仅为了获取其他类中某个功能而去继承！

**继承中的语法格式**

通过 `extends` 关键字，可以声明一个类B继承另外一个类A，定义格式如下：

[修饰符] class 类A {
        
    	...
    }
    
    [修饰符] class 类B extends 类A {
        
    	...
    }

类B，称为子类、派生类(derived class)、SubClass

类A，称为父类、超类、基类(base class)、SuperClass

**代码举例**

**1、父类**

/*
     * 定义动物类Animal，做为父类
     */
    public class Animal {
        
        // 定义name属性
        String name;
        // 定义age属性
        int age;
    
        // 定义动物的吃东西方法
        public void eat() {
        
            System.out.println(age + "岁的"
                    + name + "在吃东西");
        }
    }

**2、子类**

/*
     * 定义猫类Cat 继承 动物类Animal
     */
    public class Cat extends Animal {
        
        int count;//记录每只猫抓的老鼠数量
    
        // 定义一个猫抓老鼠的方法catchMouse
        public void catchMouse() {
        
            count++;
            System.out.println("抓老鼠，已经抓了"
                    + count + "只老鼠");
        }
    }

**3、测试类**

public class TestCat {
        
        public static void main(String[] args) {
        
            // 创建一个猫类对象
            Cat cat = new Cat();
            // 为该猫类对象的name属性进行赋值
            cat.name = "Tom";
            // 为该猫类对象的age属性进行赋值
            cat.age = 2;
            // 调用该猫继承来的eat()方法
            cat.eat();
            // 调用该猫的catchMouse()方法
            cat.catchMouse();
            cat.catchMouse();
            cat.catchMouse();
        }
    }

**继承性的细节说明**

1.子类会继承父类所有的实例变量和实例方法  
2.子类不能直接访问父类中私有的(private)的成员变量和方法  
3.在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”  
4.Java支持多层继承(继承体系)

class A{
        }
    class B extends A{
        }
    class C extends B{
        }

> 说明：
> 
>  *  子类和父类是一种相对的概念
>  *  顶层父类是Object类。所有的类默认继承Object，作为父类。

5.一个父类可以同时拥有多个子类

class A{
        }
    class B extends A{
        }
    class D extends A{
        }
    class E extends A{
        }

6.Java只支持单继承，不支持多重继承

public class A{
        }
    class B extends A{
        }
    
    //一个类只能有一个父类，不可以有多个直接父类。
    class C extends B{
        } 	//ok
    class C extends A,B...	//error

**练习：**

(1)定义一个ManKind类，包括

*  成员变量int sex和int salary；
 *  方法void manOrWoman()：根据sex的值显示“man”(sex1)或者“woman”(sex0)；
 *  方法void employeed()：根据salary的值显示“no job”(salary==0)或者“ job”(salary!=0)。

public class ManKind {
        
        int sex; // 成员变量：性别
        int salary; // 成员变量：工资
    
        public void manOrWoman(){
         // 方法：判断男女性别并输出
            if(sex == 1){
         // 如果性别为 1，表示男性
                System.out.println("man"); // 输出 man
            }else if(sex == 0){
         // 如果性别为 0，表示女性
                System.out.println("woman"); // 输出 woman
            }
        }
    
        public void employeed(){
         // 方法：判断是否有工作并输出
            if(salary == 0){
         // 如果工资为 0，表示没有工作
                System.out.println("no job"); // 输出 no job
            }else{
         // 否则有工作
                System.out.println("job"); // 输出 job
            }
        }
    }

(2)定义类Kids继承ManKind，并包括

*  成员变量int yearsOld；
 *  方法printAge()打印yearsOld的值。

package demo07;
    
    public class Kids extends ManKind{
         // 继承自 ManKind
        int yearsOld; // 成员变量：年龄
    
        public void printAge(){
         // 方法：输出年龄
            System.out.println(yearsOld); // 输出成员变量 yearsOld 的值
        }
    }

(3)定义类KidsTest，在类的main方法中实例化Kids的对象someKid，用该对象访问其父类的成员变量及方法。

package demo07;
    
    public class KidsTest {
        
        public static void main(String[] args) {
        
            Kids someKid = new Kids();// 实例化 Kids 类的对象 someKid
            someKid.sex = 1; // 调用继承自 ManKind 的成员变量 sex，赋值为 1
            someKid.salary = 1000; // 调用继承自 ManKind 的成员变量 salary，赋值为 1000
            someKid.manOrWoman(); // 调用继承自 ManKind 的方法 manOrWoman，输出 man
            someKid.employeed(); // 调用继承自 ManKind 的方法 employeed，输出 job
            someKid.yearsOld = 10; // 调用 Kids 自己的成员变量 yearsOld，赋值为 10
            someKid.printAge(); // 调用 Kids 自己的方法 printAge，输出 10
        }
    }

### 5.3 方法的重写（override/overwrite） ###

父类的所有方法子类都会继承，但是当某个方法被继承到子类之后，子类觉得父类原来的实现不适合于自己当前的类，该怎么办呢？子类可以对从父类中继承来的方法进行改造，我们称为方法的`重写 (override、overwrite)`。也称为方法的`重置`、`覆盖`。

在程序执行时，子类的方法将覆盖父类的方法。

**举例**

比如新的手机增加来电显示头像的功能，代码如下：

//SmartPhone：智能手机
    public class SmartPhone extends Phone{
        
        //重写父类的来电显示功能的方法
    	@Override
        public void showNum(){
        
            //来电显示姓名和图片功能
            System.out.println("显示来电姓名");
            System.out.println("显示头像");
        }
        //重写父类的通话功能的方法
        @Override
        public void call() {
        
            System.out.println("语音通话 或 视频通话");
        }
    }

//TestOverride类
    public class TestOverride {
        
        public static void main(String[] args) {
        
            // 创建子类对象
            SmartPhone sp = new SmartPhone();
    
            // 调用父类继承而来的方法
            sp.call();
    
            // 调用子类重写的方法
            sp.showNum();
        }
    }

> @Override使用说明：
> 
> 写在方法上面，用来检测是不是满足重写方法的要求。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。建议保留，这样编译器可以帮助我们检查格式，另外也可以让阅读源代码的程序员清晰的知道这是一个重写的方法。

**方法重写的要求**

1.  子类重写的方法`必须`和父类被重写的方法具有相同的`方法名称`、`参数列表`。
2.  子类重写的方法的返回值类型`不能大于`父类被重写的方法的返回值类型。（例如：Student < Person）。

> 注意：如果返回值类型是基本数据类型和void，那么必须是相同

1.  子类重写的方法使用的访问权限`不能小于`父类被重写的方法的访问权限。（public > protected > 缺省 > private）

> 注意：① 父类私有方法不能重写 ② 跨包的父类缺省的方法也不能重写

1.  子类方法抛出的异常不能大于父类被重写方法的异常

此外，子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

#### 方法的重载与重写 ####

`Java中的方法重载（Overloading）`：是指在同一个类中，可以存在多个名称相同但参数个数或类型不同的方法，即通过不同的参数列表对同一方法名进行重载。当调用这些被重载的方法时，编译器会根据实参的类型、数量和顺序选择最合适的方法。Java中的方法重载通常用于实现一些相似的功能，从而提高代码的复用。

`Java中的方法重写（Overriding）`:是指子类重写父类中的方法，也被称为覆盖。在子类中定义一个与父类中方法名、参数列表、返回值类型相同的方法，并且使用 @Override 注释符号进行标注，表示重写了父类中的方法。

方法重载和重写是 Java 中常用的两种方法实现方式，它们都是为了实现代码复用和提高扩展性。

（1）同一个类中

public class TestOverload {
        
        public int max(int a, int b){
        
            return a > b ? a : b;
        }
        public double max(double a, double b){
        
            return a > b ? a : b;
        }
        public int max(int a, int b,int c){
        
            return max(max(a,b),c);
        }
    }

（2）父子类中

public class TestOverloadOverride {
        
        public static void main(String[] args) {
        
            Son s = new Son();
            s.method(1);//只有一个形式的method方法
    
            Daughter d = new Daughter();
            d.method(1);
            d.method(1,2);//有两个形式的method方法
        }
    }
    
    class Father{
        
        public void method(int i){
        
            System.out.println("Father.method");
        }
    }
    class Son extends Father{
        
        public void method(int i){
        //重写
            System.out.println("Son.method");
        }
    }
    class Daughter extends Father{
        
        public void method(int i,int j){
        //重载
            System.out.println("Daughter.method");
        }
    }

### 5.4 关键字：super ###

在Java类中使用super来调用父类中的指定操作：

*  super可用于访问父类中定义的属性
 *  super可用于调用父类中定义的成员方法
 *  super可用于在子类构造器中调用父类的构造器

**注意：**

*  尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
 *  super的追溯不仅限于直接父类
 *  super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

#### 5.4.1 super的使用场景 ####

**①子类中调用父类被重写的方法**

*  如果子类没有重写父类的方法，只要权限修饰符允许，在子类中完全可以直接调用父类的方法；
 *  如果子类重写了父类的方法，在子类中需要通过`super.`才能调用父类被重写的方法，否则默认调用的子类重写的方法

举例：

public class Phone {
        
        public void sendMessage(){
        
            System.out.println("发短信");
        }
        public void call(){
        
            System.out.println("打电话");
        }
        public void showNum(){
        
            System.out.println("来电显示号码");
        }
    }
    
    //smartphone：智能手机
    public class SmartPhone extends Phone{
        
        //重写父类的来电显示功能的方法
        public void showNum(){
        
            //来电显示姓名和图片功能
            System.out.println("显示来电姓名");
            System.out.println("显示头像");
    
            //保留父类来电显示号码的功能
            super.showNum();//此处必须加super.，否则就是无限递归，那么就会栈内存溢出
        }
    }

总结：

*  **方法前面没有super.和this.**
    
     *  先从子类找匹配方法，如果没有，再从直接父类找，再没有，继续往上追溯
 *  **方法前面有this.**
    
     *  先从子类找匹配方法，如果没有，再从直接父类找，再没有，继续往上追溯
 *  **方法前面有super.**
    
     *  从当前子类的直接父类找，如果没有，继续往上追溯

**②子类中调用父类中同名的成员变量**

*  如果实例变量与局部变量重名，可以在实例变量前面加this.进行区别
 *  如果子类实例变量和父类实例变量重名，并且父类的该实例变量在子类仍然可见，在子类中要访问父类声明的实例变量需要在父类实例变量前加super.，否则默认访问的是子类自己声明的实例变量
 *  如果父子类实例变量没有重名，只要权限修饰符允许，在子类中完全可以直接访问父类中声明的实例变量，也可以用this.实例访问，也可以用super.实例变量访问

举例：

class Father{
        
    	int a = 10;
    	int b = 11;
    }
    class Son extends Father{
        
    	int a = 20;
        
        public void test(){
        
    		//子类与父类的属性同名，子类对象中就有两个a
    		System.out.println("子类的a：" + a);//20  先找局部变量找，没有再从本类成员变量找
            System.out.println("子类的a：" + this.a);//20   先从本类成员变量找
            System.out.println("父类的a：" + super.a);//10    直接从父类成员变量找
    		
    		//子类与父类的属性不同名，是同一个b
    		System.out.println("b = " + b);//11  先找局部变量找，没有再从本类成员变量找，没有再从父类找
    		System.out.println("b = " + this.b);//11   先从本类成员变量找，没有再从父类找
    		System.out.println("b = " + super.b);//11  直接从父类局部变量找
    	}
    	
    	public void method(int a, int b){
        
    		//子类与父类的属性同名，子类对象中就有两个成员变量a，此时方法中还有一个局部变量a		
    		System.out.println("局部变量的a：" + a);//30  先找局部变量
            System.out.println("子类的a：" + this.a);//20  先从本类成员变量找
            System.out.println("父类的a：" + super.a);//10  直接从父类成员变量找
    
            System.out.println("b = " + b);//13  先找局部变量
    		System.out.println("b = " + this.b);//11  先从本类成员变量找
    		System.out.println("b = " + super.b);//11  直接从父类局部变量找
        }
    }
    class Test{
        
        public static void main(String[] args){
        
            Son son = new Son();
    		son.test();
    		son.method(30,13);  
        }
    }

总结：起点不同（就近原则）

*  **变量前面没有super.和this.**
    
     *  在构造器、代码块、方法中如果出现使用某个变量，先查看是否是当前块声明的`局部变量`，
     *  如果不是局部变量，先从当前执行代码的`本类去找成员变量`
     *  如果从当前执行代码的本类中没有找到，会往上找`父类声明的成员变量`（权限修饰符允许在子类中访问的）
 *  **变量前面有this.**
    
     *  通过this找成员变量时，先从当前执行代码的本类去找成员变量
     *  如果从当前执行代码的本类中没有找到，会往上找==父类声明的成员变量（==权限修饰符允许在子类中访问的）
 *  **变量前面super.**
    
     *  通过super找成员变量，直接从当前执行代码的直接父类去找成员变量（权限修饰符允许在子类中访问的）
     *  如果直接父类没有，就去父类的父类中找（权限修饰符允许在子类中访问的）

**特别说明：应该避免子类声明和父类重名的成员变量**

**③子类构造器中调用父类构造器**

在 Java 中，子类可以调用父类的构造器来初始化父类的成员变量，使用 super() 方法可以显式调用父类的构造器。如果子类的构造器没有显式地调用父类的构造器，则会默认调用父类的无参构造器。在子类构造器的第一行使用 super() 方法即可调用父类的构造器。例如：

class Parent {
        
        int x;
        Parent(int x) {
        
            this.x = x;
        }
    }
    
    class Child extends Parent {
        
        int y;
        Child(int x, int y) {
        
            super(x); // 调用父类的构造器，初始化父类的 x 成员变量
            this.y = y;
        }
    }
    
    public class Test {
        
        public static void main(String[] args) {
        
            Child c = new Child(10, 20);
            System.out.println(c.x); // 输出 10，父类的 x 成员变量已经被初始化
            System.out.println(c.y); // 输出 20
        }
    }

在子类的构造器中使用 super() 方法显式调用父类的构造器，可以让子类在初始化时也能完成父类的初始化工作，保证程序的正确运行。同时，在实际编程中，还需要注意以下几点：

1.  若子类构造器中没有显式调用父类构造器，则系统会默认调用父类的无参构造器，如果父类没有无参构造器或者无参构造器的访问控制是 private，则会编译错误。此时需要在子类构造器中显式调用父类构造器，语法为 super(参数列表)。
2.  父类构造器的调用要放在子类构造器的第一行。
3.  如果父类构造器有多个构造器，子类可以通过 super(参数列表) 显式调用指定的父类构造器。一个子类构造器只能调用一个父类构造器，并且必须放在第一行声明。
4.  当父类构造器中有初始化语句时，子类中必须自己写构造方法并调用父类构造器。

#### 5.4.2 this与super ####

**1、this和super的意义**

this：当前对象

*  在构造器和非静态代码块中，表示正在new的对象
 *  在实例方法中，表示调用当前方法的对象

super：引用父类声明的成员

**2、this和super的使用格式**

*  this
    
     *  this.成员变量：表示当前对象的某个成员变量，而不是局部变量
     *  this.成员方法：表示当前对象的某个成员方法，完全可以省略this.
     *  this()或this(实参列表)：调用另一个构造器协助当前对象的实例化，只能在构造器首行，只会找本类的构造器，找不到就报错
 *  super
    
     *  super.成员变量：表示当前对象的某个成员变量，该成员变量在父类中声明的
     *  super.成员方法：表示当前对象的某个成员方法，该成员方法在父类中声明的
     *  super()或super(实参列表)：调用父类的构造器协助当前对象的实例化，只能在构造器首行，只会找直接父类的对应构造器，找不到就报错

**练习**

1、写一个名为Account的类模拟账户。该类的属性和方法如下图所示。该类包括的属性：账号id，余额balance，年利率annualInterestRate；包含的方法：访问器方法（getter和setter方法），返回月利率的方法getMonthlyInterest()，取款方法withdraw()，存款方法deposit()。

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZPqLKGpD-1680682124909)(images/image-20220324003430464.png)\]][img-ZPqLKGpD-1680682124909_images_image-20220324003430464.png]

package demo08;
    
    public class Account {
        
        private int id; //账号id
        private double balance; //余额balance
        private double annualInterestRate; //年利率annualInterestRate
        public Account(int id, double balance, double annualInterestRate) {
        
            this.id = id;
            this.balance = balance;
            this.annualInterestRate = annualInterestRate;
    
        }
        public int getId() {
         // 获取账户
            return id;
        }
    
        public void setId(int id) {
         // 设置账户
            this.id = id;
        }
    
        public double getBalance() {
         // 获取余额
            return balance;
        }
    
        public void setBalance(double balance) {
         // 设置余额
            this.balance = balance;
        }
    
        public double getAnnualInterestRate() {
         //获取年利率
            return annualInterestRate;
        }
    
        public void setAnnualInterestRate(double annualInterestRate) {
         // 设置年利率
            this.annualInterestRate = annualInterestRate;
        }
    
        public double getMonthlyInterest() {
         // 获取月利率
            return annualInterestRate / 12;
        }
    
        public void withdraw(double amount) {
         // 取款
            if (amount > balance) {
        
                System.out.println("余额不足");
            } else {
        
                balance -= amount;
                System.out.println("成功取款" + amount + "元，账户余额为" + balance + "元");
            }
        }
    
        public void deposit(double amount) {
         // 存款
            balance += amount;
            System.out.println("成功存款" + amount + "元，账户余额为" + balance + "元");
        }
    }

2、创建Account类的一个子类CheckAccount代表可透支的账户，该账户中定义一个属性overdraft代表可透支限额。在CheckAccount类中重写withdraw方法，其算法如下：

如果（取款金额<账户余额），
    	可直接取款
    如果（取款金额>账户余额），
    	计算需要透支的额度
    	判断可透支额overdraft是否足够支付本次透支需要，如果可以
    		将账户余额修改为0，冲减可透支金额
    	如果不可以
    		提示用户超过可透支额的限额

package demo08;
    
    public class CheckAccount extends Account{
        
        private double overdraft;
    
        public CheckAccount(int id, double balance, double annualInterestRate, double overdraft) {
        
            super(id, balance, annualInterestRate);
            this.overdraft = overdraft;
        }
    
        public double getOverdraft() {
        
            return overdraft;
        }
    
        public void setOverdraft(double overdraft) {
        
            this.overdraft = overdraft;
        }
        @Override
        public void withdraw(double amount) {
         // 取款
            if (amount <= getBalance() + overdraft) {
        
                if (amount <= getBalance()) {
        
                    setBalance(getBalance() - amount);
                    System.out.println("成功取款" + amount + "元，账户余额为" + getBalance() + "元");
                } else {
        
                    double overdraftAmount = amount - getBalance();
                    setBalance(0);
                    overdraft -= overdraftAmount;
                    System.out.println("成功取款" + amount + "元，账户余额为0元，已透支" + overdraftAmount + "元，可透支额为" + overdraft + "元");
                }
            } else {
        
                System.out.println("余额不足，可透支额为" + overdraft + "元");
            }
        }
    }

要求：  
写一个用户程序测试Account类。在用户程序中，创建一个账号为1122、余额为20000、年利率4.5%的Account对象。使用withdraw方法提款30000元，并打印余额。  
再使用withdraw方法提款2500元，使用deposit方法存款3000元，然后打印余额和月利率。  
提示：在提款方法withdraw中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。  
写一个用户程序测试CheckAccount类。在用户程序中，创建一个账号为1122、余额为20000、年利率4.5%，可透支限额为5000元的CheckAccount对象。  
使用withdraw方法提款5000元，并打印账户余额和可透支额。  
再使用withdraw方法提款18000元，并打印账户余额和可透支额。  
再使用withdraw方法提款3000元，并打印账户余额和可透支额。  
提示：  
（1）子类CheckAccount的构造方法需要将从父类继承的3个属性和子类自己的属性全部初始化。  
（2）父类Account的属性balance被设置为private，但在子类CheckAccount的withdraw方法中需要修改它的值，因此应修改父类的balance属性，定义其为protected。

package demo08;
    public class Test {
        
        public static void main(String[] args) {
        
            // 创建账号为1122、余额为20000、年利率4.5%的Account对象
            Account account = new Account(1122, 20000, 0.045);
            // 使用withdraw方法提款30000元，并打印余额
            account.withdraw(30000);
            // 使用withdraw方法提款2500元，使用deposit方法存款3000元，然后打印余额和月利率
            account.withdraw(2500);
            account.deposit(3000);
            System.out.println("账户余额为" + account.getBalance() + "元，月利率为" + account.getMonthlyInterest() * 100 + "%");
    
            // 创建账号为1122、余额为20000、年利率4.5%，可透支限额为5000元的CheckAccount对象
            CheckAccount checkAccount = new CheckAccount(1122, 20000, 0.045, 5000);
            // 使用withdraw方法提款5000元，并打印账户余额和可透支额
            checkAccount.withdraw(5000);
            System.out.println("账户余额为" + checkAccount.getBalance() + "元，可透支额为" + checkAccount.getOverdraft() + "元");
            // 使用withdraw方法提款18000元，并打印账户余额和可透支额
            checkAccount.withdraw(18000);
            System.out.println("账户余额为" + checkAccount.getBalance() + "元，可透支额为" + checkAccount.getOverdraft() + "元");
            // 使用withdraw方法提款3000元，并打印账户余额和可透支额
            checkAccount.withdraw(3000);
            System.out.println("账户余额为" + checkAccount.getBalance() + "元，可透支额为" + checkAccount.getOverdraft() + "元");
        }
    }
    
    >运行结果
    余额不足
    成功取款2500.0元，账户余额为17500.0元
    成功存款3000.0元，账户余额为20500.0元
    账户余额为20500.0元，月利率为0.375%
    成功取款5000.0元，账户余额为15000.0元
    账户余额为15000.0元，可透支额为5000.0元
    成功取款18000.0元，账户余额为0元，已透支3000.0元，可透支额为2000.0元
    账户余额为0.0元，可透支额为2000.0元
    余额不足，可透支额为2000.0元
    账户余额为0.0元，可透支额为2000.0元

#### 子类对象实例化全过程 ####

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GiQ5vZpD-1680443622972)(images/image-20220324003713230.png)\]][img-GiQ5vZpD-1680443622972_images_image-20220324003713230.png]

举例：

class Creature {
        
        public Creature() {
        
            System.out.println("Creature无参数的构造器");
    	}
    }
    class Animal extends Creature {
        
        public Animal(String name) {
        
            System.out.println("Animal带一个参数的构造器，该动物的name为" + name);
        }
        public Animal(String name, int age) {
        
            this(name);
            System.out.println("Animal带两个参数的构造器，其age为" + age);
    	}
    }
    public class Dog extends Animal {
        
        public Dog() {
        
            super("汪汪队阿奇", 3);
            System.out.println("Dog无参数的构造器");
        }
        public static void main(String[] args) {
        
            new Dog();
    	}
    }

### 5.5 特征三：多态性 ###

> 一千个读者眼中有一千个哈姆雷特。

#### 5.5.1 多态的形式和体现 ####

**对象的多态性**

多态性，是面向对象中最重要的概念，在Java中的体现：**对象的多态性：父类的引用指向子类的对象**

格式：（父类类型：指子类继承的父类类型，或者实现的接口类型）

父类类型 变量名 = 子类对象；

举例：

Person p = new Student();
    
    Object o = new Person();//Object类型的变量o，指向Person类型的对象
    
    o = new Student(); //Object类型的变量o，指向Student类型的对象

对象的多态：在Java中，子类的对象可以替代父类的对象使用。所以，一个引用类型变量可能指向(引用)多种不同类型的对象

**多态的理解**

Java引用变量有两个类型：`编译时类型`和`运行时类型`。编译时类型由`声明`该变量时使用的类型决定，运行时类型由`实际赋给该变量的对象`决定。简称：**编译时，看左边；运行时，看右边。**

*  若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
 *  多态情况下，“看左边”：看的是父类的引用（父类中不具备子类特有的方法）  
    “看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）

多态的使用前提：① 类的继承关系 ② 方法的重写

**举例**

public class Pet {
        
        private String nickname; //昵称
    
        public String getNickname() {
        
            return nickname;
        }
    
        public void setNickname(String nickname) {
        
            this.nickname = nickname;
        }
    
        public void eat(){
        
            System.out.println(nickname + "吃东西");
        }
    }

public class Cat extends Pet {
        
        //子类重写父类的方法
        @Override
        public void eat() {
        
            System.out.println("猫咪" + getNickname() + "吃鱼仔");
        }
    
        //子类扩展的方法
        public void catchMouse() {
        
            System.out.println("抓老鼠");
        }
    }

public class Dog extends Pet {
        
        //子类重写父类的方法
        @Override
        public void eat() {
        
            System.out.println("狗子" + getNickname() + "啃骨头");
        }
    
        //子类扩展的方法
        public void watchHouse() {
        
            System.out.println("看家");
        }
    }

**1、方法内局部变量的赋值体现多态**

public class TestPet {
        
        public static void main(String[] args) {
        
            //多态引用
            Pet pet = new Dog();
            pet.setNickname("小白");
    
            //多态的表现形式
            /*
            编译时看父类：只能调用父类声明的方法，不能调用子类扩展的方法；
            运行时，看“子类”，如果子类重写了方法，一定是执行子类重写的方法体；
             */
            pet.eat();//运行时执行子类Dog重写的方法
    //      pet.watchHouse();//不能调用Dog子类扩展的方法
    
            pet = new Cat();
            pet.setNickname("雪球");
            pet.eat();//运行时执行子类Cat重写的方法
        }
    }

**2、方法的形参声明体现多态**

public class Person{
        
        private Pet pet;
        public void adopt(Pet pet) {
        //形参是父类类型，实参是子类对象
            this.pet = pet;
        }
        public void feed(){
        
            pet.eat();//pet实际引用的对象类型不同，执行的eat方法也不同
        }
    }

public class TestPerson {
        
        public static void main(String[] args) {
        
            Person person = new Person();
    
            Dog dog = new Dog();
            dog.setNickname("小白");
            person.adopt(dog);//实参是dog子类对象，形参是父类Pet类型
            person.feed();
    
            Cat cat = new Cat();
            cat.setNickname("雪球");
            person.adopt(cat);//实参是cat子类对象，形参是父类Pet类型
            person.feed();
        }
    }

**3、方法返回值类型体现多态**

public class PetShop {
        
        //返回值类型是父类类型，实际返回的是子类对象
        public Pet sale(String type){
        
            switch (type){
        
                case "Dog":
                    return new Dog();
                case "Cat":
                    return new Cat();
            }
            return null;
        }
    }

public class TestPetShop {
        
        public static void main(String[] args) {
        
            PetShop shop = new PetShop();
    
            Pet dog = shop.sale("Dog");
            dog.setNickname("小白");
            dog.eat();
    
            Pet cat = shop.sale("Cat");
            cat.setNickname("雪球");
            cat.eat();
        }
    }

开发中，有时我们在设计一个数组、或一个成员变量、或一个方法的形参、返回值类型时，无法确定它具体的类型，只能确定它是某个系列的类型。

案例：

（1）声明一个Dog类，包含public void eat()方法，输出“狗啃骨头”

（2）声明一个Cat类，包含public void eat()方法，输出“猫吃鱼仔”

（3）声明一个Person类，功能如下：

*  包含宠物属性
 *  包含领养宠物方法 public void adopt(宠物类型Pet)
 *  包含喂宠物吃东西的方法 public void feed()，实现为调用宠物对象.eat()方法

public class Dog {
        
        public void eat(){
        
            System.out.println("狗啃骨头");
        }
    }

public class Cat {
        
        public void eat(){
        
            System.out.println("猫吃鱼仔");
        }
    }

public class Person {
        
        private Dog dog;
    
        //adopt：领养
        public void adopt(Dog dog){
        
            this.dog = dog;
        }
    
        //feed：喂食
        public void feed(){
        
            if(dog != null){
        
                dog.eat();
            }
        }
    }

#### 5.5.2 多态的好处和弊端 ####

**好处**：变量引用的子类对象不同，执行的方法就不同，实现动态绑定。代码编写更灵活、功能更强大，可维护性和扩展性更好了。

**弊端**：一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。

Student m = new Student();
    m.school = "pku"; 	//合法,Student类有school成员变量
    Person e = new Student(); 
    e.school = "pku";	//非法,Person类没有school成员变量
    
    // 属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。

> 开发中：
> 
> 使用父类做方法的形参，是多态使用最多的场合。即使增加了新的子类，方法也无需改变，提高了扩展性，符合开闭原则。
> 
> 【开闭原则OCP】
> 
>  *  对扩展开放，对修改关闭
>  *  通俗解释：软件系统中的各种组件，如模块（Modules）、类（Classes）以及功能（Functions）等，应该在不修改现有代码的基础上，引入新功能

#### 5.5.3 虚方法调用(Virtual Method Invocation) ####

在Java中虚方法是指在编译阶段不能确定方法的调用入口地址，在运行阶段才能确定的方法，即可能被重写的方法。

Person e = new Student();
    e.getInfo();	//调用Student类的getInfo()方法

子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

> `静态链接（或早起绑定）`：当一个字节码文件被装载进JVM内部时，如果被调用的目标方法在编译期可知，且运行期保持不变时。这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接。那么调用这样的方法，就称为非虚方法调用。比如调用静态方法、私有方法、final方法、父类构造器、本类重载构造器等。
> 
> `动态链接（或晚期绑定）`：如果被调用的方法在编译期无法被确定下来，也就是说，只能够在程序运行期将调用方法的符号引用转换为直接引用，由于这种引用转换过程具备动态性，因此也就被称之为动态链接。调用这样的方法，就称为虚方法调用。比如调用重写的方法（针对父类）、实现的方法（针对接口）。

#### 5.5.4 成员变量没有多态性 ####

*  若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。
 *  对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量

public class TestVariable {
        
        public static void main(String[] args) {
        
            Base b = new Sub();
            System.out.println(b.a);
            System.out.println(((Sub)b).a);
    
            Sub s = new Sub();
            System.out.println(s.a);
            System.out.println(((Base)s).a);
        }
    }
    class Base{
        
        int a = 1;
    }
    class Sub extends Base{
        
        int a = 2;
    }

#### 5.5.5 向上转型与向下转型 ####

首先，一个对象在new的时候创建是哪个类型的对象，它从头至尾都不会变。即这个对象的运行时类型，本质的类型用于不会变。但是，把这个对象赋值给不同类型的变量时，这些变量的编译时类型却不同。  
多态，就一定会有把子类对象赋值给父类变量的时候，这个时候，在`编译期间`，就会出现类型转换的现象。  
但是，使用父类变量接收了子类对象之后，我们就`不能调用`子类拥有，而父类没有的方法了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做类型转换，使得`编译通过`。

*  **向上转型**：当左边的变量的类型（父类） > 右边对象/变量的类型（子类），我们就称为向上转型
    
     *  此时，编译时按照左边变量的类型处理，就只能调用父类中有的变量和方法，不能调用子类特有的变量和方法了
     *  但是，**运行时，仍然是对象本身的类型**，所以执行的方法是子类重写的方法体。
     *  此时，一定是安全的，而且也是自动完成的
 *  **向下转型**：当左边的变量的类型（子类）<右边对象/变量的编译时类型（父类），我们就称为向下转型
    
     *  此时，编译时按照左边变量的类型处理，就可以调用子类特有的变量和方法了
     *  但是，**运行时，仍然是对象本身的类型**
     *  不是所有通过编译的向下转型都是正确的，可能会发生ClassCastException，为了安全，可以通过isInstanceof关键字进行判断

向上转型：自动完成

向下转型：（子类类型）父类变量

public class ClassCastTest {
        
        public static void main(String[] args) {
        
            //没有类型转换
            Dog dog = new Dog();//dog的编译时类型和运行时类型都是Dog
    
            //向上转型
            Pet pet = new Dog();//pet的编译时类型是Pet，运行时类型是Dog
            pet.setNickname("小白");
            pet.eat();//可以调用父类Pet有声明的方法eat，但执行的是子类重写的eat方法体
    //        pet.watchHouse();//不能调用父类没有的方法watchHouse
    
            Dog d = (Dog) pet;
            System.out.println("d.nickname = " + d.getNickname());
            d.eat();//可以调用eat方法
            d.watchHouse();//可以调用子类扩展的方法watchHouse
    
            Cat c = (Cat) pet;//编译通过，因为从语法检查来说，pet的编译时类型是Pet，Cat是Pet的子类，所以向下转型语法正确
            //这句代码运行报错ClassCastException，因为pet变量的运行时类型是Dog，Dog和Cat之间是没有继承关系的
        }
    }

#### 5.5.6 关键字：instanceof ####

为了避免ClassCastException的发生，Java提供了 `instanceof` 关键字，给引用变量做类型的校验。如下代码格式：

//检验对象a是否是数据类型A的对象，返回值为boolean型
    对象a instanceof 数据类型A

*  说明：
    
     *  只要用instanceof判断返回true的，那么强转为该类型就一定是安全的，不会报ClassCastException异常。
     *  如果对象a属于类A的子类B，a instanceof A值也为true。
     *  要求对象a所属的类与类A必须是子类和父类的关系，否则编译错误。

代码：

public class TestInstanceof {
        
        public static void main(String[] args) {
        
            Pet[] pets = new Pet[2];
            pets[0] = new Dog();//多态引用
            pets[0].setNickname("小白");
            pets[1] = new Cat();//多态引用
            pets[1].setNickname("雪球");
    
            for (int i = 0; i < pets.length; i++) {
        
                pets[i].eat();
    
                if(pets[i] instanceof Dog){
        
                    Dog dog = (Dog) pets[i];
                    dog.watchHouse();
                }else if(pets[i] instanceof Cat){
        
                    Cat cat = (Cat) pets[i];
                    cat.catchMouse();
                }
            }
        }
    }

#### **练习：笔试&面试** ####

题目1：继承成员变量和继承方法的区别

class Base {
        
        int count = 10;
        public void display() {
        
            System.out.println(this.count);
        }
    }
    
    class Sub extends Base {
        
        int count = 20;
        public void display() {
        
            System.out.println(this.count);
        }
    }
    
    public class FieldMethodTest {
        
        public static void main(String[] args){
        
            Sub s = new Sub();
            System.out.println(s.count);
            s.display();
            Base b = s;
            System.out.println(b == s);
            System.out.println(b.count);
            b.display();
        }
    }

题目2：

//考查多态的笔试题目：
    public class InterviewTest1 {
        
    
    	public static void main(String[] args) {
        
    		Base base = new Sub();
    		base.add(1, 2, 3);
    
    //		Sub s = (Sub)base;
    //		s.add(1,2,3);
    	}
    }
    
    class Base {
        
    	public void add(int a, int... arr) {
        
    		System.out.println("base");
    	}
    }
    
    class Sub extends Base {
        
    
    	public void add(int a, int[] arr) {
        
    		System.out.println("sub_1");
    	}
    
    //	public void add(int a, int b, int c) {
        
    //		System.out.println("sub_2");
    //	}
    
    }

题目3：

//getXxx()和setXxx()声明在哪个类中，内部操作的属性就是哪个类里的。
    public class InterviewTest2 {
        
    	public static void main(String[] args) {
        
    		Father f = new Father();
    		Son s = new Son();
    		System.out.println(f.getInfo());//atguigu
    		System.out.println(s.getInfo());//尚硅谷
    		s.test();//尚硅谷  atguigu
    		System.out.println("-----------------");
    		s.setInfo("大硅谷");
    		System.out.println(f.getInfo());//atguigu
    		System.out.println(s.getInfo());//大硅谷
    		s.test();//大硅谷  atguigu
    	}
    }
    
    class Father {
        
    	private String info = "atguigu";
    
    	public void setInfo(String info) {
        
    		this.info = info;
    	}
    
    	public String getInfo() {
        
    		return info;
    	}
    }
    
    class Son extends Father {
        
    	private String info = "尚硅谷";
    	
    	public void setInfo(String info) {
        
    		this.info = info;
    	}
    
    	public String getInfo() {
        
    		return info;
    	}
    	
    	public void test() {
        
    		System.out.println(this.getInfo());
    		System.out.println(super.getInfo());
    	}
    }

题目4：多态是编译时行为还是运行时行为？

//证明如下：
    class Animal  {
        
    	protected void eat() {
        
    		System.out.println("animal eat food");
    	}
    }
    
    class Cat  extends Animal  {
        
    	protected void eat() {
        
    		System.out.println("cat eat fish");
    	}
    }
    
    class Dog  extends Animal  {
        
    	public void eat() {
        
    		System.out.println("Dog eat bone");
    	}
    }
    
    class Sheep  extends Animal  {
        
    	public void eat() {
        
    		System.out.println("Sheep eat grass");
    	}
    }
    
    public class InterviewTest {
        
    	public static Animal  getInstance(int key) {
        
    		switch (key) {
        
    		case 0:
    			return new Cat ();
    		case 1:
    			return new Dog ();
    		default:
    			return new Sheep ();
    		}
    
    	}
    
    	public static void main(String[] args) {
        
    		int key = new Random().nextInt(3);
    		System.out.println(key);
    
    		Animal  animal = getInstance(key);
    		animal.eat(); 
    	}
    }

### 5.6 Object 类的使用 ###

类 `java.lang.Object`是类层次结构的根类，即所有其它类的父类。每个类都使用 `Object` 作为超类。

![2ae93d2cd52c4258871c63ab27724445.png][]

*  Object类型的变量与除Object以外的任意引用数据类型的对象都存在多态引用
    
        method(Object obj){
              …} //可以接收任何类作为其参数
        
        Person o = new Person();  
        method(o);
 *  所有对象（包括数组）都实现这个类的方法。
 *  如果一个类没有特别指定父类，那么默认则继承自Object类。例如：
    
        public class Person {
              
        	...
        }
        //等价于：
        public class Person extends Object {
              
        	...
        }

#### 5.6.1 Object类的方法 ####

根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。这里我们主要关注其中的6个：

##### 1、(重点)equals() #####

**= =：**

*  **基本类型**比较值:只要两个变量的值相等，即为true。
    
        int a=5; 
        if(a==6){
              …}
 *  **引用类型**比较引用(是否指向同一个对象)：只有指向同一个对象时，==才返回true。
    
        Person p1=new Person();  	    
        Person p2=new Person();
        if (p1==p2){
              …}
    
     *  用“==”进行比较时，符号两边的`数据类型必须兼容`(可自动转换的基本数据类型除外)，否则编译出错

\*\*equals()：\*\*所有类都继承了Object，也就获得了equals()方法。还可以重写。

*  只能比较引用类型，Object类源码中equals()的作用与“==”相同：比较是否指向同一个对象。
    
    ![image-20220503104750655][]
 *  格式:obj1.equals(obj2)
 *  特例：当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象；
    
     *  原因：在这些类中重写了Object类的equals()方法。
 *  当自定义使用equals()时，可以重写。用于比较两个对象的“内容”是否都相等
 *  重写equals()方法的原则
    
     *  `对称性`：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
     *  `自反性`：x.equals(x)必须返回是“true”。
     *  `传递性`：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
     *  `一致性`：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
     *  任何情况下，x.equals(null)，永远返回是“false”；
        
        x.equals(和x不同类型的对象)永远返回是“false”。
 *  重写举例：

class User{
        
    	private String host;
    	private String username;
    	private String password;
    	public User(String host, String username, String password) {
        
    		super();
    		this.host = host;
    		this.username = username;
    		this.password = password;
    	}
    	public User() {
        
    		super();
    	}
    	public String getHost() {
        
    		return host;
    	}
    	public void setHost(String host) {
        
    		this.host = host;
    	}
    	public String getUsername() {
        
    		return username;
    	}
    	public void setUsername(String username) {
        
    		this.username = username;
    	}
    	public String getPassword() {
        
    		return password;
    	}
    	public void setPassword(String password) {
        
    		this.password = password;
    	}
    	@Override
    	public String toString() {
        
    		return "User [host=" + host + ", username=" + username + ", password=" + password + "]";
    	}
    	@Override
    	public boolean equals(Object obj) {
        
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		User other = (User) obj;
    		if (host == null) {
        
    			if (other.host != null)
    				return false;
    		} else if (!host.equals(other.host))
    			return false;
    		if (password == null) {
        
    			if (other.password != null)
    				return false;
    		} else if (!password.equals(other.password))
    			return false;
    		if (username == null) {
        
    			if (other.username != null)
    				return false;
    		} else if (!username.equals(other.username))
    			return false;
    		return true;
    	}
    	
    }

**面试题：**==和equals的区别

*  == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
 *  equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==;我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点。
 *  具体要看自定义类里有没有重写Object的equals方法来判断。
 *  通常情况下，重写equals方法，会比较类中的相应属性是否都相等。

**练习1：**

int it = 65;
    float fl = 65.0f;
    System.out.println("65和65.0f是否相等？" + (it == fl)); // 输出 false
    //65 和 65.0f 不相等，因为它们虽然值相同，但数据类型不同
    
    char ch1 = 'A'; char ch2 = 12;
    System.out.println("65和'A'是否相等？" + (it == ch1)); // 输出 true
    //65 和 'A' 相等，因为在 char 类型中，A 的 Unicode 码值是 65，也就是说 ch1 的值是 65
    System.out.println("12和ch2是否相等？" + (12 == ch2)); // 输出 true
    //12 和 ch2 相等，因为它们的值相同，都是 12
    
    String str1 = new String("hello");
    String str2 = new String("hello");
    System.out.println("str1和str2是否相等？" + (str1 == str2)); // 输出 false
    //str1 和 str2 不相等，因为它们虽然存储的字符串相同，但是是两个不同的对象，比较的是两者在内存中的引用地址
    
    System.out.println("str1是否equals str2？" + (str1.equals(str2))); // 输出 true
    //str1.equals(str2) 返回 true，说明两个对象存储的字符串相等
    System.out.println("hello" == new java.util.Date()); // 抛出编译错误，因为无法比较两个不同类型的对象

**练习2：**

编写Order类，有int型的orderId，String型的orderName，相应的getter()和setter()方法，两个参数的构造器，重写父类的equals()方法：public boolean equals(Object obj)，并判断测试类中创建的两个对象是否相等。

public class Order {
        
        private int orderId; // 订单编号
        private String orderName; // 订单名称
    
        /**
         * 两个参数的构造器
         * @param orderId 订单编号
         * @param orderName 订单名称
         */
        public Order(int orderId, String orderName) {
        
            this.orderId = orderId;
            this.orderName = orderName;
        }
    
        /**
         * 获取订单编号
         * @return 订单编号
         */
        public int getOrderId() {
        
            return orderId;
        }
    
        /**
         * 设置订单编号
         * @param orderId 订单编号
         */
        public void setOrderId(int orderId) {
        
            this.orderId = orderId;
        }
    
        /**
         * 获取订单名称
         * @return 订单名称
         */
        public String getOrderName() {
        
            return orderName;
        }
    
        /**
         * 设置订单名称
         * @param orderName 订单名称
         */
        public void setOrderName(String orderName) {
        
            this.orderName = orderName;
        }
    
        /**
         * 重写 equals 方法，判断两个对象是否相等
         * @param obj 待比较对象
         * @return true（相等）/false（不相等）
         */
        @Override
        public boolean equals(Object obj) {
        
            if (this == obj) //判断是否为同一个对象
                return true;
            if (obj instanceof Order) {
         //判断是否为同一类型
                Order order = (Order) obj;
                return this.orderId == order.orderId && this.orderName.equals(order.orderName); // 判断两个对象的 orderId 和 orderName 是否相等
            }
            return false;
        }
    
        public static void main(String[] args) {
        
            Order order1 = new Order(1, "order1"); // 创建 Order 对象 1
            Order order2 = new Order(2, "order2"); // 创建 Order 对象 2
            Order order3 = new Order(1, "order1"); // 创建 Order 对象 3
            System.out.println(order1.equals(order2)); // 判断 Order 对象 1 和 2 是否相等
            // 结果：false
            System.out.println(order1.equals(order3)); // 判断 Order 对象 1 和 3 是否相等
            // 结果：true
        }
    }

##### 2、(重点)toString() #####

方法签名：public String toString()

① 默认情况下，toString()返回的是“对象的运行时类型 @ 对象的hashCode值的十六进制形式"

② 在进行String与其它类型数据的连接操作时，自动调用toString()方法

Date now=new Date();
    System.out.println(“now=”+now);  //相当于
    System.out.println(“now=”+now.toString());

③ 如果我们直接System.out.println(对象)，默认会自动调用这个对象的toString()

> 因为Java的引用数据类型的变量中存储的实际上时对象的内存地址，但是Java对程序员隐藏内存地址信息，所以不能直接将内存地址显示出来，所以当你打印对象时，JVM帮你调用了对象的toString()。

④ 可以根据需要在用户自定义类型中重写toString()方法  
如String 类重写了toString()方法，返回字符串的值。

s1="hello";
    System.out.println(s1);//相当于System.out.println(s1.toString());

例如自定义的Person类：

public class Person {
          
        private String name;
        private int age;
    
        @Override
        public String toString() {
        
            return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
        }
    }

##### 3、clone() #####

//Object类的clone()的使用
    public class CloneTest {
        
    	public static void main(String[] args) {
        
    		Animal a1 = new Animal("花花");
    		try {
        
    			Animal a2 = (Animal) a1.clone();
    			System.out.println("原始对象：" + a1);
    			a2.setName("毛毛");
    			System.out.println("clone之后的对象：" + a2);
    		} catch (CloneNotSupportedException e) {
        
    			e.printStackTrace();
    		}
    	}
    }
    
    class Animal implements Cloneable{
        
    	private String name;
    
    	public Animal() {
        
    		super();
    	}
    
    	public Animal(String name) {
        
    		super();
    		this.name = name;
    	}
    
    	public String getName() {
        
    		return name;
    	}
    
    	public void setName(String name) {
        
    		this.name = name;
    	}
    
    	@Override
    	public String toString() {
        
    		return "Animal [name=" + name + "]";
    	}
    	
    	@Override
    	protected Object clone() throws CloneNotSupportedException {
        
    		// TODO Auto-generated method stub
    		return super.clone();
    	}
    	
    }

##### 4、finalize() #####

*  当对象被回收时，系统自动调用该对象的 finalize() 方法。（不是垃圾回收器调用的，是本类对象调用的）
    
     *  永远`不要主动调用`某个对象的finalize方法，应该交给垃圾回收机制调用。
 *  什么时候被回收：当某个对象没有任何引用时，JVM就认为这个对象是垃圾对象，就会在之后不确定的时间使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用 finalize()方法。
 *  子类可以重写该方法，目的是在对象被清理之前执行必要的清理操作。比如，在方法内断开相关连接资源。
    
     *  如果重写该方法，让一个新的引用变量重新引用该对象，则会重新激活对象。
 *  在JDK 9中此方法已经被`标记为过时`的。

public class FinalizeTest {
        
    	public static void main(String[] args) {
        
    		Person p = new Person("Peter", 12);
    		System.out.println(p);
    		p = null;//此时对象实体就是垃圾对象，等待被回收。但时间不确定。
    		System.gc();//强制性释放空间
    	}
    }
    
    class Person{
        
    	private String name;
    	private int age;
    
    	public Person(String name, int age) {
        
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	public String getName() {
        
    		return name;
    	}
    	public void setName(String name) {
        
    		this.name = name;
    	}
    	public int getAge() {
        
    		return age;
    	}
    	public void setAge(int age) {
        
    		this.age = age;
    	}
    	//子类重写此方法，可在释放对象前进行某些操作
    	@Override
    	protected void finalize() throws Throwable {
        
    		System.out.println("对象被释放--->" + this);
    	}
    	@Override
    	public String toString() {
        
    		return "Person [name=" + name + ", age=" + age + "]";
    	}
    	
    }

##### 5、getClass() #####

public final Class<?> getClass()：获取对象的运行时类型

> 因为Java有多态现象，所以一个引用数据类型的变量的编译时类型与运行时类型可能不一致，因此如果需要查看这个变量实际指向的对象的类型，需要用getClass()方法

public static void main(String[] args) {
        
    	Object obj = new Person();
    	System.out.println(obj.getClass());//运行时类型
    }

结果：

class com.atguigu.java.Person

##### 6、hashCode() #####

public int hashCode()：返回每个对象的hash值。(后续在集合框架章节重点讲解)

public static void main(String[] args) {
        
    	System.out.println("AA".hashCode());//2080
        System.out.println("BB".hashCode());//2112
    }

#### 5.6.2 关键字：native ####

使用native关键字说明这个方法是原生函数，也就是这个方法是用`C/C++`等非Java语言实现的，并且`被编译成了DLL`，由Java去调用。

*  本地方法是有方法体的，用c语言编写。由于本地方法的方法体源码没有对我们开源，所以我们看不到方法体
 *  在Java中定义一个native方法时，并不提供实现体。

**1. 为什么要用native方法**

Java使用起来非常方便，然而有些层次的任务用java实现起来不容易，或者我们对程序的效率很在意时，例如：Java需要与一些底层操作系统或某些硬件交换信息时的情况。native方法正是这样一种交流机制：它为我们提供了一个非常简洁的接口，而且我们无需去了解Java应用之外的繁琐的细节。

**2. native声明的方法，对于调用者，可以当做和其他Java方法一样使用**

native method的存在并不会对其他类调用这些本地方法产生任何影响，实际上调用这些方法的其他类甚至不知道它所调用的是一个本地方法。JVM将控制调用本地方法的所有细节。

[6aab098af5b94058bc5dd4ef187eb895.png]: https://img-blog.csdnimg.cn/6aab098af5b94058bc5dd4ef187eb895.png
[img-ZPqLKGpD-1680682124909_images_image-20220324003430464.png]: https://img-blog.csdnimg.cn/5718f673c2c54144a8419b7cff5f70f3.png
[img-GiQ5vZpD-1680443622972_images_image-20220324003713230.png]: https://img-blog.csdnimg.cn/eb57ea67ee6f499c90ab920df536500a.png
[2ae93d2cd52c4258871c63ab27724445.png]: https://img-blog.csdnimg.cn/2ae93d2cd52c4258871c63ab27724445.png
[image-20220503104750655]: