Java入门 面向对象(多态、抽象类) (第二十天)

多态的概念：

生活中：同一个事物，作用条件不一样，结果不一样

Java中：同一个父类引用，指向不同的子类实例，执行不同的操作
               方法重写是实现多态的前提   

多态的实现步骤：

多态实现步骤：

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

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

使用父类作为方法的形参，是Java中实现和使用多态的主要方式

使用父类作为方法的返回值，也是Java中实现和使用多态的主要方式

抽象： 

抽象方法：使用abstract修饰的方法为抽象方法

          1）抽象方法没有方法体
          2）抽象方法所在的类需要声明为抽象类
          3）子类继承一个抽象类后，子类中必须重写抽象父类中         
             所有的抽象方法，如果
                不重写，那么子类也需要定义为抽象类

抽象类：使用abstract修饰的类为抽象类

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

代码（类）

package AnimalDemo04;

public abstract class Father {//使用abstract修饰的类为抽象类
	//定义属性
	private String name;
	private int age;

	//无参构造方法
	public Father() {
		super();
	}
	
	//有参构造方法
	public Father(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	
	//get/aet方法
	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;
	}

	
     //toString重写方法
	@Override
	public String toString() {
		return "Father [name=" + name + ", age=" + age + "]";
	}
	
	/*public void test(){
		System.out.println("我是Father类中的test()方法");
	}*/
	
	//抽象方法使用abstract修饰，没有方法体
	public abstract void test();

}

子类

package AnimalDemo04;

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()方法");

	}

}

对象

package AnimalDemo04;

public class Test {
	
	public static void main(String[] args) {

		//创建Father类对象
	    //Father father=new Father();//抽象类不能实例化，因为没有意义
		
		//向上转型：父类引用指向子类的实例
		Father father = new Son1("土灵", 23, 178);
		father.test();	
		
	}
}

转型

向上转型

      语法：
       <父类型> <引用变量名> = new <子类型>();

向上转型：父类的引用指向子类对象，自动进行类型转换

注意：
   1） 此时通过父类引用变量调用的方法是子类 
         覆盖或继承父类的方法，不是父类的方法
   2）此时通过父类引用变量无法调用子类特有 
         的方法

向下转型

 语法：
         <子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;

向下转型：将一个指向子类对象的父类引用赋给一个子类的引用，即：父类类型转换为子类类型。需强制类型转换
   
注意：在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常

代码：父类

package AnimalDemo06;

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

子类：1

package AnimalDemo06;

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()");
	}

}

子类：2

package AnimalDemo06;

public class Son2 extends Father {

	private double weight;
	
	
	public Son2() {
		super();
	}
	
	public Son2(String name, int age, double weight) {
		super(name, age);
		this.weight = weight;
	}
	

	public double getWeight() {
		return weight;
	}
	public void setWeight(double weight) {
		this.weight = weight;
	}
	
	@Override
	public void test() {
		System.out.println("我是Son2类中重写Father类里的test()方法");
		
	}
	
	//定义一个Son2类中独有的方法
	
	public void son2Method(){
		System.out.println("我是Son2类中独有的sonMethod()方法");
	}
	

}

 对象(向上转型)

package AnimalDemo06;

public class Test {
	
	public static void main(String[] args) {
		//创建Father类对象
	    //Father father=new Father();//抽象类不能实例化，因为没有意义
		
		//向上转型：父类引用指向子类的实例
		Father father = new Son1("光头强", 23, 178);
		father.test();
	}
}

 对象(向下转型)

package AnimalDemo06;

public class Test {
	
	public static void main(String[] args) {
		//创建Father类对象
	    //Father father=new Father();//抽象类不能实例化，因为没有意义
		

		
		//父类的引用不能调用子类里的方法，需要进行强制类型转换(向下转型)
//		father.son1Method();
		

			//向下转型，子类的引用指向父类的引用
			Son1 son = (Son1)father;
			son.son1Method();

	}
}

instanceof

如何减少在向下转型的过程中，没有转换为真实子类类型的类型转换异常？
        Java中提供了instanceof运算符来进行类型的判断

使用instanceof时，对象的类型必须和instanceof后面的参数所指定的类在继承上有上下级关系
 

package AnimalDemo06;

public class Test {
	
	public static void main(String[] args) {
		//创建Father类对象
	    //Father father=new Father();//抽象类不能实例化，因为没有意义
		
		//向上转型：父类引用指向子类的实例
		Father father = new Son1("光头强", 23, 178);
		father.test();
		
			
		
		//父类的引用不能调用子类里的方法，需要进行强制类型转换(向下转型)
//		father.son1Method();
		

        //instanceof进行类型的判断
		if(father instanceof Son1){
			//向下转型，子类的引用指向父类的引用
			Son1 son = (Son1)father;
			son.son1Method();
		}else if(father instanceof Son2){
			//向下转型，子类的引用指向父类的引用
			Son2 son= (Son2)father;
			son.son2Method();
		}	
		
	}
}