Java—继承性与多态性

一、this关键字

[1. 理解this](#1. 理解this)

[2. this练习](#2. this练习)

二、继承性

[2.1 继承性的理解](#2.1 继承性的理解)

[2.1.1 多层继承](#2.1.1 多层继承)

[2.2 继承性的使用练习](#2.2 继承性的使用练习)

[2.2.1 练习1](#2.2.1 练习1)

[2.2.2 练习2](#2.2.2 练习2)

[2.3 方法的重写](#2.3 方法的重写)

[2.4 super关键字](#2.4 super关键字)

[2.4.1 子类对象实例化](#2.4.1 子类对象实例化)

三、多态性

[3.1 多态性的理解](#3.1 多态性的理解)

[3.2 向下转型与多态练习](#3.2 向下转型与多态练习)

四、Object类

[4.1 clone()](#4.1 clone())

[4.2 equals()](#4.2 equals())

[4.3 toString()](#4.3 toString())

一、this关键字

1. 理解this

在声明一个属性对应的 setXxx 方法时，如果形参名与属性名相同，可以使用 this 来区分它们。使用 this 修饰的变量表示属性，而不带 this 的变量表示形参。

this可调用的结构:成员变量、方法、构造器

**理解:**当前对象(在方法中调用时)或当前正在创建的对象(在构造器中调用时)

**注意：**如果方法的形参与对象的属性同名了，我们必须使用"this. "进行区分。使用this.修饰的变量即为属性(或成员变量)没有使用this.修饰的变量，即为局部变量。

this调用构造器

格式: "this (形参列表)"
我们可以在类的构造器中，调用当前类中指定的其它构造器
要求:"this (形参列表) "必须声明在当前构造器的首行
结论: "this (形参列表) "在构造器中最多声明一个
如果一个类中声明了n个构造器，则最多有n- 1个构造器可以声明有" this (形参列表) "的结构

2. this练习

Account-Customer-Bank 练手

UML类图：

java 复制代码

//Account类
public class Account {
    private double balance;

    public Account(double init_balance){
        this.balance = init_balance;
    }

    public double getBlance(){
        return balance;
    }

    //存钱
    public void deposit(double amt){
        if (amt > 0) {
            balance += amt;
            System.out.println("成功存入" + amt);
        }
    }

    //取钱
    public void withdraw(double amt){
        if (amt >= amt && amt > 0) {
            balance -= amt;
            System.out.println("成功取出" + amt);
        }else{
            System.out.println("余额不足");
        }
    }

}

//Customer类
public class Customer {
    private String firstname;
    private String lastname;

    private Account account;

    public Customer(){

    }
    public  Customer(String f,String l){
        this.firstname = f;
        this.lastname = l;
    }

    public String getFirstname(){
        return firstname;
    }

    public String getLastname(){
        return lastname;
    }

    public Account getAccount(){
        return account;
    }

    public void setAccount(Account acctount){
        this.account = acctount;
    }
}
//Bank类
public class Bank {
    private Customer[] customers;
    private int numberOfCustomer;

    public Bank(){
        customers = new Customer[10];
    }

    public void addCustomer(String f,String l) {
        Customer cust = new Customer(f,l);
        customers[numberOfCustomer++] = cust;
    }
    public int getNumberOfCustomer() {
        return numberOfCustomer;
    }
    public Customer getCustomer(int index){
        if (index < 0 || index >= numberOfCustomer) {
            return null;
        }

        return customers[index];
    }
}
//测试
public class BankTest {
    public static void main(String[] args) {
        Bank bank = new Bank();

        bank.addCustomer("备","刘");
        bank.addCustomer("权","孙");

        bank.getCustomer(0).setAccount(new Account(1000));
        bank.getCustomer(0).getAccount().withdraw(900);

        System.out.println("账户余额为： " + bank.getCustomer(0).getAccount().getBlance());

    }
}

二、继承性

2.1 继承性的理解

图示：

代码角度：

自上而下：定义一个类A，在定义另一个类B时，功能上两者相似，则考虑B继承于A。
自下而上：定义了类B,C,D，且类B,C,D有类似的属性和方法，则将相同的属性与方法抽取，封装到类A中，让B,C,D继承于类A。类B,C,D中相似的功能删除。

基本概念：

继承（Inheritance） ：Java通过 extends 关键字实现类之间的继承关系。子类（Subclass）可以继承父类（Superclass）的字段和方法。

基本格式：

class A{

//属性、方法

}

class B extends A{

}

继承性的好处：

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

图示：

代码：

java 复制代码

// 子类：Cat
// 父类：Animal
class Animal {
    // 属性
    protected String name;
    protected int age;

    // 构造函数
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 方法：获取动物信息
    public void info() {
        System.out.println("宠物名: " + name + ", 年龄: " + age);
    }
}

class Cat extends Animal {

    public Cat(String name, int age) {
        super(name, age); // 调用父类构造函数
    }

    // 子类特有方法：抓老鼠
    public void catchMouse() {
        System.out.println(name + "抓老鼠 ");
    }
}

// 子类：Dog
class Dog extends Animal {

    public Dog(String name, int age) {
        super(name, age); // 调用父类构造函数
    }

    // 子类特有方法：看家
    public void guardHome() {
        System.out.println(name + "看家护院 ");
    }
}

public class Test {
    public static void main(String[] args) {
        // 创建 Cat 对象
        Cat cat = new Cat("汤姆", 3);
        cat.info();         // 输出: Name: Whiskers, Age: 3
        cat.catchMouse();   // 输出: Whiskers is catching a mouse.

        // 创建 Dog 对象
        Dog dog = new Dog("杰森", 5);
        dog.info();         // 输出: Name: Buddy, Age: 5
        dog.guardHome();    // 输出: Buddy is guarding the home.
    }
}

结果：

解释：

由于继承性，子类获取父类中声明的所有属性和方法，但封装性影响，子类并不能直接调用父类中声明的属性或方法。
子类不是父类的子集，而是对父类的 "扩展"
不要为了继承而继承，要判断是否有is a的关键。

默认的父类：没有直接说明其父类，则默认继承java.lang.Object

2.1.1 多层继承

图示：

**概念：**直接父类，间接父类

格式：

class A{}

class B extends A{}

class C extends B{}

补充：

java中子父类的概念是相对的
java中一个父类可以声明多个子类，但一个子类只能有一个父类。

2.2 继承性的使用练习

2.2.1 练习1

代码:

java 复制代码

//定义子父类
public class ManKind {
    private int sex;
    private int salary;

    public ManKind(){}
    public ManKind(int salary,int sex ){
        this.salary = salary;
        this.sex = sex;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public int getSex() {
        return sex;
    }

    public void manOrWoman() {
        if (sex == 1) {
            System.out.println("I am man");
        }else if (sex == 0) {
            System.out.println("I am woman");
        }
    }

    public void employed(){
        if (salary == 0) {
            System.out.println("I no job");
        }
        if (salary != 0) {
            System.out.println("I have a job");
        }
    }
}

class Kids extends ManKind{
    private int yearsOld;
    public Kids(){

    }

    public Kids(int yearsOld){
        this.yearsOld = yearsOld;
    }
    public Kids(int salary,int sex){
        setSex(sex);
        setSalary(salary);
    }

    public void setYearsOld(int yearsOld) {
        this.yearsOld = yearsOld;
    }

    public int getYearsOld() {
        return yearsOld;
    }

    public void printAge(){
        System.out.println("I am" +yearsOld +"years old");
    }
}

//代码测试
public class KidsTest {
    public static void main(String[] args) {
        Kids kid = new Kids();
        kid.setSalary(100);
        kid.setSex(1);
        kid.setYearsOld(10);

        kid.employed();
        kid.manOrWoman();

        kid.printAge();
    }
}

结果：

2.2.2 练习2

代码：

java 复制代码

public class Circle {
    private double radius;

    public Circle(){
        this.radius = 1;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public double findArea(){
        return  3.14 * radius * radius;
    }
}

public class Cylinder extends Circle {
    private double length;
    public Cylinder(){
        this.length = 1;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public double getLength() {
        return length;
    }

    public double findVolume(){
        return findArea() * getLength();
    }
}
//测试
public class Test {
    public static void main(String[] args) {
        Cylinder cy = new Cylinder();

        cy.setRadius(2.3);
        cy.setLength(1.4);
        System.out.println("圆的面积：" + cy.findArea());
        System.out.println("圆柱的体积：" + cy.findVolume());
    }
}

结果：

2.3 方法的重写

1 为什么需要方法的重写

子类继承父类后，获取父类中声明的所有方法。但父类中的方法不太适用于子类，此时，子类要对从父类中继承的方法进行覆盖。

2.方法重写是什么？

子类对父类继承过来的方法进行覆盖，覆写的操作。

3.方法重写遵循的规则

父类被重写的方法与子类重写的方法的方法名和形参列表必须相同。
子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符。（父类中private类的方法不能被子类重写）

关于返回值类型

父类被重写的方法的返回值为void，子类重写的方法的返回值也要是void
父类被重写的方法的返回值为基本数据类型 / 引用数据类型，子类重写的方法的返回值也必须与被重写的方法的返回值相同或是被重写的方法的返回值的子类。

4.使用举例

java 复制代码

// 父类：Animal
class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

// 子类：Dog
class Dog extends Animal {
    @Override
    public void sound() { // 重写父类的 sound 方法
        System.out.println("狗 汪汪叫");
    }
}

// 子类：Cat
class Cat extends Animal {
    @Override
    public void sound() { // 重写父类的 sound 方法
        System.out.println("猫 喵喵叫");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog(); // 父类引用指向子类对象
        Animal myCat = new Cat(); // 父类引用指向子类对象

        myDog.sound(); // 输出: Dog barks
        myCat.sound(); // 输出: Cat meows
    }
}

方法的重载与重写的区别

重载："两同一不同"->编译时多态

重写：继承以后，子类覆盖父类中同名同参数的方法->运行时多态

2.4 super关键字

super关键字用于引用父类的属性、方法以及构造函数。

1.当子类重写了父类的方法时，可以使用super来调用父类中的被重写的方法。

java 复制代码

class Parent {
    void display() {
        System.out.println("This is the Parent class.");
    }
}

class Child extends Parent {
    void display() {
        System.out.println("This is the Child class.");
    }

    void show() {
        super.display();  // 调用父类的display方法
        display();        // 调用子类的display方法
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.show();
    }
}

2.super调用属性，尤其是在子类中有同名属性的情况下。

java 复制代码

class Parent {
    String name = "Parent";

    void show() {
        System.out.println("Name: " + name);
    }
}

class Child extends Parent {
    String name = "Child";

    void show() {
        System.out.println("Name: " + name);
        System.out.println("Parent Name: " + super.name);  // 访问父类的属性
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.show();
    }
}

3.调用父类的构造器，以及方法和属性

java 复制代码

// 定义一个父类 Parent
class Parent {
    String name;

    // 父类构造函数
    Parent(String name) {
        this.name = name;
        System.out.println("调用父类，父类名称： " + this.name);
    }

    // 父类方法
    void display() {
        System.out.println("调用父类的display()方法");
    }
}

// 定义一个子类 Child 继承 Parent
class Child extends Parent {
    String name; // 子类中也有一个同名属性

    // 子类构造函数
    Child(String childName) {
        super("张良"); // 调用父类构造函数
        this.name = childName; // 初始化子类的属性
        System.out.println("子类的名称：" + this.name);
    }

    // 重写父类方法
    @Override
    void display() {
        super.display(); // 调用父类的 display 方法
        System.out.println("现在是子类覆盖后自己的display()方法");
    }

    // 显示父类和子类的名字
    void showNames() {
        System.out.println("子类名: " + this.name);
        System.out.println("父类名: " + super.name); // 访问父类属性
    }
}

// 主类
public class Test {
    public static void main(String[] args) {
        Child child = new Child("张三"); // 创建 Child 类的实例
        child.display(); // 调用子类的 display 方法
        child.showNames(); // 调用显示名字的方法
    }
}

结果：

2.4.1 子类对象实例化

图解：

三、多态性

3.1 多态性的理解

1.理解：一种事物的多种形态。

例：女朋友说"我想养一个宠物"，则宠物就可以理解为：猫，狗，仓鼠，兔子等等。

多态性的使用前提:

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

多态的适用性:适用于方法，不适用于属性。

2. Java中多态性的体现:

子类对象的多态性:父类的引用指向子类的对象。( 或子类的对象赋给父类的引用)比如:Person p2 = new Man();

java 复制代码

// 定义一个父类 Animal
class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

// 定义一个子类 Dog 继承 Animal
class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

// 定义另一个子类 Cat 继承 Animal
class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建 Animal 类型的引用，指向 Dog 对象
        Animal myDog = new Dog();
        myDog.sound(); // 输出：Dog barks

        // 创建 Animal 类型的引用，指向 Cat 对象
        Animal myCat = new Cat();
        myCat.sound(); // 输出：Cat meows
    }
}

多态性的应用:

虚拟方法调用
在多态的场景下，调用方法时。编译时，认为方法是左边声明的父类的类型的方法(即被重写的方法)执行式，实际执行的是子类重写父类的方法。
简称为:编译看左边，运行看右边。

多态性的好处与弊端

好处: 极大的减少了代码的冗余，不需要定义多个重载的方法。
弊端: 在多态的场景下，我们创建了子类的对象，也加载了子类特有的属性和方法。但是由于声明为父类的引用,导致我们没有办法直接调用子类特有的属性和方法。

3.2 向下转型与多态练习

图示：

向下转型，其实就是使用：强转符

代码体现：

java 复制代码

// 定义一个父类
class Animal {
    void makeSound() {
        System.out.println("动物的叫声");
    }
}

// 定义一个子类
class Dog extends Animal {
    void makeSound() {
        System.out.println("汪汪汪");
    }
}

// 另一个子类
class Cat extends Animal {
    void makeSound() {
        System.out.println("喵喵喵");
    }
}

public class Test {
    public static void main(String[] args) {
        // 父类引用指向子类对象
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        // 运行时多态性
        myDog.makeSound();  // 输出: 汪汪汪
        myCat.makeSound();  // 输出: 喵喵喵

        // 向下转型
        if (myDog instanceof Dog) {
            Dog dog = (Dog) myDog; // 安全的向下转型
            dog.makeSound(); // 输出: 汪汪汪
        }

        if (myCat instanceof Cat) {
            Cat cat = (Cat) myCat; // 安全的向下转型
            cat.makeSound(); // 输出: 喵喵喵
        }

        // 尝试错误的向下转型（会抛出 ClassCastException）
        try {
            Dog dog = (Dog) myCat; // 错误的向下转型
            dog.makeSound();
        } catch (ClassCastException e) {
            System.out.println("使用错误的向下转型，报错: " + e.getMessage());
        }
    }
}

结果：

实战练习

**场景：**假设我们正在开发一个图形处理系统，需要绘制不同的形状（圆形、矩形等），同时实现对这些形状的面积计算。

java 复制代码

// 抽象类 Shape
abstract class Shape {
    public abstract double area(); // 抽象方法，计算面积
}

// 圆形类
class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

// 矩形类
class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double area() {
        return width * height;
    }
}

// 形状处理类
class ShapeProcessor {
    public void printArea(Shape shape) {
        System.out.println("面积: " + shape.area());
    }

    public void identifyShape(Shape shape) {
        if (shape instanceof Circle) {
            Circle circle = (Circle) shape; // 向下转型
            System.out.println("这是一个圆形，半径为: " + circle.radius);
        } else if (shape instanceof Rectangle) {
            Rectangle rectangle = (Rectangle) shape; // 向下转型
            System.out.println("这是一个矩形，宽度为: " + rectangle.width + " and height: " + rectangle.height);
        } else {
            System.out.println("Unknown shape");
        }
    }
}

// 主类
public class PolymorphismExample {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);

        ShapeProcessor processor = new ShapeProcessor();
        processor.printArea(circle); // 计算并打印圆的面积
        processor.identifyShape(circle); // 识别圆的类型

        processor.printArea(rectangle); // 计算并打印矩形的面积
        processor.identifyShape(rectangle); // 识别矩形的类型
    }
}

结果：

四、Object类

要明确：java.lang.Object （因为可以自己命名一个叫Object的类）

任何一个java类（不包括Object类）都直接或间接的继承于Object类，Object类称为java类的根父类。

Object类声明的结构：

没有声明属性
提供一个空参的构造器
重点关注：Object类中声明的方法

图示：

4.1 clone()

clone() 方法用于创建一个对象的副本。

为了使用此方法，类必须实现 Cloneable 接口，并重写 clone() 方法。默认情况下，Object的 clone() 方法是浅拷贝。

java 复制代码

class Person implements Cloneable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter和Setter方法
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 浅拷贝
    }
}

public class CloneExample {
    public static void main(String[] args) {
        try {
            Person person1 = new Person("Alice", 30);
            Person person2 = (Person) person1.clone(); // 克隆person1

            // 修改person2的属性
            System.out.println("Before change:");
            System.out.println("person1: " + person1.getName() + ", " + person1.getAge());
            System.out.println("person2: " + person2.getName() + ", " + person2.getAge());

            person2.age = 31; // 这里是为了示例，实际应提供set方法
            System.out.println("After change:");
            System.out.println("person1: " + person1.getName() + ", " + person1.getAge());
            System.out.println("person2: " + person2.getName() + ", " + person2.getAge());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

4.2 equals()

任何数据范围都可以使用

子类说明情况：

自定义的类在没有重写Object中equals()方法的情况下，调用的就是Object类中声明的equals()，比较两个对象的引用地址是否相等，（或是否指向了堆空间中同一个对象实例）
对于String、File、Date和包装类等，都重写了Object类中的equals()方法，用于比较两个对象的实体内容是否相等。

如何重写：

手动实现
调用IDEA自动实现

IDEA使用快捷键：Alt+Inest即可

代码实现：

java 复制代码

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) 
            return true; // 引用相等
        if (obj == null || getClass() != obj.getClass()) 
            return false; // 类型检查
        Person person = (Person) obj; // 类型转换
        return age == person.age && name.equals(person.name); // 属性比较
    }

}

public class Test {
    public static void main(String[] args) {
        Person person1 = new Person("张三", 30);
        Person person2 = new Person("张三", 30);
        Person person3 = new Person("李四", 25);

        // 比较内容
        System.out.println(person1.equals(person2)); // 输出 true
        System.out.println(person1.equals(person3)); // 输出 false
    }
}

结果：

问题："=="和equals()方法的区别

1.==操作符

==比较的是两个对象的引用（内存地址），即它们是否指向同一个对象。对于基本数据类型，==比较的是它们的值。
使用场景：
- 对于基本数据类型，==比较它们的实际值。
- 对于对象类型，==比较它们的引用是否相同。

equals() 方法

equals()方法用于比较两个对象的内容是否相等，通常会覆盖 Object 类中的 equals() 方法来实现自定义的比较逻辑。
使用场景：
- equals()适用于需要内容比较的场景。尤其是在处理自定义对象时，通常会重写 equals()方法以提供自定义的比较逻辑。
- 默认的 equals() 方法（来自 Object 类）与 == 的行为相同，比较的是对象的引用。

注意事项：

对称性 ：如果 a.equals(b) 为 true，那么 b.equals(a) 也必须为 true。
传递性 ：如果 a.equals(b) 和 b.equals(c) 都为 true，那么 a.equals(c) 也必须为 true。
一致性 ：如果没有修改对象的内容，多次调用 a.equals(b) 必须返回相同的结果。
非空性 ：对于任何非空引用 a，a.equals(null) 应该返回 false。

4.3 toString()

toString()方法返回对象的字符串表示，通常是类名后跟"@"符号和对象的哈希码（十六进制表示）

基本格式：

public String toString() {

return getClass().getName() + "@" + Integer.toHexString(hashCode());

}

IDEA使用快捷键：Alt+Inest即可

代码举例：

java 复制代码

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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