面向对象（第二部分）-CSDN博客

本文链接：https://blog.csdn.net/bugnotfound/article/details/138416759

本文详细解释了Java中this关键字用于区分实例变量和局部变量，构造器中调用其他构造器，方法重写、继承性，以及super关键字的作用。同时介绍了多态性，包括编译时和运行时多态性，以及向下转型的概念。最后提到了Object类及其常用方法。

摘要由CSDN通过智能技术生成

this关键字

区分实例变量和局部变量：
- 当实例变量与方法参数或局部变量同名时，可以使用this关键字来区分。例如，this.variable指的是当前对象的实例变量，而variable指的是方法内的局部变量。
调用当前对象的其他方法：
- 可以使用this关键字调用当前对象的其他方法。
构造器中调用其他构造器：
- 在构造器中可以使用this()来调用同一个类的其他构造器。
作为参数传递：
- this关键字可以作为参数传递给其他方法。
返回当前对象：
- 在方法中可以使用return this;来返回当前对象的引用。

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

通过继承，一个类可以从另一个类继承属性和方法，从而形成类之间的层次关系
继承只能是一对一的，而接口的实现可以是一对多的

// 父类
class Animal {
    String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// 子类继承自Animal类
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    public void bark() {
        System.out.println(name + " is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog("Buddy");
        myDog.eat(); // 继承自父类Animal
        myDog.bark(); // 子类自己的方法
    }
}

方法的重写

方法的重写是指子类重新定义（覆盖）其继承自父类的方法
方法名称、参数列表和返回类型必须与父类中被重写的方法完全相同。
子类方法不能缩小父类方法的访问权限。例如，如果父类方法是public，则子类方法也必须是public。
子类方法不能抛出比父类方法声明更多的异常，但可以抛出更少或不抛出异常。
使用@Override注解可以帮助编译器检查是否正确地重写了父类的方法。

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound(); // Output: Animal makes a sound

        Dog dog = new Dog();
        dog.makeSound(); // Output: Dog barks
    }
}

super关键字

用于引用父类的实例变量或方法
它可以用在子类中，以区分子类和父类中具有相同名称的变量或方法
通过super关键字，可以访问父类的构造方法、实例变量和方法，以便在子类中重用父类的功能或扩展其功能
调用可以看作就近原则

调用父类构造方法

在子类的构造方法中使用super()来调用父类的构造方法。这样可以确保先初始化父类的实例变量和执行父类的构造方法，然后再执行子类的构造方法

public class SubClass extends SuperClass {
    public SubClass() {
        super(); // 调用父类的无参构造方法
    }
}

访问父类的实例变量

使用super关键字可以访问父类中被子类覆盖的实例变量。

public class SuperClass {
    int num = 10;
}

public class SubClass extends SuperClass {
    int num = 20;

    public void display() {
        System.out.println("Subclass num: " + num); // 访问子类的num
        System.out.println("Superclass num: " + super.num); // 访问父类的num
    }
}

调用父类的方法

使用super关键字可以调用父类中被子类覆盖的方法。
从结果的角度看，体现了类的继承性
- 当我们创建子类对象后，子类对象就获取了其父类中声明的所有的属性和方法，在权限允许的情况下，可以直接调用
从过程的角度来看
- 当我们通过子类的构造器创建对象时，子类的构造器一定会直接或间接的调用到其父类的构造器，而其父类的构造器同样会直接或简介的调用到其父类的父类的构造器…，直到调用了Object类中的构造器为止
- 正因为我们调用过子类所有的父类的构造器，所以我们就会将父类中声明的属性、方法加载到内存中，供子类的对象使用

public class SuperClass {
    public void display() {
        System.out.println("SuperClass display method");
    }
}

public class SubClass extends SuperClass {
    public void display() {
        super.display(); // 调用父类的display方法
        System.out.println("SubClass display method");
    }
}

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

它允许不同的对象对同一个消息做出不同的响应
使用时需要有继承关系，适用于方法
子类对象的多态性
- 父类的引用指向子类的对象（或子类的对象赋给父类的引用）
编译时多态性：
- 也称为静态多态性，是指在编译时根据引用变量的类型来调用相应的方法。这种多态性是通过方法的重载实现的。编译器在编译时会根据引用变量的类型决定调用哪个方法。
运行时多态性：
- 也称为动态多态性，是指在运行时根据对象的实际类型来调用相应的方法。这种多态性是通过方法的重写实现的。在运行时，虚拟机会动态地确定调用哪个方法。
多态实际上是由一个父类引申出来的拥有各自特殊的方法的子类的集合，这些子类都同属于同一个父类，能够使用父类所蕴含的方法，而多态体现在，当子类对父类的方法进行重写时，不同的子类对于同一个消息就会做出不同的反应；且在进行实例化时由于这些子类均属于同一父类，故可以使用向上转型，即使用父类名来声明子类名，而在new时使用具体的子类。使得由父类声明的实例拥有父类的类型却拥有具体子类的方法。而当拥有多个子类时，即出现了声明上为同一父类实例，却拥有对同一消息做出不同响应的能力
例子：object类的形参可以填写一切对象

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    void sound() {
        System.out.println("Cat barks");
    }
}

public class AnimalTest {
    public static void main(String[] args) {
        AnimalTest test = new AnimalTest();
        Animal animal1 = new Dog(); // 编译时类型为Animal，运行时类型为Dog
        Animal animal2 = new Cat();// 编译时类型为Animal，运行时类型为Cat
        test.adopt(animal1); // 调用的是Dog类的sound方法
        test.adopt(animal2); // 调用的是Cat类的sound方法
    }

    public void adopt(Animal animal){
      animal.sound();//使用父类做方法的形参，即使增加了新的子类，方法也无需改变
    }
}

向下转型

可以看作是多态（向上转型）的反面
指将一个父类类型的对象转换为其子类类型的对象
当你有一个父类引用指向一个子类对象时，如果你想要访问子类特有的方法或属性，就需要进行向下转型。
向下转型需要使用强制类型转换符号，但在进行向下转型之前，最好使用instanceof操作符来检查是否可以安全地进行转换，以避免ClassCastException异常。

class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 向上转型
        animal.eat();

        if (animal instanceof Dog) {//判断animal对象是否是Dog类的实例
            Dog dog = (Dog) animal; // 向下转型
            dog.bark();
        }
    }
}