Java中的抽象类与接口，zookeeper学习

总结：

抽象方法： 前面由abstract声明，只要方法体，没有具体实现

抽象类： 含有一个或多个抽象方法的抽象类，但一般不包括全部都是抽象方法，全部都是抽象方法接下来会介绍是接口；抽象类需要使用abstract声明

注意：

• 1.如果一个类包含一个或多个抽象方法，该类必须被限定为抽象类。(否则，编译器就会报错。)

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

• 3.抽象类并不需要所有的方法都是抽象的，只要有一个抽象方法就是抽象类

• 4.抽象类可以被继承，但不能创建对象，导出类必须实现所有的抽象方法，否则仍然是抽象类，且必须加abstract声明

1.2 接口

interface关键字使抽象方法的概念更向前迈进了一步。abstract关键字允许人们在类中创建一个或多个没有任何定义的方法–提供了接口部分，但是没有提供任何任何相应的具体实现，这些实现是由此类的继承者创建的。

interface这个关键字产生一个完全抽象的类，它根本没有提供任何具体实现。它允许创建者确定方法名、参数列表和返回类型，但是没有任何方法体。接口只提供了形式，而未提供任何具体实现。任何使用某特定接口的代码都知道可以调用该接口的哪些方法，而且仅需知道这些。因此，接口被用来建立类与类之间的协议。

要想创建一个接口，需要用interface关键字来替代calss关键字，就像类一样，可以在interface关键字前面添加public关键字。如果不添加public关键字，则它只具有包访问权限，这样就只能在同一个包内可用。接口也可以包含域，但是这些域隐式的是static和final的。要让一个类遵循某个特定接口(或者是一组接口),需要使用implements关键字，它表示：“interface只是它的外貌，但是现在我要声明它是如何工作的”，除此之外，它看起来还很像继承。

例：

interface Rodent {

String name = “Rodent”;

void eat();

void run();

void sleep();

String toString();

}

class Mouse implements Rodent {

private String name = “Mouse”;

public void eat() {

System.out.print(“Mouse.eat()”); }

public void run() {

System.out.print(“Mouse.run()”); }

public void sleep() {

System.out.print(“Mouse.sleep()”); }

public String toString() { return name; }

}

class Rat implements Rodent {

private String name = “Rat”;

public void eat() {

System.out.print(“Rat.eat()”); }

public void run() {

System.out.print(“Rat.run()”); }

public void sleep() {

System.out.print(“Rat.sleep()”); }

public String toString() { return name; }

}

class Squirrel implements Rodent {

private String name = “Squirrel”;

public void eat() {

System.out.print(“Squirrel.eat()”); }

public void run() {

System.out.print(“Squirrel.run()”); }

public void sleep() {

System.out.print(“Squirrel.sleep()”); }

public String toString() { return name; }

}

public class RodentTest {

public static void main(String[] args) {

Rodent[]rodents={ new Mouse(), new Rat(), new Squirrel()};

for(Rodent r : rodents) {

System.out.println("\n"+r.toString()+"😊;

r.eat();

r.run();

r.sleep();

}

}

}

Output:

Mouse:

Mouse.eat()Mouse.run()Mouse.sleep()

Rat:

Rat.eat()Rat.run()Rat.sleep()

Squirrel:

Squirrel.eat()Squirrel.run()Squirrel.sleep()

1.3 完全解耦

只要一个方法操作的是类而非接口，那么你就只能使用这个类及其子类。如果想要将这个方法应用于不在此继承结构中的某个类，那就会出现问题。接口可以在很大程度上放宽这种限制，因此，它使得我们可以编写可复用性更好的代码。将接口从具体实现中解耦使得接口可以应用于多种不同的具体实现，因此代码也就更具有可复用性。

继承与接口

---

2.1 Java中的多重继承

接口不仅仅是一种更纯粹形式的抽象类，接口没有任何具体实现–也就是说，没有任何与接口相关的存储；因此，也就无法阻止多个接口的组合。组合多个类的接口的行为被称作多重继承，在Java中，可以执行多重继承，但是只有一个类可以有具体实现；

在导出类中，不强制要求必须有一个是抽象的或“具体的”基类。如果要从一个非接口的类继承，那么只能从一个类去继承，其余的基元素必须是接口。需要将所有的接口名都置于implements关键字之后，用逗号将它们一一隔开。可以继承任意多个接口，并可以向上转型为每个接口，因为每个接口都是一个独立类型。

下面例子展示了一个具体类组合数个接口之后产生一个新类：

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{

@Override

public void swim() {}

@Override

public void fly() {}

}

public class Adventure {

public static void t(CanFight x){x.fight();}

public static void u(CanSwim x){x.swim();}

public static void v(CanFly x){x.fly();}

public static void w(ActionCharacter x){x.fight();}

public static void main(String[] args) {

Hero hero=new Hero();

t(hero);

u(hero);

v(hero);

w(hero);

}

}

Hero组合了具体类ActionCharacter和接口CanFight、CanSwim和CanFly。当通过这种方式讲一个具体类和多个接口组合到一起时，这个具体类必须放在前面，后面跟着的才是接口。

2.2 使用接口的核心原因：

• 1.为了能够向上转型为多个基类型(以及由此带来的灵活性)；

• 2.防止客户端程序员创建该类的对象，并确保这仅仅是建立一个接口(这与使用抽象类原因相同)

2.3 通过继承来扩展接口

通过继承，可以很容易地在接口中添加新的方法声明，还可以通过继承在新接口中组合数个接口，这两种方式都可以获得新的接口。

interface Monster{

void menace();

}

【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】

浏览器打开：qq.cn.hn/FTf 免费领取

interface DangerousMonster extends Monster{

void destroy();

}

interface Lethal{

void kill();

}

class Dragon implements DangerousMonster{

@Override

public void menace() {}

@Override

public void destroy() {}

}

interface Vampire extends DangerousMonster,Lethal{

void drinkBlood();

}

class VeryBadVampire implements Vampire{

@Override

public void menace(){}

@Override

public void destroy(){}

@Override

public void kill(){}

@Override

public void drinkBlood(){}

}

public class HorrorShow {

static void u(Monster b){b.menace();}

static void v(DangerousMonster d){

d.menace();

d.destroy();

}

static void w(Lethal l){l.kill();}

public static void main(String[] args) {

DangerousMonster barney=new Dragon();

u(barney);

v(barney);

Vampire vlad=new VeryBadVampire();

u(vlad);

v(vlad);

w(vlad);

}

}

DangerousMonster是Monster的直接扩展，它产生了一个新接口。Dragon中实现了这个接口；

在Vampire中使用的语法仅适用于接口继承，一般情况下，只可以将extends用于单一类，但是可以引用多个基类接口，只需用逗号将接口名一一分隔开即可。

2.4 适配接口

接口最吸引人的原因之一就是允许同一个接口具有多个不同的具体实现。在简单的情况中，它的体现形式通常是一个接受接口类型的方法，而该接口的实现和向该方法传递的对象则取决于方法的使用者。

使用接口，你主要就是要声明：“你可以用任何你想要的对象来调用我的方法，只要你的对象遵循我的接口”。这使得方法更加灵活、通用，并更具有可复用性。我们可以再任何有类之上添加新的接口，所以这意味着让方法接受接口类型，是一种让任何类都可以对该方法进行适配的方式。这就是使用接口而不是类的强大之处。

2.5 接口中的域

因为放入接口中的任何域都是static和final的，所以接口就成为了一种很便捷的用来创建常量组的工具。在接口定义的域不能是 “空final”，但是可以被非常量表达式初始化。

2.6 嵌套接口

接口可以嵌套在类或其他接口中。例：

class A{

interface B{

void f();

}

public class BImp implements B{

@Override

public void f() {}

}

private class BImp2 implements B{

public void f(){}

}

public interface C{

void f();

}

class CImp implements C{

@Override

public void f() {}

}

private class CImp2 implements C{

@Override

public void f() {}

}

public interface D{

void f();

}

class DImp implements D{

@Override

public void f() {}

}

private class DImp2 implements D{

@Override

public void f() {

}

}

public D getD(){

return new DImp2();

}

private D dRef;

public void receiveD(D d){

dRef=d;

dRef.f();

}

}

interface E{

interface G{

void f();

}

public interface H{

void f();

}

void g();

}

public class NestingInterfaces {

public class BImp implements A.B {

@Override

public void f() {}

class CImp implements A.C{

@Override

public void f() {}

}

class EImp implements E{

@Override

public void g() {}

}

class EGImp implements E.G{

@Override

public void f() {}

}

class EImp2 implements E{

@Override

public void g() {}

}

class EG implements E.G{

@Override

public void f() {}

}

}

public static void main(String[] args){

A a=new A();

A.D ad=a.getD();

}

}

在类中嵌套接口的语法是相当显而易见的，就像非嵌套接口一样，可以拥有public和 “包访问” 两种可视性。

接口与工厂

---

接口是实现多重继承的途径，而生成遵循某个接口的对象的典型方式就是工厂方法设计模式。这与直接调用构造器不同，在工厂对象上调用的是创建方法，而该工厂对象将生成接口的某个实现的对象。

理论上，通过这种方式，我们的代码将完全与接口的实现分离，这就使得我们可以透明地将某个实现替换为另一个实现。下面的实例展示了工厂方法的结构：

interface Service{

void method1();

void method2();