Java面向对象（5）

 * 面向对象特征之三：多态性（运行时行为）
 * 
 * 1.理解多态性：可以理解为一个事物的多种形态。
 * 2.何为多态性：
 *   对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
 *   
 * 3. 多态的使用：虚拟方法调用

• 虚方法调用，可以实现运行时的多态
  • 子类重载了父类的方法时，运行时系统根据调用该方法的实例的类型来决定选择哪一个方法调用。
  • 所有的非final方法都会自动地进行动态绑定。

public class TestVirtualInvoke{
    static void doStuff(Shape s){ // Shape为形式参数类型
        s.draw();
    }
    public static void main(String[] args) {
        Shape s = new Shape();
        Cricle c = new Cricle();
        Triangle t = new Triangle();
        Shape l = new Line(); // 可以将父类类型的引用指向子类的实例对象

        doStuff(s); 
        doStuff(c); // 调用的时候，使用其子类实例作为实参
        doStuff(t); // 运行时，系统根据调用方法的实例类型，来决定哪一个方法被调用
        doStuff(l);
    }
}

class Shape{
    void draw(){ System.out.println("Draw Shape"); }
}

class Cricle extends Shape{
    // 子类重载了父类的方法
    void draw(){ System.out.println("Draw Cricle"); }
}

class Triangle extends Shape{
    void draw(){ System.out.println("Draw Triangle"); }
}

class Line extends Shape{
    void draw(){ System.out.println("Draw Line"); }
}

-----------OUTPUT-----------  
Draw Shape
Draw Cricle
Draw Triangle
Draw Line

 *   有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
 *   总结：编译，看左边；运行，看右边。
 *   

 package com.atguigu.exer;
/*
 * 练习：
 * 1.若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，
 * 系统将不可能把父类里的方法转移到子类中：编译看左边，运行看右边
 * 
 * 2.对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，
 * 这个实例变量依然不可能覆盖父类中定义的实例变量：编译运行都看左边
 * 
 * 
 * 
 * 
 */
class Base {
	int count = 10;

	public void display() {
		System.out.println(this.count);
	}
}

class Sub extends Base {
	int count = 20;

	public void display() {
		System.out.println(this.count);
	}
}

public class FieldMethodTest {
	public static void main(String[] args) {
		Sub s = new Sub();
		System.out.println(s.count);//20
		s.display();//20
		
		Base b = s;//多态性
		//==：对于引用数据类型来讲，比较的是两个引用数据类型变量的地址值是否相同
		System.out.println(b == s);//true
		System.out.println(b.count);//10
		b.display();//20
	}
}

 * 4.多态性的使用前提：  ① 类的继承关系  ② 方法的重写
 * 
 * 5.对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
 

Debug调试：

向下转型：

 * instanceof关键字的使用
         * 
         * a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
         * 
         * 
         *  使用情境：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先
         *  进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
         *  
         *  如果 a instanceof A返回true,则 a instanceof B也返回true.
         *  其中，类B是类A的父类。

//Person是Man的父类
//如果 a instanceof A返回true,则 a instanceof B也返回true.
//	  其中，类B是类A的父类。
if(p2 instanceof Man){
			Man m2 = (Man)p2;
			m2.earnMoney();
			System.out.println("******Man******");
		}
		
		if(p2 instanceof Person){
			System.out.println("******Person******");
		}

 如何才能调用子类特有的属性和方法？

//Person是Man的父类
public class PersonTest {
	public static void main(String[] args) {
    Person p2 = new Man();
    		//如何才能调用子类特有的属性和方法？
		//向下转型：使用强制类型转换符。
		Man m1 = (Man)p2;
		m1.earnMoney();
		m1.isSmoking = true;
		
		//使用强转时，可能出现ClassCastException的异常。
//		Woman w1 = (Woman)p2;
//		w1.goShopping();
		
	
		
		//练习：
		//问题一：编译时通过，运行时不通过
		//举例一：
//		Person p3 = new Woman();
//		Man m3 = (Man)p3;
		//举例二：
//		Person p4 = new Person();
//		Man m4 = (Man)p4;

		
		//问题二：编译通过，运行时也通过
//		Object obj = new Woman();
//		Person p = (Person)obj;
		
		//问题三：编译不通过
//		Man m5 = new Woman();
		
//		String str = new Date();
		
//		Object o = new Date();
//		String str1 = (String)o;
		
		
		
	}
}

多态的面试题

package com.atguigu.exer;

//考查多态的笔试题目：
public class InterviewTest1 {

	public static void main(String[] args) {
		Base1 base = new Sub1();
		base.add(1, 2, 3);

		Sub1 s = (Sub1)base;
		s.add(1,2,3);
	}
}

class Base1 {
	public void add(int a, int... arr) {
		System.out.println("base1");
	}
}

class Sub1 extends Base1 {

	public void add(int a, int[] arr) {
		System.out.println("sub_1");
	}

	
	public void add(int a, int b, int c) {
		System.out.println("sub_2");
	}

}
/*
输出结果
sub_1
sub_2
*/