Java-多态，抽象类和接口

这个是今天博客所要更新的主要内容

多态的概述

• 多态概述：
  某一个事物，在不同时刻表现出来的不同状态。
• 举例：
  Cat c=new Cat();
  Animal a=new Cat();
  猫可以是猫的类型。猫 m = new 猫();
  同时猫也是动物的一种，也可以把猫称为动物。动物 d = new 猫();
• 多态前提：
  1:要有继承关系。
  2:要有方法重写。 其实没有也是可以的，但是如果没有这个就没有意义。
  3:要有父类引用指向子类对象。
  父 f = new 子();

多态中成员访问特点

• 成员变量：
  编译看左边，运行看左边。（即访问父类成员变量）
• 构造方法：
  创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
• 成员方法：
  编译看左边，运行看右边。（即访问子类重写过的方法，若没重写方法，则访问父类的方法）
• 静态方法：
  编译看左边，运行看左边（静态方法不能被重写，所以直接访问父类的静态方法）

多态的好处和弊端

• 多态的好处：
  1:提高了代码的维护性(继承保证)
  2:提高了代码的扩展性(由多态保证)
• 多态的弊端：
  不能访问子类特有的方法

多态中的向上转型和向下转型

• 向上转型：
  用父类接受子类对象（父类 名字=new 子类();）
  其实向上转型也就是多态的形式
• 向下转型：
  用子类接受父类对象（子类 名字=（子类）父类对象的名字;）

多态的内存图

多态案例（孔子装爹）

• 故事简介：
  听说孔子爹JavaSE讲的很好，张三慕名前来，把孔子爹请到家里去给他讲课去了 ，那么这个时候，李四也来到孔子家里，请孔子爹讲Java 孔子一看学员来了，孔子爹又不在家，孔子又不想失去这个学员，孔子经过乔装打扮，装成他爹的样子，给李四讲课，他只会将论语，讲完之后，把李四打发走了，孔子想玩游戏了，卸下这套装扮，去开心的玩游戏去了

  public class MyTest {
   public static void main(String[] args) {
    KongDie kd = new KongZi(); 
    System.out.println(kd.age);
    kd.teache();
    KongZi k = (KongZi) kd; //向下转型
    System.out.println(k.age);
    k.playGame(); //调用自己特有的方法
   }
  }
  class KongDie {
   int age = 60;
   public void teache() {
    System.out.println("讲授JavaSE");
   }
  }
  class KongZi extends KongDie {
   int age = 30;
   public void teache() {
    System.out.println("讲授论语");
   }
   public void playGame() {
    System.out.println("玩纪念碑谷游戏");
   }
  }
  

以上代码体现故事

抽象类的概述及其特点

• 概述：
  用abstract修饰的类为抽象类
• 抽象类特点：
  1:抽象类和抽象方法必须用abstract关键字修饰
  抽象类格式: abstract class 类名 {}
  抽象方法格式: public abstract void eat();
  2:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
  3:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
  用于子类访问父类数据时的初始化
  4:抽象类不能直接实例化那么，抽象类如何实例化呢?
  按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
  5:抽象类的子类
  要么是抽象类
  要么重写抽象类中的所有抽象方法

抽象类的成员特点

• 抽象类的成员特点：
  1:成员变量：既可以是变量，也可以是常量。
  2:构造方法：有。
  用于子类访问父类数据的初始化。
  3:成员方法：既可以是抽象的，也可以是非抽象的。
• 抽象类的成员方法特性：
  1:抽象方法 强制要求子类做的事情。
  2:非抽象方法 子类继承的事情，提高代码复用性。

抽象类演示猫狗案例

import java.net.SocketTimeoutException;
public class MyTest {
  public static void main(String[] args) {   
    Aniaml an = new Cat();
    an.name="汤姆";
    an.age=2;
    System.out.println(an.name+"==="+an.age);
    an.eat();
    ((Cat) an).catchMouse();  
    an=new Dog();
    an.name="旺财";
    an.age=9;
    System.out.println(an.name+"=="+an.age);
    an.eat();
    ((Dog) an).lookDoor();
  }
}
abstract class Aniaml {
  public String name;
  public int age;
  public abstract void eat();
}
class Cat extends Aniaml {
@Override
  public void eat() {
    System.out.println("猫吃鱼");
  }
  public void catchMouse(){
    System.out.println("猫抓老鼠");
  }
}
class Dog extends Aniaml{
@Override
  public void eat() {
    System.out.println("狗吃骨头");
  }
  public void lookDoor(){
    System.out.println("狗看门");
  }
}

abstract关键字不能与哪些关键字共存

• abstract不能与private共存，因为被private修饰的方法不能在子类中访问，所以会和abstract冲突

• abstract不能与final共存，因为被final修饰的方法不能被重写，所以会和abstract冲突

• abstract不能与static共存，因为static修饰的方法不能重写，所以也就没有意义了

接口的概述及其特点

• 接口概述：
  继续回到我们的猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了。
  但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。
  而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的。
  所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。
  所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可
• 接口特点：
  1:接口用关键字interface表示 格式: interface 接口名 {}
  2:类实现接口用implements表示 格式: class 类名 implements 接口名 {}
  3:接口不能实例化
  那么，接口如何实例化呢?
  按照多态的方式来实例化。
  4:接口的子类
  a:可以是抽象类。但是意义不大。
  b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

接口的成员特点

• 接口成员特点：
  1.成员变量；只能是常量，并且是静态的。
  默认修饰符：public static final（jdk1.8之后默认加）
  建议：自己手动给出。
  2.构造方法：接口没有构造方法。
  3.成员方法：只能是抽象方法。
  默认修饰符：public abstract（jdk1.8之后默认加）

类与类,类与接口,接口与接口的关系

• 类与类：继承关系，只能实现单继承，但可以实现多继承

• 类与接口：实现关系，可以单实现，也可多实现，并且可以在继承一个类的同时实现多个接口

• 接口与接口：继承关系，可以单继承，也可多继承

抽象类和接口的区别

• 成员区别：
  1.抽象类：
  成员变量：可以变量，也可以常量
  构造方法：有
  成员方法：可以抽象，也可以非抽象
  2.接口：
  成员变量：只可以常量
  成员方法：只可以抽象
• 关系区别：
  1.类与类
  继承，单继承
  2.类与接口
  实现，单实现，多实现
  3.接口与接口
  继承，单继承，多继承
• 设计理念区别：
  抽象类 被继承体现的是：”is a”的关系。 抽象类中定义的是该继承体系的共性功能。
  接口 被实现体现的是：”like a”的关系。 接口中定义的是该继承体系的扩展功能。

接口的案例

西开的老师有基础班的，也有就业班的。

共性：

   属性：姓名，年龄

   功能：讲课。

现在又要针对日语这种小语种单独开班，

需要部分基础班老师和部分就业班老师会说日语。

请用所学知识把上面的内容用代码体现。

package org.westos.domo;
public class Demo2 {
  public static void main(String[] args) {
    JiChu jiChu = new JiChu();
    Teacher teacher1 = jiChu;
    teacher1.name = "沈老师";
    teacher1.age = 18;
    System.out.println(teacher1.name);
    System.out.println(teacher1.age);
    teacher1.teach();
    Speak speak = jiChu;
    speak.speak();
    System.out.println("------------------------------------------------");
    JiuYe jiuYe = new JiuYe();
    Teacher teacher2=jiuYe;
    teacher2.name="熊老师";
    teacher2.age=19;
    System.out.println(teacher2.name);
    System.out.println(teacher2.age);
    teacher2.teach();
    Speak speak1=jiuYe;
    speak1.speak();
  }
}
class Teacher {
  String name;
  int age;
  public void teach() {
    System.out.println("讲课");
  }
}
class JiChu extends Teacher implements Speak {
@Override
  public void teach() {
    System.out.println(name+"会讲JavaSE,基础班");
  }
@Override
  public void speak() {
    System.out.println(name + "为了工作，不得已而学日语");
  }
}
class JiuYe extends Teacher implements Speak {
@Override
  public void teach() {
    System.out.println(name+"会讲JavaEE,就业班");
  }
@Override
  public void speak() {
    System.out.println(name+"为了不被老板炒鱿鱼，必须得学会日语");
  }
}
interface Speak {
  void speak();
}