《Java编程思想》读书笔记 第九章 接口

《Java编程思想》读书笔记 第九章 接口

抽象类和抽象方法

抽象方法是不完整的,仅有声明而没有方法体

abstract void f();

包含抽象方法的类叫做抽象类;如果一个类包含一个或多个抽象方法,该类必须被定义为抽象的

如果从一个抽象类继承,并想创建该类的对象,那么就必须为基类中的所有抽象方法提供方法定义;如果不这样做,那么导出类也是抽象类,且编译器会强制我们用abstract关键字来限制这个类

abstract class Instrument {
    private int i;
    public abstract void play(String s);
    public String what() { return "Instrument"; }
}
class Wind extends Instrument {
    public void play(String s) {
        System.out.println("Wind.play()");
    }
}

接口

interface这个关键字产生一个完全抽象的类,它根本就没有提供任何具体实现

要让一个类遵循某个特定接口(或一组接口),需要使用implements关键字

interface Instrument {
    int VALUE = 5;//final && static
    void play(String s);
    void adjust();
}

class Wind implements Instrument {
    public void play(String s) {
        System.out.print("Wind.play()");
    }
    public void adjust() {
        System.out.println(""Wind.adjust()"");
    }
}
  • 接口中的方法默认是public的,不需要显式声明为public的
  • 接口中的任何域都自动时static和final的
  • 当要实现一个接口时,在接口中被定义的方法必须被显式声明为public的,否则只能得到默认的包访问权限

Java中的多重继承

  • 如果从一个非接口的类继承,那么只能从一个类继承
  • 可以继承多个接口
interface CanFight {
    void fight();
}
interface CanSwim {
    void swim();
}
interface CanFly {
    void fly();
}
class ActionCharacter {
    public void fight(){}
}

class Hero extends ActionCharacter 
        implements CanFight, CanSwim, CanFLy {
    public void swim() {}
    public void fly() {}
}

如果要将一个具体类和多个接口组合到一起时,这个具体类必须放在前面,后面跟着的才是接口

如果知道某事物应该称为一个基类,那么第一选择应该是使它成为一个接口

通过继承来扩展接口

interface Monster {
    void menace();
}
interface DangerousMonster extends Monster {
    void destory();
}
interface Lethal {
    void kill();
}
class DragonZilla implements DangerousMonster {
    public void menace() {}
    public void destory() {}
}
interface Vampire extends DangerousMonster, Lethal {
    void drinkBlood();
}
interface VeryBadVampire implements Vampire {
    public void menace() {}
    public void destory() {}
    public void kill() {}
    public void drinkBlood() {]
}

只可以将extends用于单一类,但是可以引用多个接口

嵌套接口

接口可以嵌套在类或者其他接口中

class A {
    interface B {
        void f();
    }
    public class BImp implements B {
        public void f() {]
    }

    private interface D {
        void f();
    }
    private class DImp implements D {
        public void f() {}
    }
}

interface E {
    interface G {
        void f();
    }
    //interface within an interface can't be private
    //private interface H {
        //void f();
    //}
}
public class BImp implements A.B {
    public void f() {}
}

在类中嵌套的接口可以时private的,但是该接口中的方法定义不能添加任何类型信息(不允许向上转型)

在接口中嵌套的接口自动默认为public的,而不能声明为private

接口与工厂

接口是实现多重继承的途径,而生成遵循某个接口的对象的典型方式就是工厂方法

在工厂对象上调用的是创建方法,而该工厂对象将生成接口的某个实现的对象

interface Service {
    void method1();
    void method2();
}
interface ServiceFactory {
    Service getService();
}

class Implementation1 implements Service {
    public Implementation1() {}
    public void method1() {
	System.out.println("Implementation1 method1");
    }
    public void method2() {
	System.out.println("Implementation1 method2");
    }
}
class Implementation1Factory implements ServiceFactory {
    public Service getService() {
	return new Implementation1();
    }
}
class Implementation2 implements Service {
    public Implementation2() {}
    public void method1() {
	System.out.println("Implementation2 method1");
    }
    public void method2() {
	System.out.println("Implementation2 method2");
    }
}
class Implementation2Factory implements ServiceFactory {
    public Service getService() {
	return new Implementation2();
    }
}

public class Factories {
    public static void serviceConsumer(ServiceFactory fact) {
	Service service = fact.getService();
	service.method1();
	service.method2();
    }
    public static void main(String[] args) {
	serviceConsumer(new Implementation1Factory());
	serviceConsumer(new Implementation2Factory());
    }
}

创建的Implementation1Factory类工厂对象,调用getService()方法后,生成了Implementation1对象,而Implementation1类时接口Service的一个实现

编辑于 2017-03-12

文章被以下专栏收录