Java基础之多态，接口，抽象方法

1.多态：对象在不同时刻表现出来的不同状态

1.1条件
               要有继承关系或者实现关系
               要有函数重写
               父类类型指向子类对象

1.2多态之间成员特点
     函数：编译看左面，运行看右面
     变量：编译看左面，运行看左面（函数有重写。而变量没有）

1.3多态的弊端和解决方案
     多态不可以让父类访问子类的特有功能(Animal类具备Cat类的抓老鼠功能吗？)
     解决方法
          向上转型Animal a = new Cat();     猫是动物
          向下转型Cat c = (Animal)a;           动物是猫
          ClassCastException异常                Dog d = (Dog)(a); 动物已经是猫了，猫转换成狗？扯蛋
          Dog d = (Dog)(c);                         编译就会出现错误，不可转换类型

1.4多态的好处和用法
     为了提供代码的扩展性和可维护性
     class Animal
     {
          public void show(){}

     }

     class Cat extends Animal{}
     class Dog extends Animal{}
     class Pig extends Animal{}

     //父类类型不断指向子类对象
     class AnimalTool(Animal a)
     {
          a.show();
     }

---

2.抽象类的特点

方法只有声明，没有实现时，该方法就是抽象方法。需要被abstract修饰。抽象方法必须定义在抽象类中，该类也被abstract修饰
          抽象方法和抽象类 用abstract修饰
          有 抽象方法的类一定是抽象类 （ 或接口 ），但 抽象类里面不一定全都是抽象方法
          抽象类不能被实例化，但是有构造函数，但可以通过子类完成实例化
          一个类继承了抽象类

               |--子类必须要重写父类全部的抽象方法

               |--不重写方法就得这个子类也是抽象的

2.1抽象类的成员特点
     成员变量：可以有常量，还可以有变量
     构造函数：构造函数可以让子类进行构造调用父类构造进行初始化
     成员函数：可以有抽象方法，也可以有非抽象方法。抽象方法为了强制重写，非抽象为子类继承

2.2abstract和什么关键字不能并存？
     final（不能被继承和重写）不可以和abstract共存
     private也不行，子类继承之后不可以重写成员函数
     static也不行，用类名调用抽象方法，你调用完有啥用啊？一个抽象的函数，没有任何意义啊

---

3.接口

    3.1 如果一个抽象类中的方法都是抽象的，这个时候，java就提供了一种更抽象的表示形式：接口。
        格式：
        interface 接口名{}
        class 类名 implements 接口名 {}

     3.2接口的特点
          接口不能被实例化
          一个类如果实现了接口
               |--要么是抽象类
               |--要么实现接口中的所有方法

      3.3接口的成员特点
          成员变量     只能是常量，默认修饰符 public static final
          成员方法     只能是抽象方法，默认修饰符 public abstract
          推荐：永远手动给出修饰符，阅读性强

      3.4接口的思想特点
          |--对外暴露的规则
          |--是功能的扩展
          |--降低耦合度
               耦合：类与类的关系
               内聚：类自己完成某件事情的能力
               高内聚，低耦合
          |--接口可以多实现

     3.5类，接口的关系
          类与类
               继承关系,只能单继承，可以多层继承
          类与接口
               实现关系，可以单实现，也可以多实现
               还可以在继承一个类的同时实现多个接口
          接口与接口
               继承关系，可以单继承，也可以多继承

小练习

//Person类

abstract class Person

{

       public Person(){}

       public Person(String name, int age)

      {

             this . name = name;

             this . age = age;

      }

       //成员变量

       private String name ;

       private int age ;

       public String getName()

      {

             return this . name ;

      }

       public void setName(String name)

      {

             this . name = name;

      }

       public int getAge()

      {

             return this . age ;

      }

       public void setAge( int age)

      {

             this . age = age;

      }

       //成员函数

       abstract public void eat(); 

}

//教练父类

abstract class Coach extends Person

{

       public Coach(String name, int age)

      {

             super (name,age);

      }

       //特有方法：教

       abstract public void teach();

}

//运动员父类

abstract class Athlete extends Person

{

       public Athlete(String name, int age)

      {

             super (name,age);  

      }

       //特有方法：学

       abstract public void study();

}

/*===============================================================================*/

//乒乓球教练子类

class PingPangCoachImpl extends Coach implements StudyEnglish

{

       public PingPangCoachImpl(String name, int age)

      {

             super (name,age);  

      }

       public void teach()

      {

            System. out .print( "我是乒乓球教练,正在教乒乓球..." );

      }

       public void eat()

      {

            System. out .print( "我是乒乓球教练,我吃大鸡蛋..." );

      }

       public void studyEnglish()

      {

            System. out .print( "我学会了English" );

      }

}

//乒乓球运动员子类

class PingPangAthleteImpl extends Athlete implements StudyEnglish

{

       public PingPangAthleteImpl(String name, int age)

      {

             super (name,age);  

      }

       public void study()

      {

            System. out .println( super .getName() + "是乒乓球运动员,累的跟狗一样..." );

      }

       public void eat()

      {

            System. out .println( "我是乒乓球运动员,我吃小鸡蛋...,今年" + super .getAge() + "岁了!" );

      }

       public void studyEnglish()

      {

            System. out .println( "我学会了English" );

      }

}

//篮球教练子类

class BasketBallCoach extends Coach

{

       public BasketBallCoach(String name, int age)

      {

             super (name,age);  

      }

       public void teach()

      {

            System. out .print( "我是篮球教练,我两米九..." );

      }

       public void eat()

      {

            System. out .print( "我是篮球教练,我吃牛肉..." );

      }

}

//篮球运动员子类

class BasketBallAthlete extends Athlete

{

       public BasketBallAthlete(String name, int age)

      {

             super (name,age);  

      }

       public void study()

      {

            System. out .print( "我是篮球运动员,我一米五..." );

      }

       public void eat()

      {

            System. out .print( "我是篮球运动员,我吃猪肉..." );

      }

}

/*===============================================================*/

interface StudyEnglish

{

       public abstract void studyEnglish();

}

class Demo

{

       public static void main(String[] args)

      {

            PingPangAthleteImpl PPAI = new PingPangAthleteImpl( "旺财" ,12);

            PPAI.study();

            PPAI.eat();

            PPAI.studyEnglish();

      }

}