【JAVA学习笔记】14 多态

2018.4.2

多态

我有一个动物园：
 Animal类
 	Monkey
 	Tiger
 	Snake

 	限制需要对所有的动物进行喂食。
 	
 	发现，每一个东西都有一个喂食的方式，而且喂食的方式其实都一样
 	归纳总结的方法：能不能把这些东西放到一起。
 	
 	思考：
 		能不嫩实现喂食动物的方法
 		
 		喂食动物，要确定操作的哪一个类。
 		
 		发现这里要求传入对象是Animal类对象的方法，传入Animal的子类对象也可以，
 		没有任何的报错和提示，直接可以运行。
 		
 		从生活角度分析，猴子，老虎，蛇都是动物，那么喂食动物的方法，他们也适用。
 	发现：
 		在方法中如果需要的参数是一个类对象，那么在这个参数中传入该类的子类对象也可以。
 		例如：
 		eat（Animal a）
 		传入Monkey m方法正常运行。
	

    class Animal {
    	int age;
    	
    	public Animal() {}
    	
    	public Animal(int age) {
    		this.age = age;
    	}
    	public void eat(Animal a) {
    		System.out.println(a.getClass()+"在吃东西");
    	}
    	public Animal tellMeWhoAreYou(Animal a){
    		System.out.println(a.getClass());
    		return a;                                                                              
        	}
        }


    class Monkey extends Animal {
    	public void eat(Monkey m) {
    		
    	}
    }
    class Tiger extends Animal {
    	public void eat(Tiger t) {
    		
    	}
    }
    class Snake extends Animal {
    	public void eat(Snake s) {
    		
    }
    }
    public class Demo1 {
    	public static void main(String[] args) {
    			Monkey monkey = new Monkey();
    		
    			Tiger tiger = new Tiger();
    			
    			Snake snake = new Snake();
    			
    			Animal animal = new Animal();
    			
    			animal.eat(monkey);
    			animal.eat(tiger);
    			Animal  lu = animal.tellMeWhoAreYou(monkey);
    			Monkey ma = (Monkey)animal.tellMeWhoAreYou(monkey);//monkey强转
    }
    }
    
结果：
    class lianxi.Monkey在吃东西
    class lianxi.Tiger在吃东西
    class lianxi.Monkey
    class lianxi.Monkey

多态实例

规定一个usb接口，在usb接口中要求所有的usb设备要完成connect()

        interface Usb {	
        	public void connect() ;
        }
        //U盘[遵从]了usb接口，实现了connect方法。
        class Upan implements Usb{
        
        	@Override
        	public void connect() {
        	System.out.println("U盘连接电脑，传输数据");
        		
        	}
        }
        //键盘【遵从】了Usb接口，实现了connect方法。
        class Keyboard implements Usb {
        
        	@Override
        	public void connect() {
        	 System.out.println("推荐filco键盘，有且是茶轴");
        		
        	}	
        }
        
        class Computer {
        	//电脑上留有一个usb接口，但是是什么设备来使用，usb来确定，更谁要连接来确定，但是连接的设备
        	//必须【遵从】usb接口
        	public void usbConnect(Usb usb) {
        		usb.connect();//用的是和父类同名的成员方法，调用的是子类的方法。
        	}
        }
        
        public class demo2 {
        public static void main(String[] args) {
        	Computer MBP = new Computer();
        	//传入的是一个【遵从】usb接口的U盘匿名对象
        	MBP.usbConnect(new Upan());
        	//传入的是一个【遵从】usb接口的键盘匿名对象。
        	MBP.usbConnect(new Keyboard());
        	
        	 定义的形式参数是一个接口，但是传入的是【遵从】接口的类对象 
        	 
        	 
        }
        }   
        
结果：
        U盘连接电脑，传输数据
        推荐filco键盘，有且是茶轴

总结多态概念

从前两个代码中可以总结这两句话（多态的核心。）
 	1.在一个方法中 需要的参数是一个类对象，但是传入的参数是该类的子类对象也是可以的
 	2.在一个方法中， 定义的参数格式是一个接口，传入的参数是【遵从】该接口的对象。
 	
 【总结多态概念】（多态是拿来用的不需要多加解释。）【重写的目的：满足子类的需求。】
 	父类的引用指向子类的对象，或者接口的引用指向【遵从】接口的类对象。

多态的适应注意事项：[背下来](指向子类的对象Father f = new Son("lu"))

1.多态情况下，父类的引用调用父类和子类同名的普通成员方法，那么调用的是方法。 
 2.多态情况下，父类的引用调用父类和子类同名的普通成员变量，那么调用的是父类的成员变量。
 3.多态情况下，父类的引用调用父类和子类同名的【静态】成员方法，那么调用的是父类的【静态】成员方法。
  4.多态情况下，父类的引用不能调用子类特有的成员变量。

        class Father {
        		String name;//父类中的成员变量
        		int weight = 90;//和子类同名的成员变量
        		public Father() {}
        	
        		public Father(String name) {
        			this.name = name;
        		}
        		
        		public void game() {
        			System.out.println("曼彻斯特");
        		}
        		
        		public static void work() {
        			System.out.println("工程师");
        		}
        }
        
        class Son extends Father {
        	int age = 16;//子类中的成员变量
        	int weight = 74;//和父类的同名的成员变量。
        	
        	public Son() {}
        	
        	public Son(String name) {
        		super(name);
        	}
        	
        	@Override
        	public void game() {
        		System.out.println("巴萨罗那");
        	}
        	
        	public static void work() {
        		System.out.println("程序员");
        	}
        	
        }
        public class Demo3 {
        	public static void main(String[] args) {
        /*		Son s = new Son("lu");
        		s.game();
        		s.work();
        		
        		Father f = new Father("lu1");
        		f.game();
        		f.work();
        	*/
        		//父类引用指向子类的对象【多态】
        		Father ftos = new Son("lu2");
        		
        		ftos.game();//子类对象的方法
        			
        		System.out.println(ftos.weight);//父类对象的方法
        		
        		ftos.work();//父类的静态成员方法
        		
        	//system.out.println(ftos.age); 报错 多态情况下，父类的引用不能调用子类特有的成员变量。
        		
        	}
        }
结果：
    巴萨罗那
    90
    工程师