Java 继承与多态超详细梳理

public class Base {

     int a;

     int b;

     int c;

}

public class Derived extends Base{

     int a; // 与父类中成员a同名，且类型相同

     char b; // 与父类中成员b同名，但类型不同

     public void method(){

         a = 100 ; // 访问父类继承的a，还是子类自己新增的a？

         b = 101 ; // 访问父类继承的b，还是子类自己新增的b?

         c = 102 ; // 子类没有c，访问的肯定是从父类继承下来的c

     }

}

public class Base {

     int a;

     int b;

     public void methodA(){

         System.out.println( "Base中的methodA()" );

     }

     public void methodB(){

         System.out.println( "Base中的methodB()" );

}

public class Derived extends Base{

     int a;

     char b;

     // 与父类中methodA()构成重载

     public void methodA( int a) {

         System.out.println( "Derived中的method()方法" );

     }

     // 与父类中methodB()构成重写

     public void methodB(){

         System.out.println( "Derived中的methodB()方法" );

     }

     public void methodC(){

         a = 100 ; // 等价于： this.a = 100;

         b = 101 ; // 等价于： this.b = 101;

         // 访问父类的成员变量时，需要借助super关键字

         // super是获取到子类对象中从基类继承下来的部分

         super .a = 200 ;

         super .b = 201 ;

         methodA(); // 没有传参，访问父类中的methodA()

         methodA( 20 ); // 传递int参数，访问子类中的methodA(int)

         methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到

         super .methodB(); // 访问基类的methodB()

     }

}

public class Base {

     public Base(){

         System.out.println( "Base()" );

     }

}

public class Derived extends Base{

     public Derived(){

    // super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super(),

    // 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，

    // 并且只能出现一次

         System.out.println( "Derived()" );

     }

}

public class TestAnimal {

     // 2. 函数传参：形参为父类引用，可以接收任意子类的对象

     public static void eatFood(Animal a) {

         a.eat();

     }

     // 3. 作返回值：返回任意子类对象

     public static Animal buyAnimal(String var) {

         if ( "狗" == var) {

             return new Dog( "狗狗" , 1 );

         } else if ( "猫" == var) {

             return new Cat( "猫猫" , 1 );

         } else {

             return null ;

         }

     }

     public static void main(String[] args) {

         Animal cat = new Cat( "元宝" , 2 ); // 1. 直接赋值：子类对象赋值给父类对象

         Dog dog = new Dog( "小七" , 1 );

     }

}

public class Animal(){

     String name;

     int age;

     public Animal(String name, int age){

         this .name = name;

         this .age = age;

     }

     public void eat(){

         System.out.println(name + "吃饭" );

         }

}

public class Cat extends Animal{

     public Cat(String name, int age){

         super (name, age);

     }

     @Override

     public void eat(){

         System.out.println(name+ "吃鱼~~~" );

     }

}

public class Dog extends Animal {

     public Dog(String name, int age){

         super (name, age);

     }

     @Override

     public void eat(){

         System.out.println(name+ "吃骨头~~~" );

     }

}

public class TestAnimal {

     // 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法

    // 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法

    // 注意：此处的形参类型必须时父类类型才可以

     public static void eat(Animal a){

         a.eat();

     }

     public static void main(String[] args) {

         Animal animal1 = new Cat( "元宝" , 2 );

         Animal animal2 = new Dog( "小七" , 1 );

         eat(animal1);

         eat(animal2);

     }

}