JAVA中的多态

/*
 * 多态：可以理解为事物存在的多种体现形态
 * 
 * 人：男人，女人
 * 动物：猫，狗
 * 猫 x = new 猫（）；
 * 动物 x = new 猫（）；   这个就是多态
 * 
 * 1、多态的基本体现
 * 		父类的引用指向了自己的子类对象
 * 		父类的引用也可以接收自己的子类对象
 * 
 * 2、多态的前提
 * 		必须是类与类之间有关系（继承||实现）
 * 		通常还有一个前提：存在覆盖
 * 
 * 3、多态的好处
 * 		多态的出现大大提高了程序的扩展性
 * 
 * 4、多态的弊端
 * 		提高了扩展性，但是只能使用父类的引用访问父类的成员
 * 
 * */

//动物类，动物都需要吃东西，抽取出eat（）方法，但是每个动物吃的东西不同，所以抽象

abstract class Animal {
	abstract void eat();
}

//猫类，继承动物类，复写父类中的eat（）方法，还有自己的特有方法抓老鼠

class Cat extends Animal {
	void eat() {
		System.out.println("吃鱼");
	}

	public void CatchMouse() {
		System.out.println("抓老鼠");
	}
}

//狗类，继承动物类，复写父类中的eat（）方法，还有自己的特有方法看家

class Dog extends Animal {
	void eat() {
		System.out.println("吃骨头");
	}

	void WatchHome() {
		System.out.println("看家");
	}
}

public class DuoTaiDemo {
	public static void main(String args[]) {
		/*
		 * Cat c=new Cat(); c.eat(); Dog d=new Dog(); d.eat();
		 */
		Animal c = new Cat();
		function(c);
		// 如果要调用猫的特有方法，如何操作
		// 强制将父类引用转为子类类型
		// Cat a = (Cat) c;
		// a.CatchMouse();
		Animal d = new Dog();
		function(d);

	}

	public static void function(Animal c) {
		c.eat();
		/*if (c instanceof Cat) {
			Cat a = (Cat) c;
			a.CatchMouse();
		}
		if (c instanceof Dog) {
			Dog a = (Dog) c;
			a.WatchHome();
		}*/
		
	}
}

提高扩展性在于：比如上面的代码是半年前的，我现在多了一个猪类，要加进去，那么我只要加猪类继承动物类就可以了，不需要去改动源码。如果不用多态的话，我还要去main（）函数中添加猪类的使用过程，这个例子中看上去还可以接受，但到实际开发中，这是极其耗时的。所以，利用多态，我们提高了程序的扩展性，降低了耦合。

举例子：

/*
 * 基础学生：
 * 		学习，睡觉。
 * 高级学生：
 * 		学习，睡觉。
 * 可以将这两类事物进行抽取
 * 
 * */

abstract class Student3 {
	public abstract void study();

	public void sleep() {
		System.out.println("躺着睡");
	}
}

class BaseStudent2 extends Student3 {
	public void study() {
		System.out.println("base study");
	}

	public void sleep() {
		System.out.println("坐着睡");
	}
}

class AdvStudent2 extends Student3 {
	public void study() {
		System.out.println("adv student");
	}
}

class DoStudent{
	public void doSome(Student3 a) {
		a.study();
		a.sleep();
	}
}

public class DuoTaiDemo2 {
	public static void main(String args[]) {
		
		DoStudent ds =new DoStudent();
		
		BaseStudent2 bs = new BaseStudent2();
		ds.doSome(bs);
		AdvStudent2 as = new AdvStudent2();
		ds.doSome(as);

	}
//	public static void doSome(Student a) {
//		a.study();
//		a.sleep();
//	}
}

上面的例子中因为都在调用学生（基础学生，高级学生）的学习和睡觉方法，我们也可以把这个调用封装起来变成一个函数，或者封装成一个类，这样耦合度进一步降低。暴露出的程序越少。

----------------------By 仔鸡

猜你喜欢