java多态、重写、Super

Super

​ Super关键字是访问我们java里面子类和父类的关键字，是最关键地方。那么下面就是我对Super的认识和其他文献对Super关键字的了解

​ 用于访问当前对象父类中的成员变量、成员方法或构造函数。在Java程序中，一个子类继承了一个父类，其实就是获取了父类中的所有成员变量和成员方法。但是，在某些情况下，子类中需要访问父类的成员变量或成员方法时，就需要使用super关键字了。

super关键字有以下几种用法：

1. 访问父类的成员变量：

在子类中，可以使用super关键字来访问父类中的成员变量。例如：

class Parent {
    int number = 10;
}

class Child extends Parent {
    int number = 20;

    public void printNumbers() {
        System.out.println(number); // 输出20
        System.out.println(super.number); // 输出10
    }
}

在上面的例子中，Child类继承了Parent类，并且Child类中定义了一个和Parent类中相同名字的成员变量number。在Child类的printNumbers方法中，通过不同的方式输出了这个成员变量的值。

1. 访问父类的成员方法：

在子类中，可以使用super关键字来调用父类中的成员方法。例如：

class Parent {
    public void print() {
        System.out.println("This is parent.");
    }
}

class Child extends Parent {
    public void print() {
        super.print(); // 调用父类的print方法
        System.out.println("This is child.");
    }
}

在上面的例子中，Child类重写了Parent类中的print方法，并且在其中调用了父类的print方法。这样做的好处是可以在不重写父类方法的情况下，扩展父类方法的功能。

1. 调用父类的构造函数：

在子类中，可以使用super关键字来调用父类的构造函数。例如：

class Parent {
    public Parent() {
        System.out.println("This is parent constructor.");
    }
}

class Child extends Parent {
    public Child() {
        super(); // 调用父类的构造函数
        System.out.println("This is child constructor.");
    }
}

在上面的例子中，Child类继承了Parent类，并且在Child类的构造函数中使用了super关键字来调用Parent类中的无参构造函数。这样就可以在初始化Child对象时，先完成父类的初始化工作。

需要注意的是，super关键字必须出现在子类的方法体中，不能在父类中使用（因为父类没有对应的super）；而且，使用super关键字调用父类构造函数时，必须放在子类构造函数的第一行。

我认为通俗的说我们可以把Super的关键字看作我们c++里面的指针

可以把super简单理解为指向父类的一个指针，用于在子类中访问父类的成员变量和成员方法。当子类和父类中出现相同名字的成员变量或成员方法时，使用super可以访问和调用父类中的对应项，避免了子类和父类成员的冲突。另外，使用super还可以在子类构造函数中调用父类构造函数，完成对父类成员变量的初始化。

方法重写

​ 在方法重写里面父类中的方法可以通过子类进行覆盖。子类中方法名和参数列表与父类相同，但是方法实现不同。

方法重写的目的是为了实现多态性，子类可以根据自身的需要重新定义方法的实现方式，从而达到灵活、可扩展的效果。当我们在编写子类时，如果发现父类中已经存在的方法无法满足子类的需求，那么可以通过重写父类的方法，来实现子类的特殊需求。

举个例子，假设我们有一个父类Animal，其中有一个speak方法用于发出声音。然后我们派生出两个子类Dog和Cat，两个子类都有它自己的叫声，因此需要重写speak方法。

父类Animal的定义如下:

public class Animal {
    public void speak() {
        System.out.println("This is an animal.");
    }
}

子类Dog和Cat分别重写speak方法如下：

public class Dog extends Animal {
    @Override
    public void speak() {
        System.out.println("The dog says bark");
    }
}

public class Cat extends Animal {
    @Override
    public void speak() {
        System.out.println("The cat says meow");
    }
}

这样，当我们在程序中使用Dog或Cat对象调用speak方法时，会输出相应的声音，从而实现了多态性。

多态

​ 对于多态的理解我认为是最抽象的，正确来说我认为Java里面面向对象才是java的核心。那么对于java的多态，我在收集内容加上自己的理解，下面就是我认识的多态

​ Java中的多态指的是同一类型的对象，在不同情况下可能表现出不同的行为方式。具体来说，可以通过子类对父类中已有的方法进行重写（覆盖），从而实现同名方法的多态性。

可以通过一句话简洁理解Java中的多态性：一个对象具有多种形态。

举个例子，假设存在一个Person类和两个子类Teacher和Student，Person类有一个introduce方法，这个方法打印出“我是一个人”这个信息。但是，不同的人在介绍自己时所说的话不同，因此我们需要通过多态来实现不同的行为方式。

Teacher和Student类都重写了introduce方法，代码如下：

public class Person {
    public void introduce() {
        System.out.println("我是一个人");
    }
}

public class Teacher extends Person {
    @Override
    public void introduce() {
        System.out.println("我是一名老师");
    }
}

public class Student extends Person {
    @Override
    public void introduce() {
        System.out.println("我是一名学生");
    }
}

现在我们可以通过以下代码来演示多态：

Person person1 = new Teacher();
Person person2 = new Student();

person1.introduce(); // 输出 "我是一名老师"
person2.introduce(); // 输出 "我是一名学生"

可以看到，尽管person1和person2的类型都是Person，但是由于它们分别引用了Teacher和Student类型的对象，因此调用introduce方法时表现出的行为不同。这就是通过多态来实现不同行为方式的一种形式。