关于java继承/多态知识

子类要是重写了父类的方法，执行子类的方法

public class Person{
  public void run(){
        
  }  
}


public class Student extend Person{
  @override 
  public void run(){
        System.out.print("son");
  }    

  public void eat(){

  }  
}

public class Application{
    public static void main(string[] args) {
    //一个对象的实际类型是确定的
    //new student()
    //new Person ();

    //可以指向的引用型就个确定了:父类的引用指向了类
　　//Student能用的方法都是自己的或者继承父类的
    Student s1 = new Student();
　　//Person父类,可以指向子类,但是不能调用子类独有的方法
    Person s2 = new Student();
    Object s3 = new Student();
    s2.run();   //子类重写了父类的方法,魏行子类的方法,输入son
    s1.run();

    s2.eat();   //报错，对象能执行哪些方法,主要看对象左边的类,和右边关系不大!
    s1.eat();

    }
}

　　

知识点一：关于继承关键字

extends关键字

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

私有的东西无法被继承

implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

知识点二：

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

this指的是当前这个类的东西，super指的是父类的东西

实例：

class Animal

{ void eat()

    { System.out.println("animal : eat"); }

}

class Dog extends Animal

{ void eat()

    { System.out.println("dog : eat"); }

  void eatTest()

    {

      this.eat(); // this 调用自己的方法

      super.eat(); // super 调用父类方法

    }

}

public class Test

{

　　public static void main(String[] args) {

　　　　Animal a = new Animal();

　　　　a.eat();

　　　　Dog d = new Dog();

　　　　d.eatTest(); }

}

 

 

super();隐藏代码。且必须在第一行（this也是，所以this和super只能使用一个调用无参构造方法）

 

final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

• 声明类：

  final class 类名 {//类体}

• 声明方法：

  修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final

 

知识点三：

构造器

子类不能继承父类的构造器（构造方法或者构造函数），但是父类的构造器带有参数的，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。

如果父类有无参构造器，则在子类的构造器中用super调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。

补充：当父类的构造函数有参，在子类里没有使用super调用并配参，会报错：

错误：Implicit super constructor xx() is undefined for default constructor. Must define an explicit constructor

因为你的父类已经定义了一个有参的构造函数，此时编译器不会为你调用默认的构造函数，

当子类继承时，必须在自己的构造函数显式调用父类的构造函数，自己才能确保子类在初始化前父类会被实例化，

如果你父类中有无参的构造函数，子类就不会强制要求调用，即你写的那个就可以通过，

编译器会默认帮你调用父类的构造函数。 

 实例：

class Person {
　　protected String name;
　　protected int age;

//你已经定义了自动的构造函数，此时编译器不会为你创建默认的构造函数
  public Person(String name,int age) {
　　this.name=name;
　　this.age=age;
  }   

  public void print() {
　　System.out.println("Name:"+name+"/nAge:"+age);
  }
}

/*由于父类的构造函数是有参的，所以编译不会为你自动调用默认的构造函数，此时，子类在自己的构造函数中必须显式的调用父类的构造函数 */

class Student extends Person { 

　　public void Student(){      //子类构造函数 

　　　　//super();   不行，因为你的父类没有无参的构造函数 

 　　　　super("a",1);
　　　　//显示调用父类的构造函数，而且必须是第一行调用
       }
}

 

补充：多态

1.多态是方法的多态,属性没有多态
2父类和了类,有联系  类型转换异常! CLassCastException!
3.存在条件 : 继承关系,方法需要重写,父类引用指向子类对象! Father f1= new Son()

以下修饰的方法不能重写：

1, static方法,属性类,它不属于实例
2. final 常量
3. private 方法;