深入讲解Java中的多态和抽象类

class Pet{
    public String name="pet";
    public void speak(){
    }
}
class Dog extends Pet{
    public String name="dog";
    @Override
    public void speak(){
        System.out.println("汪汪汪");
    }
    public void work(){
    }
}
class Cat extends Pet{
    public String name="cat";
    @Override
    public void speak(){
        System.out.println("喵喵喵");
    }
}
class Master{
    public void speak(Pet pet){//形参是父类类型对象
        pet.speak();
    }
}

Pet pet = new Dog();//使用父类类型声明对象，创建的是子类对象
//等号左边是编译时类型，等号右边是运行时类型

pet.play();//编译和运行都正常
//pet.work();//报错
/*
	报错原因
	1.调用时按照编译时方法调用，运行方法时按照运行时类型运行
    2.能调用什么类型看等号左边有定义什么方法，子类独有的方法不能被调用
    3.调用了重写方法时，调用的是父类的方法，执行时入栈的是子类重写过的方法
*/
Dog dog = (Dog)pet;
dog.work();//正确，先进行强转，然后调用子类独有的方法

//访问属性时，默认访问的是引用类型的属性
System.out.println(pet.name);//pet
System.out.println(pet1.name);//pet

@Test
public void test(){
    Master master = new Master();
    Pet pet = new Cat();//使用父类类型声明对象，创建的是子类对象
    //等号左边是编译时类型，等号右边是运行时类型
    //调用时按照编译时方法调用，运行方法时按照运行时类型运行
    //能调用什么类型看等号左边有定义什么方法，子类独有的方法不能被调用
    //调用了重写方法时，调用的是父类的方法，执行时入栈的是子类重写过的方法
    Pet pet1 = new Dog();
    master.speak(new Cat());//实参是子类类型对象
    master.speak(new Dog());
    //访问属性时，默认访问的是引用类型的属性
    System.out.println(pet.name);//pet
    System.out.println(pet1.name);//pet
}

@Test
public void test(){
    //实际在堆中创建的对象类型是运行时类型，也就是Dog类对象
    Pet pet = new Dog();//将子类对象的引用类型从子类类型自动提升成父类类型，称为向上转型
    Cat cat = (Cat)pet;//编译不报错，运行时报错ClassCastException
    Dog dog = (Dog)pet;//强制类型转换，将父类引用类型转成子类引用类型，向下转型
}

@Test
public void test(){
    //实际在堆中创建的对象类型是运行时类型，也就是Dog类对象
    Pet pet = new Dog();//将子类对象的引用类型从子类类型自动提升成父类类型，称为向上转型
    Cat cat = (Cat)pet;//编译不报错，运行时报错ClassCastException
    Dog dog = (Dog)pet;//强制类型转换，将父类引用类型转成子类引用类型，向下转型
    System.out.println(pet instanceof Dog);//true
    System.out.println(pet instanceof Cat);//false
    System.out.println(pet instanceof Pet);//true
}

@Test
public void test(){
    Pet[] pets = new Pet[4];
    pets[0] = new Cat();
    pets[1] = new Dog();
    pets[2] = new Dog();
    pets[3] = new Cat();
    for(int i=0;i<pets.length;i++){
        pets[i].play();
    }
}

   /*
   	1、编译期间进行静态分派：即确定是调用Animal类中的public void eat()方法，如果Animal类或它的父类中没有这个方法，将会报错。
   	2、运行期间进行动态绑定：即确定执行的是Cat类中的public void eat()方法，因为子类重写了eat()方法，如果没有重写，那么还是执行Animal类在的eat()方法
   */
   abstract class Animal {  
       public abstract void eat();  
   }  
   class Cat extends Animal {  
       public void eat() {  
           System.out.println("吃鱼");  
       }  
   }  
   class Dog extends Animal {  
       public void eat() {  
           System.out.println("吃骨头");  
       }  
   }
   public class Test{
       public static void main(String[] args){
           Animal a = new Cat();
           a.eat();
       }
   }

   class Father{
   }
   class Son extends Father{
   }
   class Daughter extends Father{
   }
   class MyClassOne{
   	public void method(Father f) {
   		System.out.println("father");
   	}
   	public void method(Son s) {
   		System.out.println("son");
   	}
       public void method(Daughter d) {
   		System.out.println("daughter");
   	}
   }
   class MyClassTwo{
   	public void method(Father f) {
   		System.out.println("father");
   	}
   	public void method(Son s) {
   		System.out.println("son");
   	}
   }
   public class TestOverload {
       /*
       	1、编译期间进行静态分派：即确定是调用MyClassOne类中的method(Father f)方法。
       	2、运行期间进行动态绑定：确定执行的是MyClassOne类中method(Father f)方法
       	## 因为此时f,s,d编译时类型都是Father类型，因此method(Father f)是最合适的
       */
       @Test
   	public void test() {
   		MyClassOne my = new MyClassOne();
   		Father f = new Father();
   		Father s = new Son();
   		Father d = new Daughter();
   		my.method(f);//father
   		my.method(s);//father
   		my.method(d);//father
   	}
       /*
       	1、编译期间进行静态分派：即确定是分别调用MyClassTwo类中的method(Father f)，method(Son s)，method(Father f)方法。
       	2、运行期间进行动态绑定：即确定执行的是MyClass类中的method(Father f)，method(Son s)，method(Father f)方法
       	## 因为此时f,s,d编译时类型分别是Father、Son、Daughter，而Daughter只能与Father参数类型匹配
       */
       @Test
   	public void test() {
   		MyClassTwo my = new MyClassTwo();
   		Father f = new Father();
   		Son s = new Son();
   		Daughter d = new Daughter();
   		my.method(f);//father
   		my.method(s);//Son
   		my.method(d);//father
   	}
   }

    class MyClass{
    	public void method(Father f) {
    		System.out.println("father");
    	}
    	public void method(Son s) {
    		System.out.println("son");
    	}
    }
    class MySub extends MyClass{
    	public void method(Daughter d) {
    		System.out.println("daughter");
    	}
    }
    class Father{
    }
    class Son extends Father{
    }
    class Daughter extends Father{
    }
    /*
    	1、编译期间进行静态分派：即确定是分别调用MyClass类中的method(Father f)，method(Son s)，method(Father f)方法。
    	2、运行期间进行动态绑定：即确定执行的是MyClass类中的method(Father f)，method(Son s)，method(Father f)方法。
    	## my变量在编译时类型是MyClass类型，那么在MyClass类中，只有method(Father f)，method(Son s)方法。,s,d变量编译时类型分别是Father、Son、Daughter，而Daughter只能与Father参数类型匹配。而在MySub类中并没有重写method(Father f)方法，所以仍然执行MyClass类中的method(Father f)方法
    */
    public class TestOverload {
    	public static void main(String[] args) {
    		MyClass my = new MySub();
    		Father f = new Father();
    		Son s = new Son();
    		Daughter d = new Daughter();
    		my.method(f);//father
    		my.method(s);//son
    		my.method(d);//father
    	}
   }

public class TestOne {
    public static void main(String[] args) {
        //Person person = new Person();//报错，不允许创建对象
        //Person p = new Woman();//报错，不允许创建对象
        Person student = new Student();//正确
        Woman student1 = new Student();//正确
        Student student3 = new Student();//正确
        //创建的对象可以调用抽象类的普通方法
        //当继承体系中抽象类存在相同方法签名的重名方法时，采用就近原则
        //不管创建的是哪个子类的对象，都是从现在当前类寻找方法进行调用，然后寻找本类的子父类，然后寻找本类的父类的父类
        student.methodOne();
        student1.methodOne();
        student3.methodOne();
        //访问成员变量，声明的引用类型是什么类型，就访问此类型中的成员变量
        System.out.println(student.country);
        System.out.println(student1.country);
        System.out.println(student3.country);
    }
}
abstract class Person{
    //抽象类可以有自己的属性
    public String country="person";
    //可以有抽象方法
    abstract void sayHello();
    //可以有普通方法
    public void methodOne(){
        System.out.println("in abstract class Person methodOne");
    }
}
abstract class Woman extends Person{
    public String country="woman";
    abstract void sing();
    public void methodOne(){
        System.out.println("in abstract class Woman methodOne");
    }
}
class Student extends Woman{
    public String country="student";
    @Override
    void sayHello() {
    }
    @Override
    void sing() {
    }
    public void methodOne(){
        System.out.println("in abstract class Student methodOne");
    }
}

public String toString()

public class Person {  
    private String name;
    private int age;
    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
    // 省略构造器与Getter Setter
}

public static void main(String[] args) {
		Object obj = new String();
		System.out.println(obj.getClass());//运行时类型
	}

public class TestFinalize {
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			MyData my = new MyData();
		}
		System.gc();//通知垃圾回收器来回收垃圾
		try {
			Thread.sleep(2000);//等待2秒再结束main，为了看效果
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
class MyData{
	@Override
	protected void finalize() throws Throwable {
		System.out.println("轻轻的我走了...");
	}
}

public static void main(String[] args) {
		System.out.println("Aa".hashCode());//2112
		System.out.println("BB".hashCode());//2112
	}