super关键字及方法重写

super关键字及方法重写

1.super关键字

• 调用父类 (Superclass) 的属性成员或者方法(super.属性名）(super.方法名()）；

• 调用父类的构造方法super();

• 误区：super表示父类对象，这个说法相当于说super关键字会在子对象里创建一个父对象。这是错误的。因为在创建子类对象时不会创建父类对象；

• 只会将父类信息加载到子类对象中存储；

• super(实参)的作用是：初始化当前对象的父类型特征；

  并不是创建新对象。实际上对象只创建了1个。

  下面用以前的代码来具体解释super关键字：

实例

package jicheng;

public class Animal {
    private int age;
    private String name;
    public Animal(){
        super();//默认有；
        System.out.println("Animal的无参构造");
    }
    public Animal(String name){
        super();
        System.out.println("Animal的有参构造");
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
}

package jicheng;

public class Dog extends Animal{
    public Dog(){
        super();//默认有；
        System.out.println("Dog的无参构造");
    }
    public Dog(String name){
        super(name);//调用父类有参构造
        System.out.println("Dog的有参构造");
    }
}

package jicheng;

public class hashiqi extends Dog {
    public hashiqi(){
        super();//默认有super()去调用父类的无参构造
        System.out.println("哈士奇的无参构造");
    }
    public hashiqi(String name){
        super(name);//如果不设置，则默认有super()去调用父类的无参构造；
        System.out.println("哈士奇的有参构造");
    }
}

package jicheng;

public class Demo {
    public static void main(String[] args) {
        hashiqi hsq1=new hashiqi();
        System.out.println();
        hashiqi hsq2 = new hashiqi("哈士奇");
    }
}

输出结果;

Animal的无参构造
Dog的无参构造
哈士奇的无参构造

Animal的有参构造
Dog的有参构造
哈士奇的有参构造

注意：在构造方法执行过程中一连串调用了父类的构造方法，父类的构造方法又继续向下调用它的父类的构造方法，但是实际上对象只 创建了一个。

2.方法重写

1，什么是方法重写

• 重写:子父类出现了一模一样的方法(注意:返回值类型可以是子父类）；

2，方法重写的应用：

• 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。

方法重写

重新定义从超类继承的类中的实例方法称为方法重写。

例子

让我们考虑类A和类B的以下声明:

public class A  {
    public void  print() { 
        System.out.println("A");
    }
}

public class B  extends A  {
    public void  print() { 
        System.out.println("B");
    }
}

类B是类A的子类。类B从其父类继承print()方法并重新定义它。

类B中的print()方法覆盖类A的print()方法。

如果一个类覆盖了一个方法，它会影响覆盖的类及其子类。考虑下面的类C的声明：

public class C  extends B  {
}

类C不声明任何方法。它继承类B中的print()方法。

注意

• 类总是继承它的直接超类的可用的。
• 方法必须是实例方法。重写不适用于静态方法。
• 重写方法必须具有与重写方法相同的名称。
• 重写方法必须具有与重写方法相同顺序的相同类型的相同数量的参数。
• 当方法的参数使用通用类型时，考虑通用类型参数的擦除，而不是通用类型本身与其他方法比较。
• 参数的名称无关紧要。
• 如果重写方法的返回类型是引用类型，则重写方法的返回类型必须与重写方法的返回类型兼容。

访问级别

• 重写方法的访问级别必须至少与重写方法的访问级别相同或更宽松。
• 下表列出了重写方法允许的访问级别

重写方法访问级别	允许重写方法访问级别…
public	public
protected	public, protected
package-level	public, protected, package-level

重写的访问

从子类访问重写的方法。子类可以使用关键字super作为限定符来调用超类的重写方法。