java三大特性之多态的认识，以及多态的实际应用（二）

多态的实际作用：将不同子类对象统一当作父类对象，屏蔽了不同子类之间的差异。

使用多态的好处：

1. 应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承
2. 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。 //多态的真正作用，

多态的两种常见用法：

• 1， 多态用在方法参数上， 形参可以是父类引用，实参可以传子类对象； M(A a) : 可以用A的任何子类对象作为参数
  下面程序解释了将多态定义在方法参数上，

	    package test;
	    /**
	     * 3、定义一个动物类(Animal)，里面有一个吃方法。该类有两个子	类Dog和Cat，
	     * 覆盖父类中的吃方法，Dog类为打印狗 喜欢	吃骨头，Cat类为猫喜欢吃鱼。
	     * 定一个饲养员类，该类中有一	个给动物喂食的方法，形参定义为Animal类型的引用。
	     * 定义	Test类，创建饲养员,调用喂食方法，
	     * 传入Dog对象打	印狗喜欢吃骨头，传入Cat对象打印猫喜欢吃鱼。
	     */
	    public class lt3{
	    	public static void main(String[] args) {
	    		//定义	Test类，创建饲养员,调用喂食方法，
	    		Feeder f = new Feeder();
	    		
	    		//创建dog对象
	    		Dog d = new Dog();
	    		//创建cat对象
	    		Cat c = new Cat();
	    		// 传入Dog对象打	印狗喜欢吃骨头，传入Cat对象打印猫喜欢吃鱼。
	    		f.feed(d);// 传入Dog对象打	印狗喜欢吃骨头
	    		f.feed(c);//传入Cat对象打印猫喜欢吃鱼。
	    	}
	    }
	    
	    //定一个饲养员类，该类中有一个给动物喂食的方法，形参定义为Animal类型的引用。
	    class Feeder{
	    	public void feed(Animal animal){
	    		animal.eat();
	    	}
	    }
	    
	    //定义一个动物类(Animal)，里面有一个吃方法。该类有两个子	类Dog和Cat，
	    class Animal{
	    	public void eat(){
	    		System.out.println("Animal eat ");
	    	}
	    }
	    //覆盖父类中的吃方法，Dog类为打印狗 喜欢	吃骨头，Cat类为猫喜欢吃鱼。
	    class Dog extends Animal{
	    	public void eat(){
	    		System.out.println("狗 喜欢	吃骨头");
	    	}
	    }
	    class Cat extends Animal{
	    	public void eat(){
	    		System.out.println("Cat类为猫喜欢吃鱼。");
	    	}
	    } 

• 2， 多态用在方法的返回值上， A m() : m方法完全可以返回A的某个子类对象

为便于理解代码已加详细注释说明：

	    package testUse;
	    	public class useDuoT2{
	    		public static void main(String[] args) {
	    	
    			Dog d = new Dog();
    			//d作实参，调用m1；
    			m1(d);
    	
    				//实参传子类对象
    				m2(d);
    	
    			//再创建一个cat，用猫做对象，猫也想调用这个m1.
    			Cat c = new Cat();
    			//这句话就不对了，因为函数类型是Dog，这里传一个cat类型进去肯定不对了
    			//想用这个可以再重载一个函数；
    			m1(c);
    				
    	
    				Animal a = m33();
    				Animal a1 = m33(5);//返回Cat
    				Animal a2 = m33(6);//返回Dog
    		
    	
    		}
    		//函数，dog类型
    		static void m1(Dog d){
    			d.sleep();
    		}
    	
    		static void m1(Cat c){
    			c.sleep();
    		}
    	
    		//如果动物类里面有一万个子类，这种方法就不行了，难道去重载一万次？
    		//不用重载，把函数参数类型改为Animal
    		//然后传的时候，就可以传任何一种动物了
    		//这就是多态的第一种用法：
    		//1，多态用在方法参数上，  形参可以是父类引用，实参可以传子类对象；
    		//M(A a) :   可以用A的任何子类对象作为参数
    		static void m2(Animal a){//Animal a,形参，传父类引用，
    			//如果传入的是dog类型，就输出Dog  sleep，子类会重写父类方法
    			//如果传入的是cat类型，就输出Cat  sleep，
    			a.sleep();
    		}
    	
    		//以一个dog对象作为返回值，返回类型可以写Dog，static Dog m3(){}
    		//但是实现可能会修改,如果返回值是Cat，那么返回值类型也得跟着改，
    		//类型一改所有调用这个方法的代码都得跟着修改
    		static Dog m3(){
    			return new Dog();
    		}
    			//所以这个返回值类型可以写成Animal，所以只要是动物就都可以返回
    			//所以调用的时候就需要一个Animal类型的引用去接这个返回值；Animal a = m33();
    			//
    			static Animal m33(){
    				return new Dog();
    			}
    	
    			//这个代码还可以再改一下；
    			//这个代码可以返回dog也可以返回猫。所以只能用多态。
    			//多态的第2中用法：
    			//这是把多态用在方法的返回值上，
    			//A   m() :  m方法完全可以返回A的某个子类对象
    			static Animal m33(int n){
    				if (n % 2 == 0) {
    					System.out.println("return new Dog()");
    					return new Dog();
    				}else
    					System.out.println("return new Cat()");
    					return new Cat();
    			}
    	
    	}
    	class Animal{
    		public void sleep(){
    			System.out.println("Animal  sleep");
    		}
    	
    	}
    	class Dog extends Animal{
    		public void sleep(){
    			System.out.println("Dog  sleep");
    		}
    	
    	}
    	class Cat extends Animal{
    		public void sleep(){
    			System.out.println("Cat  sleep");
    		}
    	
    	}

这样就实现了多态的作用：将不同子类对象统一当作父类对象，屏蔽了不同子类之间的差异。