接口的多态编程,应具备下列哪些要素?最合适的一项是（day11_多态&抽象类&接口）

1    
    
  、多态

1.1 多态的概述（记忆）

什么是多态

    同一对象 
    
    
，在不同时刻表现出来的不同形态    
    
  。

多态的前提 有继承/实现关系 有方法重写 有父类对象的引用执行子类对象

1.2 多态中的成员访问特点（记忆）

成员访问特点 成员变量：编程看父类
     


     


  ，运行看父类 成员方法：编译看父类 




 




 
，运行看子类 代码演示 public class Animal { public int age = 40; public void eat(){ System.out.println("动物吃东西"); } } public class Animal { public int age = 40; public void eat(){ System.out.println("动物吃东西"); } } public class AnimalDemo { public static void main(String[] args) { //父类对象引用指向子类 Animal a = new Cat(); //调用成员变量：编译看父类 

   

   

，运行看父类 System.out.println(a.age); //调用成员方法：编译看父类
     

     

 ，运行看子类 a.eat(); } }

1.3 多态的好处和弊端（记忆）

好处

    提高程序的扩展性  


     


     
。定义方法时候  




  




  ，使用父类型作为参数 


  


  


，在使用的时候
     
     
，使用具体的子类型参与操作


 




 




。

弊端

    不能使用子类特有的成员

1.4 多态中的转型（应用）

向上转型

    父类对象的引用指向子类对象就是向上转型   

   

 。

向下转型

    格式：子类型 对象名 = （子类型）父类引用;

代码演示 public class Animal { public void eat(){ System.out.println("动物吃东西"); } } public class Cat extends Animal{ @Override public void eat() { System.out.println("猫吃鱼"); } public void playGame(){ System.out.println("猫捉秘藏"); } } public class AnimalDemo { public static void main(String[] args) { //多态 //1.向上转型 Animal a = new Cat(); a.eat(); //不能访问子类对象特有的方法 //a.playGame(); //向下转型 Cat c = (Cat) a; c.eat(); c.playGame(); } }

1.5 多态的案例（应用）

案例需求

     请采用多态的思想实现猫和狗的案例   




   




   ，并在测试类中进行测试

代码实现 public class Animal { private String name; private int age; public Animal() { } public Animal(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public void eat(){ System.out.println("动物吃东西"); } } public class Dog extends Animal{ public Dog() { } public Dog(String name, int age) { super(name, age); } public void eat(){ System.out.println("狗吃骨头"); } } public class Cat extends Animal { public Cat() { } public Cat(String name, int age) { super(name, age); } @Override public void eat() { System.out.println("猫吃老鼠"); } } public class AnimalDemo { public static void main(String[] args) { //使用无参构造方法 Animal a1 = new Cat(); a1.setAge(5); a1.setName("加菲"); System.out.println(a1.getName()+","+ a1.getAge()); a1.eat(); //使用带参的构造方法 a1 = new Cat("波斯",6); System.out.println(a1.getName()+","+ a1.getAge()); a1.eat(); } }

2  


     


     
、抽象类

2.1 抽象类的概述（理解）

  当我们在做子类共性抽取时 



 



 


，有些方法在父类中并没有具体的体现          ，这个时候就需要抽象类了！

  抽象方法：没有方法体的方法应该定义为抽象方法

  抽象类：由抽象方法的类必须定义为抽象类

2.2 抽象类的特点（记忆）

抽象类和抽象方法必须使用abstract关键字修饰 //抽象类的定义 public abstract class 类名 {} //抽象方法的定义 public abstract void eat(); 抽象类中不一定有抽象方法
    




    




   ，有抽象方法的类一定是抽象类 抽象类不能实例化

    抽象类不能实例化












，但可通过子类对象实例化           ，编写方式参照多态
     



     



   ，这叫抽象类多态   

     

     。

抽象类的子类

    要么重写抽象类中的所有抽象方法

    要么还是抽象类

2.3 抽象类的成员特点（记忆）

成员的特点 成员变量 既可以时变量 也可以是常量 成员方法 即可以是抽象方法 可以是普通方法 构造方法 即可以有空参构造 也可以有有参构造 代码演示 public abstract class Animal { private int age =20; private final String city = "北京"; public Animal() { } public Animal(int age) { this.age = age; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getCity() { return city; } public void show(){ age = 40; System.out.println(age); //city = "上海";//不能给最终变量city赋值 System.out.println(city); } public abstract void eat(); } public class Cat extends Animal{ @Override public void eat() { System.out.println("猫吃鱼"); } } public class AnimalDemo { public static void main(String[] args) { Animal a = new Cat(); a.eat(); a.show(); } }

2.4 抽象类的案例（应用）

案例需求

    请采用抽象类的思想实现猫和狗的案例











，并在测试类中进行测试

代码实现 public abstract class Animal { private String name; private int age; public Animal() { } public Animal(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public abstract void eat(); } public class Cat extends Animal { public Cat() { } public Cat(String name,int age){ super(name,age); } @Override public void eat() { System.out.println("猫吃鱼"); } } public class Dog extends Animal { @Override public void eat() { System.out.println("够吃骨头"); } } public class AnimalDemo { public static void main(String[] args) { Animal a = new Cat(); a.setAge(5); a.setName("加菲"); System.out.println(a.getName()+","+a.getAge()); a.eat(); a = new Cat("波斯",6); System.out.println(a.getName()+","+a.getAge()); a.eat(); } }

3


 




 




、接口

3.1 接口的概述（理解）

  接口就是一种公共的规范标准 
    
    
，只要符合规范标准
     


     


  ，大家都可以通用



  




  




。

  Java中的接口更多的体现在对行为的抽象！

3.2 接口的特点（记忆）

接口用关键字interface修饰

    public interface 接口名 { }

类实现接口用implements表示

    public clas 类名 implements 接口名 { }

接口不能实例化

    参照多态的方式 




 




 
，通过实现类对象实例化 

   

   

，这叫接口多态  


  


。

    多态的形式：具体类多态   

   

 、抽象类多态   

     

     、接口多态

接口的子类

    要么重写接口中所有方法

    要么子类也是抽象类

3.3 接口的成员特点（记忆）

成员特点 成员特点

        只能是常量
     

     

 ，默认修饰符：public static final

构造方法

        没有  




  




  ，应为接口不能被实例化 


  


  


，所以没有具体存在

成员方法

        只能是抽象方法
     
     
，默认修饰符：public abstract

代码演示 public interface Inter { int num = 10;//public static final int num = 10; void method();//public abstract void method(); void show();//public abstract void show(); } public class InterImpl implements Inter{ public InterImpl() { } @Override public void method() { System.out.println("method"); } @Override public void show() { System.out.println("show"); } } public static void main(String[] args) { Inter i = new InterImpl(); System.out.println(Inter.num);//10 } }

3.4 接口的案例（应用）

案例需求

对猫和狗进行训练   




   




   ，他们就可以跳高了 



 



 


，这里加入跳高功能    
     
     。

    请采用抽象类和接口来实现猫狗案例          ，并在测试类中进行测试




   




   



。 代码实现 public abstract class Animal { private String name; private int age; public Animal() { } public Animal(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public abstract void eat(); } public interface Jumpping { void jump(); } public class Cat extends Animal implements Jumpping{ public Cat() { } public Cat(String name, int age) { super(name, age); } @Override public void eat() { System.out.println("猫吃鱼"); } @Override public void jump() { System.out.println("猫可以调高"); } } public class AnimalDemo { public static void main(String[] args) { Jumpping j = new Cat(); j.jump(); Animal a = new Cat(); a.setAge(5); a.setName("加菲"); System.out.println(a.getName()+","+a.getAge()); a.eat(); a = new Cat("波斯",6); System.out.println(a.getName()+","+a.getAge()); a.eat(); } }

3.5 类和接口的关系（记忆）

类与类的关系

    继承关系
    




    




   ，只能单继承












，但是可以多层继承

类与接口的关系

    实现关系           ，可以单实现
     



     



   ，也可以多实现











，还可以在继承一个类的同时实现多个接口 



 



。

3.6 抽象类与接口的区别（记忆）

成员区别 抽象类

        变量



  




  




、常量；有构造方法；也有非抽象方法

接口

        常量 
    
    
，抽象方法

关系区别 类与类：继承  


  


、单继承 类与接口：实现
     


     


  ，可以单实现 




 




 
，也可以多实现 接口与接口：继承 

   

   

，单继承
     

     

 ，多继承 设计理念区别 抽象类

        对类的抽象  




  




  ，包括属性    
     
     、行为

接口

        对行为的抽象

4




   




   



、综合案例

4.1 案例需求（理解）

我们现在有乒乓球运动员和篮球运动员 


  


  


，乒乓球教练和篮球教练              。

  为了出国交流
     
     
，跟乒乓球相关的人员都需要学习英语




    




    


。

  请用所学知识分析   




   




   ，这个案例中有哪些具体类 



 



 


，哪些抽象类          ，哪些接口
    




    




   ，并用代码实现










。

4.2 代码实现（应用）

//抽象人类 public abstract class Person { private String name; private int age; public Person() { } public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public abstract void eat(); } //抽象教练 public abstract class Coach extends Person{ public Coach() { } public Coach(String name, int age) { super(name, age); } public abstract void teach(); } //抽象运动员 public abstract class Player extends Person { public Player() { } public Player(String name, int age) { super(name, age); } public abstract void study(); } //学英语接口 public interface SpeakEnglish { public abstract void speak(); } //篮球教练 public class BasketballCoach extends Coach{ public BasketballCoach() { } public BasketballCoach(String name, int age) { super(name, age); } @Override public void teach() { System.out.println("篮球教练教如何运球和投篮"); } @Override public void eat() { System.out.println("篮球教练吃羊奶












，喝羊奶"); } } //篮球运动员 public class BasketballPlayer extends Player{ @Override public void eat() { System.out.println("篮球运动员学习如何运球和投球"); } @Override public void study() { System.out.println("篮球运动员学习如何运球和投蓝"); } } //兵乓球教练 public class PingBangCoach extends Coach implements SpeakEnglish{ @Override public void teach() { System.out.println("兵乓求教练教如何发球和接球"); } @Override public void eat() { System.out.println("兵乓球教练吃小白菜           ，和大米粥"); } @Override public void speak() { System.out.println("兵乓球教练说英语"); } } //兵乓球运动员 public class PingBangPlayer extends Player implements SpeakEnglish{ public PingBangPlayer() { } public PingBangPlayer(String name, int age) { super(name, age); } @Override public void eat() { System.out.println("兵乓球运动员学习如何发球和接球"); } @Override public void study() { System.out.println("兵乓球运动员吃大白菜
     



     



   ，喝小米粥"); } @Override public void speak() { System.out.println("兵乓球运动员说英语"); } }