(面向对象) 多态

目录

 

多态：同一个对象(事物)，在不同时刻体现出来的不同状态。

 多态的前提：

多态中的成员访问特点：

多态的好处：

用工具类实现多态：

多态的弊端：不能使用子类的特有功能（调用子类特有的方法时会报错）。

Test:面试题：

---

多态：同一个对象(事物)，在不同时刻体现出来的不同状态。

举例：

猫可以是猫的类型。猫 m = new 猫();

同时猫也是动物的一种，也可以把猫称为动物。动物 d = new 猫();

 多态的前提：

        A:要有继承关系。
        B:要有方法重写。
            其实没有也是可以的，但是如果没有这个就没有意义。
                动物 d = new 猫();
                d.show();
                动物 d = new 狗();
                d.show();
        C:要有父类引用指向子类对象。
            父 f =  new 子();

多态中的成员访问特点：

        A:成员变量
            编译(编译代码时或编辑乘.class文件时)看左边，运行（运行代码）看左边。
        B:构造方法
            创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
        C:成员方法
            编译看左边，运行看右边。
        D:静态方法
            编译看左边，运行看左边。
            (静态和类相关，算不上重写，所以，访问还是左边的)
            
        由于成员方法存在方法重写，所以它运行看右边。

class Fu {
	public int num = 100;

	public void show() {
		System.out.println("show Fu");
	}
	
	public static void function() {
		System.out.println("function Fu");
	}
}

class Zi extends Fu {
	public int num = 1000;
	public int num2 = 200;

	public void show() {
		System.out.println("show Zi");
	}
	
	public void method() {
		System.out.println("method zi");
	}
	
	public static void function() {
		System.out.println("function Zi");
	}
}

class DuoTaiDemo {
	public static void main(String[] args) {
		//要有父类引用指向子类对象。
		//父 f =  new 子();
		Fu f = new Zi();
		System.out.println(f.num);
		//找不到符号
		//System.out.println(f.num2);
		
		f.show();
		//找不到符号
		//f.method();
		f.function();
	}
}

多态的好处：

        A:提高了代码的维护性(继承保证)
        B:提高了代码的扩展性(由多态保证)

 

用工具类实现多态：

class Animal {
	public void eat(){
		System.out.println("eat");
	}
	
	public void sleep(){
		System.out.println("sleep");
	}
}

class Dog extends Animal {
	public void eat(){
		System.out.println("狗吃肉");
	}
	
	public void sleep(){
		System.out.println("狗站着睡觉");
	}
}

class Cat extends Animal {
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
	public void sleep() {
		System.out.println("猫趴着睡觉");
	}
}

class Pig extends Animal {
	public void eat() {
		System.out.println("猪吃白菜");
	}
	
	public void sleep() {
		System.out.println("猪侧着睡");
	}
}

//针对动物操作的工具类
class AnimalTool {
	private AnimalTool(){}

    /*
    public static void useCat(Cat c) {
		c.eat();
		c.sleep();
	}
    */
	public static void useAnimal(Animal a) {
		a.eat();
		a.sleep();
	}
	
}

class DuoTaiDemo2 {
	public static void main(String[] args) {
		
		Cat c = new Cat();
	    Cat c2 = new Cat();
        Cat c3 = new Cat();
		AnimalTool.useAnimal(c);
		AnimalTool.useAnimal(c2);
		AnimalTool.useAnimal(c3);

		
	}
	

}

多态的弊端：不能使用子类的特有功能（调用子类特有的方法时会报错）。

如果想使用子类的特有功能需要进行对象间的转型：

        A:创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)
        B:把父类的引用强制转换为子类的引用。(向下转型)

            对象间的转型问题：
        向上转型：
            Fu f = new Zi();
        向下转型：
            Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。

/*
	ClassCastException:类型转换异常
	一般在多态的向下转型中容易出现
*/
class Animal {
	public void eat(){}
}

class Dog extends Animal {
	public void eat() {}
	
	public void lookDoor() {
	
	}
}

class Cat extends Animal {
	public void eat() {
	
	}
	
	public void playGame() {
		
	}
}

class DuoTaiDemo5 {
	public static void main(String[] args) {
		//内存中的是狗
		Animal a = new Dog();
		Dog d = (Dog)a;
		
		//内存中是猫
		a = new Cat();
		Cat c = (Cat)a;
		
		//内存中是猫
		Dog dd = (Dog)a; //java.lang.ClassCastException: Cat cannot be cast to Dog
	}
}

Test:面试题：

/*
	看程序写结果:先判断有没有问题，如果没有，写出结果
	
	多态的成员访问特点：
		方法：编译看左边，运行看右边。
		
	继承的时候：
		子类中有和父类中一样的方法，叫重写。
		子类中没有父亲中出现过的方法，方法就被继承过来了。
*/
class A {
	public void show() {
		show2();
	}
	public void show2() {
		System.out.println("我");
	}
}
class B extends A {
	/*
	public void show() {
		show2();
	}
	*/

	public void show2() {
		System.out.println("爱");
	}
}
class C extends B {
	public void show() {
		super.show();//可以看做是B类虽然没有show()放大，但是继承了A的，show方法，因此
                      //super.show()调用的是A类中的show（）方法。A类中的show2()方法
                       //经过两次重写最终打印的是C类中的show2()方法。
	}
	public void show2() {
		System.out.println("你");
	}
}
public class DuoTaiTest4 {
	public static void main(String[] args) {
		A a = new B();
		a.show();
		
		B b = new C();
		b.show();
          //结果：爱  你
	}
}