六、抽象类和接口、类型和类型之间的关系

一、抽象类相关概念：

1.抽象类：将类和类之间共同特征提取出来，形成的就是抽象类。

2.抽象类的定义：

　　【修饰符列表】 abstract class 类名{

　　　　类体；

　　}

3.抽象方法：

　　表示没有实现的方法，没有方法体的方法。抽象方法必须在抽象类中。

　　如： public abstract void doSome();

4.抽象类是无法实例化的，无法创建对象的，故抽象类是用来被子类继承的。

5.抽象类虽然无法实例化，但是抽象类有构造方法，供子类使用(super)。

6.抽象类中不一定有抽象方法，但抽象方法必须出现在抽象类中。

7.子类继承抽象类，必须对抽象类中的所有抽象方法覆写/重写，也叫实现。非抽象方法可以不用重写。

8.final和abstract不能联合使用，这两个关键字是对立的。

abstract class Account{    public abstract void doSome();//抽象方法}class CreditAccount extends Account{    @Override    public void doSome() {        System.out.println("CreaditAccount");    }    }public class AbstractOne {    public static void main(String[] args) {        //Account a = new Account(); 抽象类无法实例化                Account q = new CreditAccount();    //面向抽象编程        q.doSome();    }}

二、接口

 1.1、接口是完全抽象的。（抽象类是半抽象）或者说是特殊的抽象类。

　　接口是一种引用数据类型，编译后也是一个class字节码文件。

1.2、接口的定义：

　　【修饰符列表】  interface 接口名 {  }

1.3、接口支持多继承。

1.4、接口中只有 常量 抽象方法。

1.5、接口都是public 修饰的（都是公开的）。

1.6、接口中的抽象方法/常量定义时：public abstract 修饰符可以省略。

interface A{    }interface B{    }interface C extends A,B{    //多继承}interface MyMath{//    public static final double PI = 3.14;     double PI = 3.14;//    public abstract int sum(int a,int b);    int sum(int a,int b);}

2.1、类和类之间叫继承，类和接口之间叫实现（ implements ）。仍可看作"继承"。

2.2、一个类可以实现多个接口。（弥补多继承）

2.3、接口和接口之间进行强制类型转换的时候，没有继承关系，也可以强转。运行时可能出现 ClassCastException 异常。建议使用instanceof。

2.4、一个非抽象类，实现接口的时候，必须将接口中所有的方法实现。

interface MyMat{    double PI = 3.14;    public abstract int sum(int a,int b);    int sub(int a,int b);}class Fa implements MyMat{    //非抽象类，实现接口的时候，必须将接口中所有的方法实现。    @Override    public int sum(int a, int b) {        return a b;    }    @Override    public int sub(int a, int b) {        return a-b;    }    }abstract class Fb implements MyMat{    //抽象类可以不用实现接口中的抽象方法}

interface Aa{    void m1();}interface Bb{    void m2();}interface Cc{    void m3();}class Dd implements Aa,Bb,Cc{    //由于继承，故需要实现继承过来的所有的抽象方法    @Override    public void m3() {        System.out.println("m3");    }    @Override    public void m2() {        System.out.println("m2");    }    @Override    public void m1() {        System.out.println("m1");    }    }class EE implements Aa{    @Override    public void m1() {    }    }public class Test {    public static void main(String[] args) {        Aa t = new EE();//多态//        Bb tt = (Bb)t;     //EE与Bb没关系，但可以强转，不过会抛出异常        System.out.println(t instanceof Bb);//false        if(t instanceof Bb) {            Bb tt1 = (Bb)t;         }    }}

 2.5、继承和实现可以共存。extends 在前， implements 在后。

class Animal{    }//飞翔的接口//接口通常提取的是行为动作interface Flyable{    void fly();}//通过接口插到猫身上，让猫fly；class Cat extends Animal implements Flyable{    @Override    public void fly() {        System.out.println("Cat Fly!!!");    }    }//不想让蛇飞，不去实现接口class Snack extends Animal{    }public class Test {    public static void main(String[] args) {        Flyable f = new Cat();//多态        f.fly();    }}

2.6、接口在开发中的作用：解耦合

　　面向抽象编程，降低耦合度，提高扩展力。

2.7、面向抽象编程，面向接口编程。降低程序耦合度，提高扩展力，符合OCP开发原则。

　　开闭原则（Open-Closed Principle，简称 OCP）说的是：软件实体（类、模块、功能等）应该可以被扩展，但不可被修改。

　　开闭原则中的“开”，是指对于组件功能的扩展是开放的，是允许对其进行功能扩展的；开闭原则中的“闭”，是指对于原有代码的修改是封闭的，即不应该修改原有的代码。

　　开闭原则说白了就是，应该在不修改现有代码的基础上，引入新功能。

2.8、接口使用离不开多态机制。

2.9、抽象类和接口之间的区别：

　　　抽象类是半抽象的。

　　　接口时完全抽象的。

　　　抽象类中有构造方法。　

　　　接口中没有构造方法。

　　　接口和和接口之间支持多继承。

　　　类和类之间只能单继承。

　　　一个类可以实现多个接口。

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

　　　一般接口使用的比抽象类多。接口一般都是对行为的抽象。

2.10、厨师 菜单 顾客的一个例子：

interface FoodMenu{    void a();    void b();}//中餐厨师class Chinacooker implements FoodMenu{    @Override    public void a() {        System.out.println("C做的A菜");    }    @Override    public void b() {        System.out.println("C做的B菜");    }    }//西餐厨师class Americacooker implements FoodMenu{    @Override    public void a() {        System.out.println("A做的A菜");    }    @Override    public void b() {        System.out.println("A做的B菜");    }    }//顾客手里有一个菜单class Customer {    private FoodMenu foodMenu;//    Acooker ac;    这样写就写死了//    Ccooker cc;        public Customer() {        super();    }    public Customer(FoodMenu foodMenu) {        super();        this.foodMenu = foodMenu;    }    public void orderA(){        foodMenu.a();    }         public FoodMenu getFoodMenu() {        return foodMenu;    }    public void setFoodMenu(FoodMenu foodMenu) {        this.foodMenu = foodMenu;    }        }public class Test {    public static void main(String[] args) {        Americacooker zhangsan = new Americacooker();        Customer Arick = new Customer(zhangsan);        Arick.orderA();    }}

View Code

三、类型与类型之间的关系：

　　is a（继承） 、has a（关联） 、 like a（实现）

1.is a ： 

　　Cat is a Animal （猫是一个动物）

　　但凡满足is a 的表示都可以设置为继承。

　　Cat extends Animal{}

2.has a ： 表示关联关系

　　Customer has a FoodMenu （顾客有一个菜单）

　　关联关系通常以属性的形式存在。

　　Customer {　　FoodMenu foodMenu； }

3.like a： 实现关系

　　Cooker like a FoodMenu（厨师像一个菜单一样）（司机像导航）

　　实现关系通常是：类实现接口。

　　Cooker implements B{}

【自行查阅】package和import

来源：https://www.icode9.com/content-4-739451.html