Java中的抽象类与接口，在阿里工作5年了-阿里云开发者社区

Java中的访问权限控制

Java中的复用类

Java中的多态

Java中的抽象类与接口

Java中的内部类

Java中的容器

接口和内部类为我们提供了一种接口与实现分离的更加结构化的方法；不同的子类可以用不同的方式表示此接口。通接口建立起一种基本形式，以此表示所有导出类的共同部分；

1.1 抽象类和抽象方法

想要学习接口，首先需要了解抽象类，它是普通的类与接口之间的一种中庸之道；因为不可能总是使用纯接口，所以抽象类仍旧有着重要的作用。

Java提供一个叫做抽象方法的机制，这种方法是不完整的；仅有声明而没有方法体。语法如下：abstract void f();包含抽象方法的类叫做抽象类。创建抽象类和抽象方法非常有用，因为它们可以使类的抽象性明确起来，并告诉用户和编译器打算怎样来使用它们。抽象类还是很有用的重构工具，因为它们使得我们可以很容易地将公共方法沿着继承层次结构向上移动。

例：

abstract class Rodent {
private String name = “Rodent”;
abstract protected void eat();
abstract protected void run();
abstract protected void sleep();
abstract public String toString();
}
class Mouse extends Rodent {
private String name = “Mouse”;
protected void eat() {
System.out.print("Mouse.eat() "); }
protected void run() {
System.out.print("Mouse.run() "); }
protected void sleep() {
System.out.print("Mouse.sleep() "); }
public String toString() { return name; }
}
class Rat extends Rodent {
private String name = “Rat”;
protected void eat() {
System.out.print("Rat.eat() "); }
protected void run() {
System.out.print("Rat.run() "); }
protected void sleep() {
System.out.print("Rat.sleep() "); }
public String toString() { return name; }
}
class Squirrel extends Rodent {
private String name = “Squirrel”;
protected void eat() {
System.out.print("Squirrel.eat() "); }
protected void run() {
System.out.print("Squirrel.run() "); }
protected 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()

总结：

抽象方法：前面由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();
}

需要zi料+ 绿色徽【vip1024b】

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 使用接口的核心原因：

总结

虽然面试套路众多，但对于技术面试来说，主要还是考察一个人的技术能力和沟通能力。不同类型的面试官根据自身的理解问的问题也不尽相同，没有规律可循。

Java中的抽象类与接口，在阿里工作5年了

总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景