java多态

多态：同一个引用类型，使用不同的实例而执行不同操作

多态：同一个事物，作用条件不一样，结果不一样
多态：同一个父类引用，指向不同的子类实例，执行不同的操作
    方法重写是实现多态的前提

// 创建Father类对象
		// Father father = new Father();//抽象类不能实例化，因为没有意义
		
		//向上转型：父类引用指向子类的实例
		Father father = new Son1("张三", 22, 173);
		father.test();
		
//		father = new Son2("李四", 25, 160);
//		father.test();

多态实现步骤：
    1）在抽象父类中定义抽象方法
    2）子类继承抽象父类并重写父类中所有的抽象方法
    3）测试类中创建父类引用指向不同的子类实例，父类引用调用方法，调用的是子类重写后的那些方法
            向上转型（自动类型转换）：父类的引用指向子类的实例
            向下转型（强制类型转换）：子类的引用指向父类的引用

//父类的引用不能调用子类里的方法，需要进行强制类型转换(向下转型)
//		father.son1Method();
		
		if(father instanceof Son1){
			//向下转型：子类的引用指向父类的引用
			Son1 son = (Son1)father;
			son.son1Method();
		}else if(father instanceof Son2){
			//向下转型：子类的引用指向父类的引用
			Son2 son = (Son2)father;
			son.son2Method();
		}

父类的引用无法调用子类里独有的方法，必须使用向下转型成对应的子类，才能通过子类去调用子类中独有的方法
    在向下转型的时候，容易出现ClassCastException（类型转换异常），原因是将父类引用转换成了不匹配的子类对象
    可以通过instanceof关键字类判断父类引用指向的是哪一个子类实例，从而避免类型转换异常

father instanceof Son1

抽象方法

抽象方法没有方法体

抽象方法必须在抽象类里

抽象方法必须在子类中被实现，除非子类是抽象类

package cn.bdqn.demo06;

public abstract class Father {

	private String name;
	private int age;

	public Father() {
		super();
	}

	public Father(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Father [name=" + name + ", age=" + age + "]";
	}
	
	public abstract void test();
	

}

package cn.bdqn.demo06;

public class Son1 extends Father {

	private double height;

	public Son1() {
		super();
	}

	public Son1(String name, int age, double height) {
		super(name, age);
		this.height = height;
	}

	public double getHeight() {
		return height;
	}

	public void setHeight(double height) {
		this.height = height;
	}

	@Override
	public void test() {
		System.out.println("我是Son1类中从写Father类里的test()方法");

	}
	
	//定义一个Son1类里独有的方法
	public void son1Method(){
		System.out.println("我是Son1类里的独有方法son1Method()");
	}

}

 

抽象类：使用abstract修饰的类为抽象类
     *     1）抽象类的声明跟之前声明一个类没有太大的区别，依然可以封装属性、声明构造方法、声明getXxx()/setXxx()方法、重写toString()方法等
     *     2）抽象类中可以包含抽象方法、也可以不包含抽象方法（但是抽象方法所在的类一定要声明为抽象类）
     *     3）抽象类不能实例化（不能通过new的方式来创建对象）