【Java】十、抽象类(abstract)、接口(interface)与封装

抽象类

抽象类不能被实例化（不能new 抽象类）

1     2     3     4     5     6     7     8     9    10    11    12    13    14    15    16    17

public abstract class Employee {    private String name;    public Employee(String name)    {       System.out.println("Constructing an Employee");       this.name = name;    }    public String toString()    {       return name + " " + address + " " + number;    }    public String getName()    {       return name;    } }

一个类只能继承一个抽象类

1     2     3     4     5     6     7     8     9    10    11    12    13    14    15    16    17    18    19    20

public class Salary extends Employee {    private double salary; //Annual salary    public Salary(String name, double salary)    {        super(name); //调用父类构造方法        setSalary(salary);    }    public double getSalary()    {        return salary;    }    public void setSalary(double newSalary)    {        if(newSalary >= 0.0)        {           salary = newSalary;        }    } }

抽象方法

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

任何子类必须重写父类的抽象方法，或者声明自身为抽象类

构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法

继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法

抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号

1     2     3     4     5     6

public abstract class Employee {    private String name;      public abstract double computePay();      //其余代码 }

接口

是一个抽象类型（但不是类），是抽象方法的集合，接口通常以interface来声明

类描述对象的属性和方法，接口则包含类要实现的方法（方法会被隐式的指定为public abstract，可以指定为default或static以实现具体方法）

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法

接口不是被类继承了，而是要被类实现

接口类型可用来声明一个变量（会被隐式的指定为public static final变量，用private修饰会报编译错误）

接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字

接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字

接口中的方法都是公有的

1     2     3     4     5     6     7

public interface NameOfInterface {    //任何类型 final, static 字段    //抽象方法    public void f1();    public void f2(); }

接口的实现

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类

类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常

类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型

1     2     3     4     5     6     7     8     9    10    11    12    13    14    15    16    17    18    19    20

public class C implements I1, I2 {      public void c1(){       System.out.println("c1");    }      public void c2(){       System.out.println("c2");    }      public int c3(){       return 0;    }      public static void main(String args[]){       C c = new C();       c.f1();       c.f2();    } }

接口的继承

接口可以继承一个或多个接口。接口的继承使用extends关键字，子接口继承父接口的方法

1     2     3     4     5     6     7     8     9    10    11    12

public interface Sports {    public void setHomeTeam(String name);    public void setVisitingTeam(String name); } public interface Football extends Sports {    public void homeTeamScored(int points);    public void visitingTeamScored(int points);    public void endOfQuarter(int quarter); }

以上Football接口自己声明了三个方法，从Sports接口继承了两个方法，这样，实现Football接口的类需要实现五个方法

抽象类和接口的区别

语法层面上的区别

 1）抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法

 2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的

 3）接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法

 4）一个类只能继承一个抽象类，而一个类却可以实现多个接口

设计层面上的区别

• 抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。举个简单的例子，飞机和鸟是不同类的事物，但是它们都有一个共性，就是都会飞。那么在设计的时候，可以将飞机设计为一个类 Airplane，将鸟设计为一个类 Bird，但是不能将 飞行 这个特性也设计为类，因此它只是一个行为特性，并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly，包含方法fly( )，然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机，比如战斗机、民用飞机等直接继承Airplane即可，对于鸟也是类似的，不同种类的鸟直接继承Bird类即可。从这里可以看出，继承是一个 "是不是"的关系，而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系，比如鸟是否能飞（或者是否具备飞行这个特点），能飞行则可以实现这个接口，不能飞行就不实现这个接口
• 设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。什么是模板式设计？最简单例子，大家都用过 ppt 里面的模板，如果用模板 A 设计了 ppt B 和 ppt C，ppt B 和 ppt C 公共的部分就是模板 A 了，如果它们的公共部分需要改动，则只需要改动模板 A 就可以了，不需要重新对 ppt B 和 ppt C 进行改动。而辐射式设计，比如某个电梯都装了某种报警器，一旦要更新报警器，就必须全部更新。也就是说对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动

e.g. 门和警报

门都有 open() 和 close() 两个动作，此时我们可以定义通过抽象类和接口来定义这个抽象概念：

1     2     3     4

abstract class Door {     public abstract void open();     public abstract void close(); }

或者

1     2     3     4

interface Door {     public abstract void open();     public abstract void close(); }

但是现在如果我们需要门具有报警 的功能，那么该如何实现？下面提供两种思路：

• 将这三个功能都放在抽象类里面，但是这样一来所有继承于这个抽象类的子类都具备了报警功能，但是有的门并不一定具备报警功能
• 将这三个功能都放在接口里面，需要用到报警功能的类就需要实现这个接口中的 open( ) 和 close( )，也许这个类根本就不具备 open( ) 和 close( ) 这两个功能，比如火灾报警器

从这里可以看出， Door 的 open() 、close() 和 alarm() 根本就属于两个不同范畴内的行为，open() 和 close() 属于门本身固有的行为特性，而 alarm() 属于延伸的附加行为。因此最好的解决办法是单独将报警设计为一个接口，包含 alarm() 行为，Door 设计为单独的一个抽象类，包含 open 和 close 两种行为。再设计一个报警门继承 Door 类和实现 Alarm 接口

1     2     3     4     5     6     7     8     9    10    11    12    13    14    15    16    17    18    19    20

interface Alram {     void alarm(); }   abstract class Door {     void open();     void close(); }   class AlarmDoor extends Door implements Alarm {     void oepn() {       //....     }     void close() {       //....     }     void alarm() {       //....     } }

封装

包：用于区别类名的命名空间，防止类的命名冲突，实现了访问控制。通常使用小写字母

将成员变量属性设为私有，通过public方法提供外部类访问该类成员变量的入口（getter和setter方法）

e.g.

1     2     3     4     5     6     7     8     9    10    11    12    13    14    15    16    17

public class Person{     private String name;     private int age; ​     public int getAge(){       return age;     } ​    public String getName(){       return name;     } ​    public void setAge(int age){       this.age = age;     } ​    public void setName(String name){       this.name = name;     } }