《THING IN JAVA》 9章接口-读书笔记_当必需时,你应该重构接口而不是到处添加额外级别的间接性-CSDN博客

本文链接：https://blog.csdn.net/zeng8129/article/details/53968507

1、抽象类和抽象方法（关键字abstract）

（1）包含抽象方法的类叫做抽象类，如果一个类包含一个或多个抽象方法，该类必须被限定为抽象的。（否则，编译器会报错）

（2）声明为抽象类的类无法实例化。（否则，编译器会报错），当然一个声明为抽象的类也可以不包含任何抽象方法，如果你想一个类不会被实例化，声明为抽象得非常实用

（3）如果一个类继承一个抽象类，那么就必须为所有方法提供实现定义，否则该类也会定义为抽象的，接口也是一样的，如果一个类实现接口而不提共全部实现方法则必须声明为抽象类。

（4）抽象类中的抽象方法不可以声明为private的，否则就没有可能提供实现的方法体。（否则，编译器会报错）

2、接口

（1）interface这个关键字产生一个完成抽象的类

（2）在接口中，所有变量都会只能（默认）为 public static final 来修饰，所有的方法都会只能（默认）public abstrace 来修饰，内部类，接口只能（默认）为public 修饰。（否则，编译器会报错）

（3）在接口中定义的域不能是“空final”，但是可以被非常量表达式初始化（域为static final 都不允许不被初始化。即”空final“。

下面证明接口中的变量是静态的：

public interface MyTest1 {
int I = 88;
}

public class MyTest2 {
public static void main(String[] args){
System.out.println(MyTest1.I);
}
}

输出：

3、完全解耦

（1）创建一个能够根据所传递的参数对象的不同而具有不同行为的方法，被称为策略设计模式（在后面的工厂模式会显示）

（2）创建一个适配器将代码转为你所拥有的接口，并产生你所需要的接口，被称为适配器设计模式

（3）将接口从具有实现中解耦使得接口可以用于多种不同的具体实现，因此代码也就更具可复用性

4、Java中的多重继承

（1）使用接口的两个原因

1.1为了能够向上转型为多个基类

1.2防止程序员创建该类的对象

（2）接口是多继承的，一般情况下，只可以将extends用于单一类，但是可以引用多个基类接口。就像所看到的，只需用逗号将借口命一一分割开即可

（3）组合接口时，出现名字冲突的情况，如下面这种情况

public interface MyTest1 {
int I = 88;
void f();
}

public class MyTest3 {
String f(){
return null;
}
}

public class MyTest4 extends MyTest3 implements MyTest1{

}

结果：编译报错，因为这样方法的重写与方法的重载并存，如上述例子，重载方法仅通过返回类型是分不开的。（遵循方法重写与方法重载的原则）

在打算组合的不同接口中使用相同的方法名通常会造成代码可读性的混乱，请尽量避免这种情况。

5、嵌套接口

（1）类和接口也可以用private，protected来修饰，但是一般存在于内部（内部类，内部接口）的，这些接口或类符合它们各自的规则，

如：

public interface MyTest7 {
interface A{

}
}

内部接口A只能用public修饰

（2）下面是一个内部接口的实例：

public class MyTest5 {
private interface A{
void f();
}
private class B{}
public class C implements A{
public void f(){};
}

public A getA(){
return new C();
}

public void receiveA(A a){
a.f();
}
}

public class MyTest6 {
public static void main(String[] args){
MyTest5 m = new MyTest5();
m.getA().f(); //1
m.receiveA(m.getA()); //2
}
}

结果：1处会编译错误，由于类C的方法f()是实现私有接口的，所以MyTest6这个类没有权限使用这个f()方法，只有MyTest5类才有权限使用这个方法，所以2成功了调用了该反法，交给了有使用f()方法权限的类MyTest6

如果了解这种特性，就总能够找到它的用武之地

6、接口与工厂

生成遵循某个接口的对象的典型方式就是工厂方法设计模式（一接口，一工厂类），下面是一个工厂的方法实例：

public class Factories {
public static void main(String[] args){
action(new UnicycleFactory());
action(new BicycleFactory());
action(new TricycleFactory());
}

public static void action(CycleFactory cf){ //调用工厂接口
Cycle c = cf.getCycle();
c.play();
}
}

interface Cycle{ //接口
void play();
}

interface CycleFactory{ //接口工厂
Cycle getCycle();
}

class Unicycle implements Cycle{ //类1
public void play() {
System.out.println("1");
}
}

class UnicycleFactory implements CycleFactory{ //类1工厂方法
public Cycle getCycle() {
return new Unicycle();
}
}

class Bicycle implements Cycle{ //类2
public void play() {
System.out.println("2");
}
}

class BicycleFactory implements CycleFactory{ //类2工厂方法
public Cycle getCycle() {
return new Bicycle();
}
}

class Tricycle implements Cycle{ //类3
public void play() {
System.out.println("3");
}
}

class TricycleFactory implements CycleFactory{ //类3工厂方法
public Cycle getCycle() {
return new Tricycle();
}
}