继承与多态

继承

概述

由来

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类便可。如图所示：

其中，多个类能够称为子类，单独那一个类称为父类、超类（superclass）或者基类。

继承描述的是事物之间的所属关系，这种关系是： is-a 的关系。例如，图中兔子属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。咱们经过继承，可使多种事物之间造成一种关系体系。

定义

• 继承：就是子类继承父类的属性和行为，使得子类对象具备与父类相同的属性、相同的行为。子类能够直接访问父类中的非私有的属性和行为。

好处

1. 提升代码的复用性。
2. 类与类之间产生了关系，是多态的前提。

继承的格式

经过 extends 关键字，能够声明一个子类继承另一个父类，定义格式以下：

class 父类 {
    ...
}
class 子类 extends 父类{
    ...
}

继承演示代码以下：

//定义员工类Employee做为父类
class Employee {    
    //定义name属性  
    String name;
    //定义员工的工做方法
    public void work() {
        System.out.println("全力以赴地工做");
    }
}

//定义教师类Teacher继承员工类Employee
class Teacher extends Employee {
    //定义一个打印name的方法
    public void printName() {
        System.out.println("name="+ name);
    }
}

//定义测试类
public class ExtendDemo01 {
    public static void main(String[] args) {
        //建立一个教师类对象
        Teacher t = new Teacher();
        //为该员工类的name属性赋值
        t.name = "小明";
        //调用Teacher类中的printName()方法
        t.printName(); // name=小明
        //调用Teacher类继承来的Work()方法
        t.work(); // 全力以赴地工做
    }
}

继承后的特色——成员变量

当类之间产生了关系后，其中各种中的成员变量，又产生了哪些影响呢？

成员变量不重名

若是子类父类中出现不重名的成员变量，这时的访问是没有影响的。代码以下：

class Fu {
    //Fu中的成员变量
    int num = 5;
}

class Zi extends Fu {
    //Zi中的成员变量
    int num2 = 6;
    //Zi中的成员方法
    public void show() {
        //访问父类中的num
        System.out.println("Fu num = "+num); //继承而来，因此直接访问。         
        //访问子类中的num2
        System.out.println("Zi num2 = "+num2);
    }
}

class ExtendsDemo02 {
    public static void main(String[] args) {
        //建立子类对象
        Zi z = new Zi();
        //调用子类中的show()方法
        z.show();
    }
}

演示结果：
Fu num = 5
Zi num2 = 6

成员变量重名

若是子类父类中出现重名的成员变量，这时的访问是有影响的。代码以下：

class Fu {
    //Fu中的成员变量
    int num = 5;
}

class Zi extends Fu {
    //Zi中的成员变量
    int num = 6;
    //Zi中的成员方法
    public void show() {
        //访问父类中的num
        System.out.println("Fu num = "+num);            
        //访问子类中的num
        System.out.println("Zi num = "+num);
    }
}

class ExtendsDemo02 {
    public static void main(String[] args) {
        //建立子类对象
        Zi z = new Zi();
        //调用子类中的show()方法
        z.show();
    }
}

演示结果：
Fu num = 6
Zi num = 6

子父类中出现了同名的成员变量时，在子类中须要访问父类中非私有成员变量时，须要使用 super 关键字，修饰父类成员变量，相似于以前学过的 this 。

使用格式：

super.父类成员变量名

子类方法须要修改，代码以下：

class Zi extends Fu {
    //Zi中的成员变量
    int num = 6;
    //Zi中的成员方法
    public void show() {
        //访问父类中的num
        System.out.println("Fu num = "+super.num);          
        //访问子类中的num
        System.out.println("Zi num = "+num);
    }
}

演示结果：
Fu num = 5
Zi num = 5

小贴士：Fu 类中的成员变量是非私有的，子类中能够直接访问。若Fu 类中的成员变量私有了，子类是不能直接访问的。一般编码时，咱们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员 变量呢？对！能够在父类中提供公共的getXxx方法和setXxx方法。

继承后的特色——成员方法

当类之间产生了关系，其中各种中的成员方法，又产生了哪些影响呢？

成员方法不重名

若是子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。代码以下：

class Fu {
    public void show() {
        System.out.println("Fu类中的show方法执行");
    }
}
class Zi extends Fu {
    public void show2() {
        System.out.println("Zi类中的show2方法执行");
    }
}
public class ExtendsDemo04 {
    public static void main(String[] args) {
        Zi z = new Zi();
        //子类中没有show方法，可是能够找到父类方法去执行
        z.show();
        z.show2();
    }
}
演示结果：
Fu类中的show方法执行
Zi类中的show2方法执行

成员方法重名——重写(Override)

若是子类父类中出现重名的成员方法，这时的访问是一种特殊状况，叫作方法重写 (Override)。

• 方法重写 ：子类中出现与父类如出一辙的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，从新实现。

代码以下：

class Fu {
    public void show() {
        System.out.println("Fu类中的show方法执行");
    }
}
class Zi extends Fu {
    public void show() {
        System.out.println("Zi类中的show方法执行");
    }
}
public class ExtendsDemo04 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}
演示结果：
Zi类中的show方法执行

重写的应用

子类能够根据须要，定义特定于本身的行为。既沿袭了父类的功能名称，又根据子类的须要从新实现父类方法，从而进行扩展加强。

super.父类成员方法，表示调用父类的成员方法

注意事项

1. 子类方法覆盖父类方法，必需要保证权限大于等于父类权限。
2. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要如出一辙。

继承后的特色——构造方法

当类之间产生了关系，其中各种中的构造方法，又产生了哪些影响呢？

首先咱们要回忆两个事情，构造方法的定义格式和做用。

1. 构造方法的名字是与类名一致的。因此子类是没法继承父类构造方法的。

2. 构造方法的做用是初始化成员变量的。因此子类的初始化过程当中，必须先执行父类的初始化动做。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才能够给子类使用。代码以下：

   class Fu {
   private int n;
   Fu() {
   System.out.println("Fu()");
   }
   }
   class Zi extends Fu{
   Zi() {
   super(); //调用父类构造方法
   System.out.println("Zi()");
   }
   }
   public class ExtendsDemo07 {
   public static void main(String args) {
   Zi zi = new Zi();
   }
   }
   输出结果：
   Fu()
   Zi()

super和this

父类空间优先于子类对象产生

在每次建立子类对象时，先初始化父类空间，再建立其子类对象自己。目的在于子类对象中包含了其对应的父类空间，即可以包含其父类的成员，若是父类成员非private修饰，则子类能够随意使用父类成员。代码体如今子类的构造方法调用时，必定先调用父类的构造方法。理解图解以下：

super和this的含义

• super ：表明父类的存储空间标识(能够理解为父亲的引用)。
• this ：表明当前对象的引用(谁调用就表明谁)。

super和this的用法

1. 访问成员

   this.成员变量    --  本类的
    super.成员变量   --  父类的
   
    this.成员方法名()    --  本类的
    super.成员方法名()   --  父类的

2. 访问构造方法

   this(...)    --  本类的构造方法
    super(...)   --  父类的构造方法

子类的每一个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。 super() 和 this() 都必须是在构造方法的第一行，因此不能同时出现。

继承的特色

1. Java只支持单继承，不支持多继承。

   //一个类只能有一个父类，不能够有多个父类。
    class C extends A{}     //ok
    class C exteds A,B...   //error

2. Java支持多层继承(继承体系)。

   class A{}
    class B extends A{}
    class C extends B{}

顶层父类是Object类。全部的类默认继承Object做为父类。

1. 子类和父类是一种相对的概念。

抽象类

概述

由来

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。咱们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

定义

• 抽象方法 ： 没有方法体的方法。
• 抽象类：包含抽象方法的类。

abstract使用格式

抽象方法

使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式：

修饰符 abstract 返回值类型 方法名 (参数列表)；

代码举例：

public abstract void run()；

抽象类

若是一个类包含抽象方法，那么该类必须是抽象类。

定义格式：

abstract class 类名字 {

}

代码举例:

public abstract class Animal {
    public abstract void run();
}

抽象的使用

继承抽象类的子类必须重写父类全部的抽象方法。不然，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，不然，从最初的父类到最终的子类都不能建立对象，失去意义。

代码举例：

public class Cat extends Animal {
    public void run() {
        System.out.println("小猫在墙头走");
    }
}
public class CatTest {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.run();
    }
}
输出结果：
小猫在墙头走

此时的方法重写，，是子类对父类抽象方法的完成实现，咱们将这种方法重写的操做，也叫作实现方法。

注意事项

关于抽象类的使用，如下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

1.抽象类不能建立对象，若是建立，编译没法经过而报错。只能建立其非抽象子类的对象。

理解：假设建立了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

2.抽象类中，能够有构造方法，是供子类建立对象时，初始化父类成员使用的。

理解：子类的构造方法中，有默认的super()，须要访问父类构造方法。

3.抽象类中，不必定包含抽象方法，可是有抽象方法的类一定是抽象类。

理解：未包含抽象方法的抽象类，目的就是不想让调用者建立该类对象，一般用于某些特殊的类结构设计。

4.抽象类的子类，必须重写抽象父类中全部的抽象方法，不然，编译没法经过而报错。除非该g子类也是抽象类。

理解：假设不重写全部抽象方法，则类中可能包含抽象方法。那么建立对象后，调用抽象的方法，没有意义。

继承的综合案例

群主发普通红包。某群有多名成员，群主给成员发普通红包。普通红包的规则：

1. 群主的一笔金额，从群主余额中扣除，平均分红n等份，让成员领取。
2. 成员领取红包后，保存到成员余额中。

请根据描述，完成案例中全部类的定义以及指定类之间的继承关系，并完成发红包的操做。

根据描述分析，获得以下继承体系

案例实现

定义用户类：

public class User {
    private String username;    //用户名
    private double leftMoney;   //余额

    //构造方法
    public User(){}

    public User(String username, double leftMoney) {
        this.username = username;
        this.leftMoney = leftMoney;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public double getLeftMoney() {
        return leftMoney;
    }

    public void setLeftMoney(double leftMoney) {
        this.leftMoney = leftMoney;
    }

    public void show() {
        System.out.println("用户名:"+ username + ", 余额为:" + leftMoney + "元");
    }
}

定义群主类：

public class Qunzhu extends User {

    public Qunzhu(){}

    public Qunzhu(String username, double leftMoney) {
        super(username, leftMoney);
    }
/*
    群主发红包，就是把一个浮点数的金额分红若干份。
    1.获取群主金额，是否够发红包 不够则返回null并提示 够则继续
    2.修改群主余额
    3.拆分成包
        3.1 若是能被整除就平均分
        3.2 若是不能 那么就把余数分给最后一份
 */
    public ArrayList<Double> send(double money, int count) {
        double leftMoney = getLeftMoney();
        if (money > leftMoney) {
            return null;
        }
        //修改群主余额
        setLeftMoney(leftMoney - money);
        //建立一个集合，保存等份金额
        ArrayList<Double> list = new ArrayList<>();
        //扩大100倍，至关于折算成‘分’为单位，避免小数运算损失精度
        money = money * 100;
        //每份的金额
        double m = money / count;
        //不能整除的余数
        double l = money % count;

        for(int i = 0;i < count - 1; i++) {
            list.add(m / 100.0);
        }
        if(l == 0) {
            //能整除，最后一份金额与以前每份金额一致
            list.add(m / 100.0);
        } else {
            //不能整除，最后一份金额为以前每份的金额+余数金额
            list.add((m + 1) / 100.0);
        }

        return list;
    }
}

定义成员类：

public class Member extends User{
    public Member() {}

    public Member(String username, double leftMoney) {
        super(username, leftMoney);
    }
    // 打开红包，就是从集合中随机取出一份保存到本身的余额中
    public void openHongbao(ArrayList<Double> list) {
        Random r = new Random();
        int index = r.nextInt(list.size());
        Double money = list.remove(index);
        setLeftMoney(money);
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        Qunzhu qz = new Qunzhu("群主", 200);
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入金额：");
        double money = sc.nextDouble();
        System.out.println("请输入个数：");
        int count = sc.nextInt();

        //发送红包
        ArrayList<Double> sendList = qz.send(money,count);

        if(sendList == null) {
            System.out.println("余额不足...");
            return;
        }

        Member m1 = new Member();
        Member m2 = new Member();
        Member m3 = new Member();

        m1.openHongbao(sendList);
        m2.openHongbao(sendList);
        m3.openHongbao(sendList);

        qz.show();
        m1.show();
        m2.show();
        m3.show();
    }
}

接口

概述

接口，是Java语言中一种引用类型，是方法的集合，若是说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及之前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。

接口的定义，它与定义类方式类似，可是使用 interface 关键字。它也会被编译成.class文件，但必定要明确它并非类，而是另一种引用数据类型。

引用数据类型：数组、类、接口。

接口的使用，它不能建立对象，可是能够被实现（ implements ，相似于被继承）。一个实现接口的类（能够看做是接口的子类），须要实现接口中全部的抽象方法，建立该类对象，就能够调用方法了，不然它必须是一个抽象类。

定义格式

public interface 接口名称 {
    //抽象方法
    //默认方法
    //静态方法
    //私有方法
}

含有抽象方法

抽象方法：使用 abstract 关键字修饰，能够省略，没有方法体。该方法供子类实现使用。

代码以下：

public interface InterFaceName {
    public abstract void method();
}

含有默认方法和静态方法

默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。

静态方法：使用 static 修饰，供接口直接调用。

代码以下：

public interface InterFaceName {
    public default void method() {
        //执行语句
    }
    public static void method2() {
        //执行语句
    }
}

含有私有方法和私有静态方法

私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。

代码以下：

public interface InterFaceName {
    private void method() {
        //执行语句
    }
}

基本的实现

实现的概述

类与接口的关系为实现关系，即类实现接口，该类能够称为接口的实现类，也能够称为接口的子类。实现的动做相似继承，格式相仿，只是关键字不一样，实现使用 implements 关键字。

非抽象子类实现接口：

1. 必须重写接口中全部抽象方法。
2. 继承了接口的默认方法，便可以直接调用，也能够重写。

实现格式：

class 类名 implements 接口名 {
    // 重写接口中抽象方法【必须】
    // 重写接口中默认方法【可选】
}

抽象方法的使用

必须所有实现，代码以下：

定义接口：

public interface LivaAble {
    //定义抽象方法
    public abstract void eat();
    public abstract void sleep();
}

定义实现类：

public class Animal implements LiveAble {
    @Override
    public void eat() {
        System.out.println("吃东西");
    }
    @Override
    public void sleep() {
        System.out.println("晚上睡");
    }
}

测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        //建立子类对象
        Animal a = new Animal();
        //调用实现后的方法
        a.eat();
        a.sleep();
    }
}
输出结果：
吃东西
晚上睡

默认方法的使用

能够继承，能够重写，二选一，可是只能经过实现类的对象来调用。

1.默认继承方法，代码以下：

定义接口：

public interface LiveAble {
    public default void fly() {
        System.out.println("天上飞");
    }
}

定义实现类：

public class Animal implements LiveAble {
    //继承，什么都不用谢，直接调用
}

测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        //建立子类对象
        Animal a = new Animal();
        //调用默认方法
        a.fly();
    }
}
输出结果：
天上飞

2.重写默认方法，代码以下：

定义接口：

public interface LiveAble {
    public default void fly() {
        System.out.println("天上飞");
    }
}

定义实现类：

public class Animal implements LiveAble {
    @Override
    public void fly() {
        System.out.println("自由自在的飞");
    }
}

测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        //建立子类对象
        Animal a = new Animal();
        //调用重写方法
        a.fly();
    }
}
输出结果：
自由自在的飞

静态方法的使用

静态与.class 文件相关，只能使用接口名调用，不能够经过实现类的类名或者实现类的对象调用，代码以下：

定义接口：

public interface LiveAble {
    public static void run() {
        System.out.println("地上跑");
    }
}

定义实现类：

public class Animale implements LiveAble {
    //没法重写静态方法
}

测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        // Animal.run(); //【错误】没法继承方法，也没法调用
        LiveAble.run();
    }
}
输出结果：
地上跑

私有方法的使用

• 私有方法：只有默认方法能够调用
• 私有静态方法：默认方法和静态方法能够调用。

若是一个接口中有多个默认方法，而且方法中有重复的内容，那么能够抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度讲，私有的方法是对默认方法和静态方法的辅助。

定义接口：

public interface LiveAble {
    default void func() {
        func1();
        func2();
    }
    private void func1(){
        System.out.println("func1~~");
    }
    private void func2(){
        System.out.println("func2~~");
    }
}

接口的多实现

以前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是能够实现多个接口的，这叫作接口的多实现。而且，一个类能继承一个父类，同时实现多个接口。

实现格式：

class 类名 [extends 父类名] implements 接口名1，接口名2，接口名3... {
    //重写接口中的抽象方法【必须】
    //重写接口中的默认方法【不重名时可选】
}

抽象方法

接口中，有多个抽象方法时，实现类必须重写全部抽象方法。若是抽象方法有重名的，只须要重写一次。代码以下：

定义多个接口：

interface A {
    public abstract void showA();
    public abstract void show();
}
interface B {
    public abstract void showB();
    public abstract void show();
}

定义实现类：

public class C implements A,B{
    @Override
    public void showA() {
        System.out.println("showA");
    }
    @Override
    public void showB() {
        System.out.println("showB");
    }
    @Override
    public void show() {
        System.out.println("show");
    }
}

默认方法

接口中，有多个默认方法时，实现类均可继承使用。若是默认方法有重名的，必须重写一次。代码以下：

定义多个接口：

interface A {
    public default void methodA(){}
    public default void method(){}
}
interface B {
    public default void methodB(){}
    public default void method(){}
}

定义实现类：

public class C implements A,B {
    @Override
    public void method() {
        System.out.println("method");   
    }
}

静态方法

接口中，存在同名的静态方法并不会冲突，缘由是只能经过各自接口名访问静态方法。

优先级的问题

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。代码以下：

定义接口:

interface A {
    public default void methodA(){
        System.out.println("AAA");
    }
}

定义父类:

class B {
    public void methodA(){
        System.out.println("BBB");
    }
}

定义子类:

class C extends D implements A {
    //未重写methodA方法
}

测试类:

public class Test {
    public static void main(String[] args) {
        C c = new C();
        c.methodA();
    }
}
输出结果：
BBB

接口的多继承【了解】

一个接口能继承另外一个或者多个接口，这和类之间的继承比较类似。接口的继承使用 extends 关键字，子接口继承父接口的方法。若是父接口中的默认方法有重名的，那么子接口须要重写一次。代码以下：

定义父接口：

interface A {
    public default void method(){
        System.out.println("AAA");
    }
}
interface B {
    public default void method(){
        System.out.println("BBB");
    }
}

定义子接口：

interface D extends A,B {
    @Override
    public default void method() {
        System.out.println("DD");
    }
}

小贴士：
子接口重写默认方法时，default关键字能够保留。子类重写默认方法时，default关键字不能够保留。

其余成员特色

• 接口中，没法定义成员变量，可是能够定义常量，其值不能够改变，默认使用public static final修饰。
• 接口中，没有构造方法，不能建立对象。
• 接口中，没有静态代码块。

多态

概述

引入

多态是继封装、继承以后，面向对象的第三大特性。

生活中，好比跑的动做，小猫、小狗和大象，跑起来是不同的。再好比飞的动做，昆虫、鸟类和飞机，飞起来也是不同的。可见，同一行为经过不一样的事物，能够体现出来的不一样的形态。多态描述的就是这样的状态。

定义

• 多态： 是指同一行为，具备多个不一样表现形式。

前提【重点】

1. 继承或者实现【二选一】
2. 方法的重写【意义体现：不重写，无心义】
3. 父类引用指向子类对象【格式体现】

多态的体现

多态体现的格式：

父类类型 变量名 = new 子类对象;
变量名.方法名();

父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

代码以下：

Fu f = new Zi();
f.method();

当使用多态方式调用方法时，首先检查父类中是否有该方法，若是没有，则编译错误；若是有，执行的是子类重写后方法。

代码以下：

定义父类：

public abstract class Animal {
    public abstract void eat();
}

定义子类：

public Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
}
public Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头")；
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        //多态形式，建立对象
        Animal a1 = new Cat();
        //调用的是Cat的eat
        a1.eat();
        //多态形式，建立对象
        Animal a2 = new Dog();
        //调用的是Dog的eat
        a2.eat();
    }
}
输出结果：
吃鱼
吃骨头

多态的好处

实际开发的过程当中，父类类型做为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。代码以下：

定义父类：

public abstract class Animal {
    public abstract void eat();
}

定义子类：

public Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
}
public Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头")；
    }
}

测试类：

public class Test_1 {
    public static void main(String[] args) {
        Cat c = new Cat();
        Dog d = new Dog();

        showCatEat(c);
        showDogEat(d);

        /*
        以上两个方法都可以被showAnimalEat(Animal a)方法所替代，且执行效果一致
        */
        showAnimalEat(c);
        showAnimalEat(d);

    }
    public static void showCatEat(Cat c){
        c.eat();
    }
    public static void showDogEat(Dog d){
        d.eat();
    }
    public static void showAnimalEat(Animal a){
        a.eat();
    }
}

因为多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，固然能够把Cat对象和Dog对象，传递给方法。

当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果天然与showCatEat、showDogEat方法一致，因此showAnimalEat彻底能够替代以上两方法。

不只仅是替代，在扩展性方面，不管以后再多的子类出现，咱们都不须要编写showXxxEat方法了，直接使用showAnimalEat均可以完成。

因此，多态的好处，体如今，可使程序编写的更简单，并有良好的扩展。

引用类型转换

多态的转型分为向上转型与向下转型两种：

向上转型

• 向上转型：多态自己是子类类型向父类类型向上转换的过程，这个过程是默认的。

当父类引用指向一个子类对象时，即是向上转型。

使用格式：

父类类型 变量名 = new 子类类型();
如 Animal a = new Cat();

向下转型

• 向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转为子类引用，可使用强制类型转换的格式，即是向下转型。

使用格式：

子类类型 变量名 = (子类类型) 父类变量名;
如 Cat c = (Cat) a;

为何要转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，若是没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给咱们带来的一点"小麻烦"。因此，想要调用子类特有的方法，必须作向下转型。

转型演示，代码以下：

定义类：

abstract class Animal {
    abstract void eat();
}

class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
    public void catchMouse() {
        Sysetm.out.println("抓老鼠");
    }   
}

class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
    public void watchHouse() {
        System.out.println("看家");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        //向上转型
        Animal a = new Cat();
        a.eat();    //调用的是Cat的eat
        //向下转型
        Cat c = (Cat) a;
        c.catchMouse();
    }
}

转型的异常

转型的过程当中，一不当心就会遇到这样的问题，请看以下代码：

public class Test {
    public static void main(String[] args) {
        //向上转型
        Animal a = new Cat();
        a.eat();
        //向下转型
        Dog d = (Dog)a;
        d.watchHouse(); //调用的是Dog的watchHouse 【运行报错】
    }
}

这段代码能够经过编译，可是运行时，却报出了 ClassCastException ，类型转换异常！这是由于，明明建立了Cat类型对象，运行时，固然不能转换成Dog对象的。这两个类型并无任何继承关系，不符合类型转换的定义。

为了不ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量作类型的校验，格式以下：

变量名 instanceof 数据类型  
若是变量属于该数据类型，返回true。 
若是变量不属于该数据类型，返回false。

因此，转换前，咱们好先作一个判断，代码以下：

public class Test {
    public static void main(String[] args) {
        //向上转型
        Animal a = new Cat();
        a.eat();
        //向下转型
        if (a instanceof Cat) {
            Cat c = (Cat) a;
            c.catchMouse();
        } else if (a instanceof Dog) {
            Dog d = (Dog)a;
            d.watchHouse();
        }
    }
}

接口多态的综合案例

笔记本电脑（laptop）一般具有使用USB设备的功能。在生产时，笔记本都预留了能够插入USB设备的USB接口，但具体是什么USB设备，笔记本厂商并不关心，只要符合USB规格的设备均可以。

定义USB接口，具有基本的开启功能和关闭功能。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵照USB规范，实现USB接口，不然鼠标和键盘的生产出来也没法使用。

案例分析

进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘

• USB接口，包含开启功能、关闭功能
• 笔记本类，包含运行功能、关机功能、使用USB设备功能
• 鼠标类，要实现USB接口，并具有点击的方法
• 键盘类，要实现USB接口，具有敲击的方法

案例实现

定义USB接口：

public interface USB {
    void open(); //开启功能
    void close(); //关闭功能
}

定义鼠标类：

public class Mouse implements USB {
    @Override
    public void open() {
        System.out.println("鼠标开启，红灯亮");
    }

    @Override
    public void close() {
        System.out.println("鼠标关闭，红灯灭");
    }

    public void click() {
        System.out.println("鼠标点击");
    }
}

定义键盘类：

public class KeyBoard implements USB {
    @Override
    public void open() {
        System.out.println("键盘开启，绿灯亮");
    }

    @Override
    public void close() {
        System.out.println("键盘关闭，绿灯灭");
    }

    public void type() {
        System.out.println("键盘打字");
    }   
}

定义笔记本类：

class Laptop {
    public void run() {
        System.out.println("笔记本运行");
    }

    //笔记本使用usb设备，当笔记本对象调用这个功能时必须给其传递一个符合USB规则的USB设备
    public void useUSB(USB usb) {
        if (usb != null) {
            usb.open();
            if (usb instanceof Mouse){
                Mouse m = (Mouse) usb;
                m.click();
            } else if (usb instanceof KeyBoard) {
                KeyBoard kb = (KeyBoard)usb;
                kb.type();
            }
            usb.close();
        }
    }

    public void shutDown() {
        System.out.println("笔记本关闭");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        Laptop lt = new Laptop();
        lt.run();

        //建立鼠标实体对象
        USB u = new Mouse();
        //笔记本使用鼠标
        lt.useUSB(u);
        //建立键盘实体对象
        USB kb = new KeyBoard();
        //笔记本使用键盘
        lt.useUSB(kb);

        lt.shutDown();
    }
}

final关键字

概述

学习了继承后，咱们知道，子类能够在父类的基础上改写父类内容，好比，方法重写。那么咱们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了不这种随意改写的状况，Java提供了 final 关键字，用于修饰不可改变内容。

• final： 不可改变。能够用于修饰类、方法和变量。
  • 类：被修饰的类，不能被继承。
  • 方法：被修饰的方法，不能被重写。
  • 变量：被修饰的变量，不能被从新赋值。

使用方式

修饰类

格式以下：

final class 类名 {

}

查询API发现像 public final class String 、 public final class Math 、 public final class Scanner等，不少咱们学习过的类，都是被final修饰的，目的就是供咱们使用，而不让咱们因此改变其内容。

修饰方法

格式以下：

修饰符 final 返回值类型 方法名(参数列表) {
    //方法体
}

重写被 final 修饰的方法，编译时就会报错。

修饰变量

1.局部变量——基本类型

基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。

2.局部变量——引用类型

引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。可是不影响对象内部的成员变量值的修改，代码以下：

public class FinalDemo2 {
    public static void main(String[] args) {
        //建立User对象
        final User u = new User();
        //建立另外一个User对象
        u = new User(); //报错，指向了新的对象，地址值改变。
        //调用setName方法
        u.setName("张三"); //能够修改
    }
}

3.成员变量

成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：

• 显示初始化：

  public class User {
  final String USERNAME = "张三";
  private int age;
  }

• 构造方法初始化：

  public class User {
  final String USERNAME;
  private int age;
  public User(String username, int age) {
  this.USERNAME = username;
  this.age = age;
  }
  }

被final修饰的常量名称，通常都有书写规范，全部字母都大写。

权限修饰符

概述

在Java中提供了四种访问权限，使用不一样的访问权限修饰符修饰时，被修饰的内容会有不一样的访问权限。

• public：公共的
• protected：受保护的
• default：默认的
• private：私有的

不一样权限的访问能力

public	protected	defalut(空的)	private
同一类中	√	√	√	√
同一包中（子类与无关类）	√	√	√
不一样包的子类	√	√
不一样包中的无关类	√

可见，public具备最大权限。private则是最小权限。

编写代码时，若是没有特殊的考虑，建议这样使用权限：

• 成员变量使用 private ，隐藏细节。
• 构造方法使用 public ，方便建立对象。
• 成员方法使用 public ，方便调用方法。

小贴士：不加权限修饰符，其访问能力与default修饰符相同

内部类

概述

什么是内部类

将一个类A定义在另外一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

成员内部类

• 成员内部类 ：定义在类中方法外的类。

定义格式：

class 外部类 {
    class 内部类 {

    }
}

在描述事物时，若一个事物内部还包含其余事物，就可使用内部类这种结构。好比，汽车类 Car 中包含发动机类 Engine ，这时， Engine 就可使用内部类来描述，定义在成员位置。

代码举例：

class Car { //外部类
    class Engine {  //内部类

    }
}

访问特色

• 内部类能够直接访问外部类的成员，包括私有成员。
• 外部类要访问内部类的成员，必需要创建内部类的对象。

建立内部类对象格式：

外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

访问演示代码以下：

定义类：

public class Person {
    private boolean live = true;
    class Heart {
        public void jump() {
            //直接访问外部类成员
            if (live) {
                System.out.println("心脏在跳动");
            } else {
                Sysetm.out.println("心脏不跳了");
            }
        }
    }

    public boolean isLive() {
        return live;
    }
    public void setLive(boolean live) {
        this.live = live;
    }
}

测试类：

public class InnerDemo {
    public static void main(String[] args) {
        //建立外部类对象
        Person p = new Person();
        //建立内部类对象
        Heart heart = p.new Heart();

        //调用内部类方法
        heart.jump();
        //调用外部类方法
        p.setLive(false);
        //调用内部类方法
        heart.jump;
    }
}
输出结果：
心脏在跳动
心脏不跳了

内部类仍然是一个独立的类，在编译以后会内部类会被编译成独立的.class文件，可是前面冠之外部类的类名和$符号 。
好比，Person$Heart.class

匿名内部类【重点】

• 匿名内部类 ：是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。
  开发中，最经常使用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，彷佛得作以下几步操做。

1. 定义子类
2. 重写接口中的方法
3. 建立子类对象
4. 调用重写后的方法

咱们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是作这样的快捷方式。

前提

匿名内部类必须继承一个父类或者实现一个父接口。

格式

new 父类名或者接口名() {
    //方法重写
    @Override
    public void method() {
        //执行语句
    }
};

使用方式

以接口为例，匿名内部类的使用，代码以下：

定义接口：

public abstract class FlyAble{
    public abstract void fly();
}

建立匿名内部类并调用：

public class InnerDemo {
    public static void main(String[] args) {
        /*
        1.等号右边:是匿名内部类，定义并建立该接口的子类对象 
        2.等号左边:是多态赋值,接口类型引用指向子类对象   
        */
        FlyAble f = new FlyAble() {
            public void fly() {
                System.out.println("fly~");
            }
        };
        
        //调用fly方法，执行重写后的方法
        f.fly();
    }
}

一般在方法的形式参数是接口或者抽象类时，也能够将匿名内部类做为参数传递。代码以下：

public class InnerDemo2 {
    public static void main(String[] args) {
        /*         
        1.等号右边:定义并建立该接口的子类对象         
        2.等号左边:是多态,接口类型引用指向子类对象        
        */ 
        FlyAble f = new FlyAble() {
            public void fly() {
                System.out.println("fly~~");
            }
        };
        //将f传递给showFly方法中
        showFly(f);
    }
    public static void showFly(FlyAble f) {
        f.fly();
    }
}

以上两步，也能够简化为一步，代码以下：

public class InnerDemo3 {
    public static void main(String[] args) {
        /*         
        建立匿名内部类,直接传递给showFly(FlyAble f)           
        */
        showFly(new FlyAble(){
            public void fly() {
                System.out.println("fly~~");
            }
        }); 
    }
    public static void showFly(FlyAble f) {
        f.fly();
    }
}

引用类型用法总结

实际的开发中，引用类型的使用很是重要，也是很是广泛的。咱们能够在理解基本类型的使用方式基础上，进一步去掌握引用类型的使用方式。基本类型能够做为成员变量、做为方法的参数、做为方法的返回值，那么固然引用类型也是能够的。

class做为成员变量

在定义一个类Role（游戏角色）时，代码以下：

class Role {
    int id; //角色id
    int blood; //生命值
    String name; //角色名称
}

使用 int 类型表示 角色id和生命值，使用 String 类型表示姓名。此时， String 自己就是引用类型，因为使用的方式相似常量，因此每每忽略了它是引用类型的存在。若是咱们继续丰富这个类的定义，给 Role 增长武器，穿戴装备等属性，咱们将如何编写呢？

定义武器类，将增长攻击能力：

class Weapon { 
    String name; //武器名称
    int hurt; //伤害值
}

定义穿戴盔甲类，将增长防护能力，也就是提高生命值：

class Armour {
    String name; //装备名称
    int protect; //防护值
}

定义角色类：

class Role {
    int id;
    int blood;
    String name;
    //添加武器属性
    Weapon wp;
    //添加盔甲属性
    Armour ar;

    //提供get/set方法
    public Weapon getWp() {
        return wp;
    }
    public void setWeapon(Weapon wp) {
        this.wp = wp;
    }
    public Armour getArmour() {
        return ar;
    }
    public void setArmour(Armour ar) {
        this.ar = ar;
    }
    //攻击方法
    public void attack() {
        System.out.println("使用"+wp.getName() + ", 形成"+wp.getHurt()+"点伤害");
    }
    //穿戴盔甲
    public void wear() {
        //增长防护就是增长blood值
        this.blood += ar.getProtect();
        System.out.println("穿上"+ar.getName()+", 生命值增长"+ar.getProtect());
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        //建立Weapon对象
        Weapon wp = new Weapon("屠龙宝刀", 99999);
        //建立Armour对象
        Armour ar = new Armour("麒麟甲",10000);
        //建立Role对象
        Role r = new Role();
        //设置属性
        r.setWeapon(wp);
        r.setArmour(ar);
        r.attack();
        r.wear();
    }
}
输出结果：
使用屠龙宝刀，形成99999点伤害
穿上麒麟甲，生命值增长10000

类做为成员变量时，对它进行赋值的操做，其实是赋给它该类的一个对象。

interface做为成员变量

接口是对方法的封装，对应游戏当中，能够看做是扩展游戏角色的技能。因此，若是想扩展更强大技能，咱们在Role中，能够增长接口做为成员变量，来设置不一样的技能。

定义接口：

//法术攻击
public interface FaShuSkill {
    public abstract void FaShuAttack();
}

定义角色类：

public class Role {
    FaShuSkill fs;
    public void setFaShuSkill(FaShuSkill fs) {
        this.fs = fs;
    }
    //法术攻击
    public void FaShuSkillAttack() {
        System.out.print("发动法术攻击:");
        fa.FaShuAttack();
        System.out.println("攻击完毕");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        //建立游戏角色
        Role role = new Role();
        //设置角色法术技能
        role.setFaShuSkill(new FaShuSkill(){
            @Override
            public void FaShuAttack() {
                System.out.println("纵横天下");
            }
        });
        //发动法术攻击
        role.FaShuSkillAttack();
        //更换技能
        role.setFaShuSkill(new FaShuSkill() {
            @Override
            public void FaShuAttack() {
                System.out.println("逆转乾坤")；
            }
        })；
        //发动法术攻击
        role.FaShuSkillAttack();
    }
}
输出结果：
发动法术攻击:纵横天下 
攻击完毕 
发动法术攻击:逆转乾坤 
攻击完毕

咱们使用一个接口，做为成员变量，以便随时更换技能，这样的设计更为灵活，加强了程序的扩展性。

接口做为成员变量时，对它进行赋值的操做，实际上，是赋给它该接口的一个子类对象。

interface做为方法参数和返回值类型

当接口做为方法的参数时,须要传递什么呢？当接口做为方法的返回值类型时，须要返回什么呢？对，其实都是它的子类对象。 ArrayList 类咱们并不陌生，查看API咱们发现，实际上，它是 java.util.List 接口的实现类。因此，当咱们看见 List 接口做为参数或者返回值类型时，固然能够将 ArrayList 的对象进行传递或返回。

请观察以下方法：获取某集合中全部的偶数。

定义方法：

public static List<Integer> getEvenNum(List<Integer> list){
    //建立保存偶数的集合
    ArrayList<Integer> evenList = new ArrayList<>();
    for (int i = 0; i < list.size(); i++){
        Integer integer = list.get(i);
        if(integer % 2 == 0) {
            evenList.add(integer);
        }
    }
    /*
    返回偶数集合
    由于getEvenNum方法的返回值类型是List，而ArrayList是List的子类，因此evenList能够返回
     */
    return evenList;
}

调用方法：

public static void main(String[] args) {
    //建立ArrayList集合，并添加数字
    ArrayList<Integer> srcList = new ArrayList<>();
    for(int i = 0; i < 10; i++) {
        srcList.add(i);
    }
    /*        
    获取偶数集合          
    由于getEvenNum方法的参数是List,而ArrayList是List的子类,          
    因此srcList能够传递          
    */
    List list = getEvenNum(srcList);
    System.out.println(list);
}

接口做为参数时，传递它的子类对象。

接口做为返回值类型时，返回它的子类对象。