Java超详细讲解继承和多态的使用

class Animal{

     public String name;

     public int age;

     public String sex;

     public void eat(){

         System.out.println( this .name+ "cat::eat()!" );

     }

     public void sleep(){

         System.out.println( this .name+ "睡觉！" );

     }

}

/**

  * 继承  其实就是对共性的抽取  从而达到了代码的复用

  */

class Cat extends Animal{

     public void mew(){

         System.out.println( this .name+ "cat::mew()!" );

     }

}

class Dog extends Animal{

     public void bark(){

         System.out.println( "dog::bark()!" );

     }

}

public class TestDemo {

     public static void main(String[] args) {

         Cat cat = new Cat();

         cat.name = "咪咪" ;

         cat.sleep();

         cat.eat();

         cat.mew();

     }

}

public class Base {

     int a;

     int b;

}

public class Derived extends Base{

     int c;

     public void method(){

         a = 10 ;    // 访问从父类中继承下来的a

         b = 20 ;    // 访问从父类中继承下来的b

         c = 30 ;    // 访问子类自己的c

    }

}

class Base {

     public int a = 1 ;

     public int b = 2 ;

     public void method(){

         System.out.println( "BASE::TEST()" );

     }

}

class Derived extends Base{

     public int a = 3 ;

     public int d = 4 ;

     public void method2(){

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

     }

     public void test(){

         method2();

         method();

         /*System.out.println(a);//如果重名类  优先访问自己的

         System.out.println(super.a);//写代码的时候  让这个代码更已读

         System.out.println(this.b);

         System.out.println(d);*/

     }

}

public class TestDemo2 {

     public static void main(String[] args) {

         Derived derived = new Derived();

         derived.test();

     }

}

public class Base {

  public void methodA(){

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

  }

}

public class Derived extends Base{

     public void methodB(){

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

    }

     public void methodC(){

         methodB();         // 访问子类自己的methodB()

         methodA();         // 访问父类继承的methodA()

         // methodD();     // 编译失败，在整个继承体系中没有发现方法methodD()

    }

}

public class Base {

  public void methodA(){

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

  }

  public void methodB(){

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

  }

}

public class Derived extends Base{

     public void methodA( int a) {

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

    }

     public void methodB(){

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

    }

     public void methodC(){

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

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

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

    }

}

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;

         // 注意：this是当前对象的引用

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

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

         super .a = 200 ;

         super .b = 201 ;

         // 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法

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

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

         // 如果在子类中要访问重写的基类方法，则需要借助super关键字

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

         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 Test {

     public static void main(String[] args) {

         Derived d = new Derived();

    }

}

class Person {

     public String name;

     public int age;

     public Person(String name, int age) {

         this .name = name;

         this .age = age;

         System.out.println( "构造方法执行" );

    }

    {

         System.out.println( "实例代码块执行" );

    }

     static {

         System.out.println( "静态代码块执行" );

         }

}

public class TestDemo {

     public static void main(String[] args) {

         Person person1 = new Person( "bit" , 10 );

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

         Person person2 = new Person( "gaobo" , 20 );

    }

}

// 为了掩饰基类中不同访问权限在子类中的可见性，为了简单类B中就不设置成员方法了

// extend01包中

public class B {

     private int a;

     protected int b;

     public int c;

     int d;

}

// extend01包中

// 同一个包中的子类

public class D extends B{

     public void method(){

         // super.a = 10;     // 编译报错，父类private成员在相同包子类中不可见

         super .b = 20 ;         // 父类中protected成员在相同包子类中可以直接访问

         super .c = 30 ;         // 父类中public成员在相同包子类中可以直接访问

         super .d = 40 ;         // 父类中默认访问权限修饰的成员在相同包子类中可以直接访问

    }

}

// extend02包中

// 不同包中的子类

public class C extends B {

     public void method(){

         // super.a = 10;     // 编译报错，父类中private成员在不同包子类中不可见

         super .b = 20 ;        // 父类中protected修饰的成员在不同包子类中可以直接访问

         super .c = 30 ;        // 父类中public修饰的成员在不同包子类中可以直接访问

         //super.d = 40;     // 父类中默认访问权限修饰的成员在不同包子类中不能直接访问

    }

}

// extend02包中

// 不同包中的类

public class TestC {

     public static void main(String[] args) {

         C c = new C();

          c.method();

         // System.out.println(c.a);   // 编译报错，父类中private成员在不同包其他类中不可见

         // System.out.println(c.b);   // 父类中protected成员在不同包其他类中不能直接访问

         System.out.println(c.c);      // 父类中public成员在不同包其他类中可以直接访问

         // System.out.println(c.d);   // 父类中默认访问权限修饰的成员在不同包其他类中不能直接访问

    }

}

// 轮胎类

class Tire{

     // ...

}

// 发动机类

class Engine{

     // ...

}

// 车载系统类

class VehicleSystem{

     // ...

}

class Car{

     private Tire tire;          // 可以复用轮胎中的属性和方法

     private Engine engine;      // 可以复用发动机中的属性和方法

     private VehicleSystem vs;   // 可以复用车载系统中的属性和方法

     // ...

}

// 奔驰是汽车

class Benz extend Car{

     // 将汽车中包含的：轮胎、发送机、车载系统全部继承下来

}

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) {

         Cat cat = new Cat( "元宝" , 2 );

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

         eat(cat);

         eat(dog);

    }

}

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 );

         eatFood(cat);

         eatFood(dog);

         Animal animal = buyAnimal( "狗" );

         animal.eat();

         animal = buyAnimal( "猫" );

         animal.eat();

    }

}

public class TestAnimal {

     public static void main(String[] args) {

         Cat cat = new Cat( "元宝" , 2 );

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

         // 向上转型

         Animal animal = cat;

         animal.eat();

         animal = dog;

         animal.eat();

         // 编译失败，编译时编译器将animal当成Animal对象处理

         // 而Animal类中没有bark方法，因此编译失败

         // animal.bark();

         // 向上转型

         // 程序可以通过编程，但运行时抛出异常---因为：animal实际指向的是狗

         // 现在要强制还原为猫，无法正常还原，运行时抛出：ClassCastException

         cat = (Cat)animal;

         cat.mew();

         // animal本来指向的就是狗，因此将animal还原为狗也是安全的  

         dog = (Dog)animal;

         dog.bark();

    }

}

public class TestAnimal {

     public static void main(String[] args) {

         Cat cat = new Cat( "元宝" , 2 );

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

         // 向上转型

         Animal animal = cat;

           animal.eat();

         animal = dog;

         animal.eat();

         if (animal instanceof Cat){

             cat = (Cat)animal;

             cat.mew();

        }

         if (animal instanceof Dog){

             dog = (Dog)animal;

             dog.bark();

        }

    }

}

public static void drawShapes() {

     Rect rect = new Rect();

     Cycle cycle = new Cycle();

     Flower flower = new Flower();

     String[] shapes = { "cycle" , "rect" , "cycle" , "rect" , "flower" };

     for (String shape : shapes) {

         if (shape.equals( "cycle" )) {

             cycle.draw();

        } else if (shape.equals( "rect" )) {

             rect.draw();

        } else if (shape.equals( "flower" )) {

             flower.draw();

        }

    }

}

public static void drawShapes() {

     // 我们创建了一个 Shape 对象的数组.

     Shape[] shapes = { new Cycle(), new Rect(), new Cycle(),

                       new Rect(), new Flower()};

     for (Shape shape : shapes) {

         shape.draw();

    }

}

class Triangle extends Shape {

     @Override

     public void draw() {

         System.out.println( "△" );

    }

}

class B {

     public B() {

         // do nothing

         func();

    }

     public void func() {

         System.out.println( "B.func()" );

    }

}

class D extends B {

     private int num = 1 ;

     @Override

     public void func() {

         System.out.println( "D.func() " + num);

    }

}

public class Test {

     public static void main(String[] args) {

         D d = new D();

         }

}