2017年3月29号星期三空气质量：中度雾霾~重度雾霾
内容：多态，接口，多态的一道面试题
一、多态（文档讲解）
*多态：*同一个操作，由于条件的不同，产生不同的结果！*同一个引用类型，使用不同的实例而执行不同的结果！**多态的两种形式：*01.编译时的多态（方法重载）*feed(Dogdog)*feed(Catcat)*feed(Penguinpenguin)*02.运行时的多态*程序在运行期间，根据不同的参数类型，从而执行不同的对象方法！**多态存在的必要条件：*01.有继承！*02.有重写！*03.父类的引用指向了子类的对象！
*给小宠物喂食01.父类对象作为参数master.feed(dog);父类的引用指向了子类的对象！master.feed(penguin);*/
/***出售宠物*02.返回值是父类类型，可以用子类类型接收
*Petpet=newDog();*小狗是宠物--->OK!*dog=master.salePet(dog);*宠物是小狗？？？--->*dog=(Dog)master.salePet(dog);--->正确*向下转型:*把父类类型转换成其对应的子类类型！*dog=(Dog)master.salePet(dog);
二、多态（图示）
三、多态Demo
1、老师代码：
1）狗狗实体类：
packagecn.bdqn.bean;
/***狗狗的实体类*/publicclassDogextendsPet{
privateStringstrain;//品种
//无参构造方法publicDog(){}
//带参构造函数publicDog(Stringname,Stringstrain,inthealth,intlove){this.strain=strain;}
publicvoidshowInfo(){super.showInfo();//调用父类的方法System.out.println("品种是："+this.strain);}
publicStringgetStrain(){returnstrain;}
publicvoidsetStrain(Stringstrain){this.strain=strain;}
/***吃食的方法*/publicvoideat(){System.out.println("小狗狗在吃骨头");}
//出售宠物@OverridepublicDogsalePet(){System.out.println("小狗狗被卖掉了！");returnthis;}
//小狗玩耍的方法publicvoiddogPlay(){System.out.println("小狗玩耍的方法");}
}
2）企鹅实体类：
/***企鹅的实体类*/publicclassPenguinextendsPet{publicStringsex;//性别
//带参构造publicPenguin(Stringname,inthealth,intlove,Stringsex){System.out.println("Penguin的带参构造");this.sex=sex;}
/***重写父类的方法*/@OverridepublicvoidshowInfo(){super.showInfo();System.out.println("性别是："+sex);}
//无参构造publicPenguin(){}
/***吃食的方法*/publicvoideat(){System.out.println("企鹅在吃鱼");}
//出售的方法@OverridepublicPenguinsalePet(){System.out.println("企鹅被卖掉了！");returnthis;}
//企鹅玩耍的方法publicvoidpenguinPlay(){System.out.println("企鹅玩耍的方法");}
3）宠物类（父类）：
//宠物类（父类）publicabstractclassPet{//成员变量子类共有的属性privateStringname;//姓名privateinthealth;//健康值privateintlove;//亲密度
//父类的无参构造publicPet(){}
//带参构造publicPet(Stringname,inthealth,intlove){this.name=name;this.health=health;this.love=love;}
/***输出宠物的信息所有宠物共享的！*/publicvoidshowInfo(){System.out.println("姓名:"+this.name);System.out.println("健康值:"+this.health);System.out.println("亲密度:"+this.love);}
//对应的set和get方法publicStringgetName(){returnname;}
publicvoidsetName(Stringname){this.name=name;}
publicintgetHealth(){returnhealth;}
publicvoidsetHealth(inthealth){this.health=health;}
publicintgetLove(){returnlove;}
publicvoidsetLove(intlove){this.love=love;}
/***有必要写方法体吗？*因为每个宠物的吃饭方法都是不一致的！*/publicabstractvoideat();
//宠物被卖掉的方法publicabstractPetsalePet();
4）所有宠物的主人类：
/***所有宠物的主人类*/publicclassMaster{
/***主人喂养着两个宠物*01.给小狗狗喂食publicvoidfeed(Dogdog){dog.eat();}
02.给企鹅喂食publicvoidfeed(Penguinpenguin){penguin.eat();}主人可以养许多的宠物，每个宠物吃食的方法都是不一样的！那么我们就必须在这个主人类中书写N个喂食的方法！这样很麻烦！怎么解决这个问题？*/
/***多态的实现：*01.父类对象作为参数*/publicvoidfeed(Petpet){pet.eat();}
/***02.返回值是父类类型*主人不开心，卖宠物！*传过来一个宠物，之后卖掉*/publicPetsalePet(Petpet){pet.salePet();returnpet;}
/***模拟主人与宠物进行玩耍*01.先在我们的pet中创建公共的play方法*02.两个子类中去重写**如果子类中的方法名不一致了？子类中有特有的方法？*什么是特有的方法？父类中没有的！*就像根据传入实例的不同，调用不同的对象方法！*这时候我们怎么来区分是哪个宠物？*/publicvoidplay(Petpet){if(petinstanceofDog){//需要把pet向下转型为DogDogdog=(Dog)pet;dog.dogPlay();}if(petinstanceofPenguin){//需要把pet向下转型为PenguinPenguinpenguin=(Penguin)pet;penguin.penguinPlay();}}
5）测试类：
packagecn.bdqn.test;
//测试类importcn.bdqn.bean.Dog;importcn.bdqn.bean.Master;importcn.bdqn.bean.Penguin;
/****多态：*同一个操作，由于条件的不同，产生不同的结果！*同一个引用类型，使用不同的实例而执行不同的结果！**多态的两种形式：*01.编译时的多态（方法重载）*feed(Dogdog)*feed(Catcat)*feed(Penguinpenguin)*02.运行时的多态*程序在运行期间，根据不同的参数类型，从而执行不同的对象方法！**多态存在的必要条件：*01.有继承！*02.有重写！*03.父类的引用指向了子类的对象！*/publicclassPetTest{
publicstaticvoidmain(String[]args){//实现主人给两个宠物喂食Dogdog=newDog();Penguinpenguin=newPenguin();//创建主人实例Mastermaster=newMaster();/***给小宠物喂食01.父类对象作为参数master.feed(dog);父类的引用指向了子类的对象！master.feed(penguin);*/
/***出售宠物*02.返回值是父类类型，可以用子类类型接收*小狗是宠物*dog=master.salePet(dog);*宠物是小狗？？？dog=(Dog)master.salePet(dog);*向下转型*把父类类型转换成其对应的子类类型！*dog=(Dog)master.salePet(dog);*/
//玩耍的方法master.play(dog);
四、多态的一道面试题Demo（难点，梳理清楚）
老师代码：
1、类A：
packageexam;
publicclassA{
//现在这两个方法是重载publicStringshow(Dd){return"AandD";}
publicStringshow(Aa){return"AandA";}}
2、类B：
publicclassBextendsA{//继承了A
//现在这两个方法是重载publicStringshow(Bb){return"BandB";}
//重写了A的方法publicStringshow(Aa){return"BandA";}}
3、类C:
publicclassCextendsB{
4、类D:
publicclassDextendsB{
5、测试类：
publicclassTestABCD{
publicstaticvoidmain(String[]args){Aa1=newA();Aa2=newB();//父类的引用指向了子类的对象Bb=newB();Cc=newC();Dd=newD();
//AandASystem.out.println(a1.show(b));//AandASystem.out.println(a1.show(c));//AandDSystem.out.println(a1.show(d));//BandASystem.out.println(a2.show(b));子类中有对应的方法执行子类重写之后的方法//BandASystem.out.println(a2.show(c));子类中没有对应的方法执行父类的方法//AandDSystem.out.println(a2.show(d));//BandBSystem.out.println(b.show(b));//BandBSystem.out.println(b.show(c));//子类和父类都没有完全对应c的方法，先继承到父类b传参（自己理解）//AandDSystem.out.println(b.show(d));//子类中没有对应的方法，直接去父类中查询}
五、接口（文档讲解）：
*java中不支持多继承！*接口来解决这个问题！**interface:接口！本身就是一个抽象类！*接口中就是提供了某种能力，但是它不关心能力的实现！*接口的特点：*01.接口中所有的方法都是publicabstract修饰的！不允许出现方法体*02.接口的实现类必须去实现接口中所有的方法，除非实现类是抽象类或者接口！*03.接口中所有的属性都是finalstatic修饰的静态常量，必须赋予初始值！*04.接口可以实现接口，只不过实现的方式是用extends*FlyextendsFly2,Fly3=====》多实现并不是多继承！*05.接口不能实例化！也不能有构造方法！**常用的接口方式：*01.接口什么都不定义！！！*02.接口中定义了很多静态常量！*03.接口中定义了很多方法！***对象与类的关系是isa*对象与接口的关系是hasa
六、接口（图示）
七、接口Demo01（小鸟飞行）
1、Bird类继承了宠物类实现了Fly接口中的功能：
importcn.bdqn.dao.Fly;
/***Bird继承了宠物类实现了Fly接口中的功能！*/publicclassBirdextendsPetimplementsFly{
@Overridepublicvoideat(){System.out.println("小鸟在吃虫子");}
//实现了Fly接口中的功能！@Overridepublicvoidfly(){System.out.println("小鸟在飞行");}
2、宠物类（父类）：
publicabstractvoideat();
3、接口fly：
packagecn.bdqn.dao;
/****java中不支持多继承！*接口来解决这个问题！**interface:接口！本身就是一个抽象类！*接口中就是提供了某种能力，但是它不关心能力的实现！*接口的特点：*01.接口中所有的方法都是publicabstract修饰的！不允许出现方法体*02.接口的实现类必须去实现接口中所有的方法，除非实现类是抽象类或者接口！*03.接口中所有的属性都是finalstatic修饰的静态常量，必须赋予初始值！*04.接口可以实现接口，只不过实现的方式是用extends*FlyextendsFly2,Fly3=====》多实现并不是多继承！*05.接口不能实例化！也不能有构造方法！**常用的接口方式：*01.接口什么都不定义！！！*02.接口中定义了很多静态常量！*03.接口中定义了很多方法！***对象与类的关系是isa*对象与接口的关系是hasa**///publicinterfaceFlyextendsFly2,Fly3{publicinterfaceFly{/***能力*/voidfly();
4、接口fly2：
publicinterfaceFly2{
voidfly2();}
5、接口fly3：
publicinterfaceFly3{
voidfly3();}
6、测试类：
importcn.bdqn.bean.Bird;
publicclassBirdTest{
publicstaticvoidmain(String[]args){Birdbird=newBird();bird.eat();bird.fly();//功能
八、接口Demo02（防盗门）
1、门的抽象类（开门，关门两个方法）：
/***门*不同的门开门关门的方式不同*我们不能把功能写死**门是抽象类*卷帘门*木门*铁门*玻璃门*/publicabstractclassDoor{//开门publicabstractvoidopen();
//关门publicabstractvoidclose();
2、防盗的接口（上锁，开锁两个方法）：
/***接口只是提供了某些功能**防盗门具有防盗的功能*防盗窗具有防盗的功能**上锁和开锁*/
publicinterfaceLockInterface{
//上锁voidlockUp();
//开锁voidlockDown();}
3、防盗门类（继承门，实现防盗接口）：
importcn.bdqn.dao.LockInterface;
/****防盗门首先是一个门然后具有防盗的功能*/publicclassPanDoorextendsDoorimplementsLockInterface{
@OverridepublicvoidlockUp(){System.out.println("门被锁上了");}
@OverridepublicvoidlockDown(){System.out.println("锁被打开了");}
@Overridepublicvoidopen(){System.out.println("门被打开了");}
@Overridepublicvoidclose(){System.out.println("门被关上了");}
4、测试类：
importcn.bdqn.bean.PanDoor;
publicclassTestDoor{publicstaticvoidmain(String[]args){
PanDoordoor=newPanDoor();door.lockDown();door.open();door.close();door.lockUp();}