【Java入门提高篇】Day3 抽象类与接口的比较

﹏ヽ暗。殇╰゛Y 2021-09-28 08:28 157阅读 0赞

[抽象类][Link 1]跟接口都讲完了，现在来[做一个比较][Link 1]。

其实说实话，[没有多大的可比较性][Link 1]，它们是完全不同的两个东西，它们的[抽象][Link 1]不在同一个层级上。但是为了让大家更好的理解，还是做一个比较吧，毕竟它们都很抽象（233）。

首先是语法层面上的对比

[1）抽象类跟接口都不能被实例化，因为它们都很虚嘛。][Link 1]但是在访问权限上，两者有一定的区别。

a、抽象类中的抽象方法（其前有abstract修饰）不能用[private][Link 1]、[static][Link 1]、[synchronized][Link 1]、[native][Link 1]访问修饰符修饰。理由很简单，容我慢慢道来。

抽象方法是没有方法体的，它的目的就是用来继承的，所以如果使用private修饰，不就不能被继承了吗？这就违背了它的设计初衷了，所以不能用private来修饰抽象方法。至于static，用它来修饰的方法可以不实例化就可以直接调用，但是抽象方法没有方法体，使用static修饰就没有意义了。synchronized是用来加锁的，如果修饰类中的方法的话，就相当于用this变量锁，但是抽象类是不能被实例化的，抽象方法也不是在本类中实现而是在子类中实现的，所以锁应该是子类所属，所以抽象方法不能用synchronized关键字修饰；至于native，这个跟abstract关键字本身就是冲突的，abstract声明方法交给子类实现，而native则是交给本地操作系统实现，如果同时出现，那就相当于把实现交给子类，又交给本地操作系统，那最后到底由谁来实现呢？

综上所述，抽象类中的抽象方法只能用[public][Link 1]和[protected][Link 1]修饰。

b.接口中的方法全部为[public abstract][Link 1]修饰，不能使用其他修饰符，而且默认情况（不加任何修饰符）下，也是[public abstract][Link 1]的，因为接口只能被类实现，不能被类继承，所以不能使用[protected修饰][Link 1]，但接口是可以继承接口的。

2）抽象类跟普通类的唯一区别就是不能被实例化，可以有抽象方法，所以它可以有构造函数，静态方法，静态代码块，可以有普通的成员变量和方法。但是接口就不一样了，接口只能声明public abstract的方法和public static final的成员变量。

3）抽象类本质上还是一个类，只能[单继承][Link 1]，一个类只能继承一个抽象类，但可以实现多个接口。

其次是概念上的比较

1）抽象类跟接口的抽象角度不一样，抽象类一般是对某些具有相似属性和方法的类进行抽象，抽象出一个统一的父类。而接口则更多的是多一组特定行为的抽象，关注的是行为，而具有这些行为的类之间可能并没有太大的关联性。

比如说，飞机能上天，鸟能上天，你要是厉害一点，应该也能上天（逃），但显然两者之间的关联度不大，如果硬是要给它们插上一个公共的父类的话，似乎不合情理，看起来就像这样：

public abstract class Flyer \{

public abstract void fly();

然后定义两个类来继承它：

public class Airplane extends Flyer \{

@Override

public void fly() \{

System.out.println("Airplane is flying.");

public class Bird extends Flyer \{

@Override

public void fly() \{

System.out.println("Bird is flying.");

好的，现在写一个测试类：

public class Test \{

public static void main(String\[\] args) \{

Flyer\[\] flyer = new Flyer\[2\];

flyer\[0\] = new Airplane();

flyer\[1\] = new Bird();

for (Flyer f:flyer)\{

f.fly();

运行结果如下：

Airplane is flying.

Bird is flying.

乍眼一看，好像运行良好，但是仔细想想，将两个关联度很低的类强行插上一个父类，似乎有些不妥，毕竟飞机跟鸟除了都能飞以外，基本没有什么相似的地方了，而且两者的飞行方式，飞行速度和高度都相去甚远，也就是说除了这个fly的方法，其他方法都要在各自的子类实现，而且一个类只能继承一个抽象类，所以Bird类和Airplane类就无法再继承其他类了，这样就反而限制了程序的灵活性。所以，这种时候，还是比较适合使用接口：

public interface IFlyable \{

//声明Fly方法

void fly();

而此时只需要将Airplane类和Bird类的extends Flyer改成implement Flyable即可。

public class Airplane implements IFlyable \{

//实现Fly方法

@Override

public void fly() \{

System.out.println("Airplane is flying.");

public class Bird implements IFlyable \{

//实现Fly方法

@Override

public void fly() \{

System.out.println("Bird is flying.");

再修改一下Test类：

public class Test \{

public static void main(String\[\] args) \{

IFlyable\[\] flyer = new IFlyable\[2\];

flyer\[0\] = new Airplane();

flyer\[1\] = new Bird();

for (IFlyable f:flyer)\{

f.fly();

输出如下：

Airplane is flying.

Bird is flying.

也许从这个栗子还没法明显的看出两者的区别，那么我们再换一个栗子，人可以坐飞机，可以坐火车，还可以坐汽车，只要它们有载人功能即可，那用接口实现如下：

public interface ICarryPassenger \{

//声明载客方法

void carry(Passenger passenger);

定义一个乘客类，用姓名来区分各个乘客。

public class Passenger \{

private String name;//乘客姓名

public Passenger(String name)\{

this.name = name;

public String getName() \{

return name;

//出行方式

public void travelBy(ICarryPassenger ic)\{

ic.carry(this);

分别定义汽车类，火车类，飞机类，它们都实现ICarryPassenger接口，飞机还可以实现IFlyable接口（虽然没有用到。。）：

public class Car implements ICarryPassenger \{

int passengerNum;

//实现carry方法

@Override

public void carry(Passenger passenger) \{

System.out.println("Passenger:"+passenger.getName()+" travel by Car.");

passengerNum++;

System.out.println("Car carries: "+passengerNum+" passenger.");

public class Train implements ICarryPassenger \{

int passengerNum;

@Override

public void carry(Passenger passenger) \{

System.out.println("Passenger:"+passenger.getName()+" travel by Train.");

passengerNum++;

System.out.println("Train carries: "+passengerNum+" passenger.");

public class Airplane implements IFlyable,ICarryPassenger\{

private int passengerNum;//乘客数量

//实现Fly方法

@Override

public void fly() \{

System.out.println("Airplane is flying.");

//实现carry方法

@Override

public void carry(Passenger passenger) \{

System.out.println("Passenger:"+passenger.getName()+" travel by Airplane.");

passengerNum++;

System.out.println("Airplane carries: "+passengerNum+" passengers.");

好的，现在我们写一个测试类来进行测试：

public class Test \{

public static void main(String\[\] args) \{

//有6个乘客想要去旅游，对于旅行方式没有侧重，随机分配交通工具

Random random = new Random();

Passenger\[\] passengers = new Passenger\[6\];//声明6个乘客

for (int i=0;i<6;i++)\{

passengers\[i\] = new Passenger("Passenger\["+i+"\]");

ICarryPassenger\[\] icp = new ICarryPassenger\[3\];//声明3种交通方式

icp\[0\] = new Airplane();

icp\[1\] = new Car();

icp\[2\] = new Train();

for (int i=0;i<6;i++)\{

passengers\[i\].travelBy(icp\[random.nextInt(3)\]);

输出如下：

Passenger:Passenger\[0\] travel by Airplane.

Airplane carries: 1 passengers.

Passenger:Passenger\[1\] travel by Train.

Train carries: 1 passenger.

Passenger:Passenger\[2\] travel by Airplane.

Airplane carries: 2 passengers.

Passenger:Passenger\[3\] travel by Car.

Car carries: 1 passenger.

Passenger:Passenger\[4\] travel by Train.

Train carries: 2 passenger.

Passenger:Passenger\[5\] travel by Airplane.

Airplane carries: 3 passengers.

因为飞机跟火车，汽车之间并没有太大关联，显然无法直接抽象出父类，它们仅有相同的行为，那就是载客，所以使用接口是最合适的。

至此，本篇讲解完毕，想必通过这一篇的讲解，对于抽象类和接口的区别应该有了更好的理解吧，如果有更好的栗子，欢迎大家留言交流，也欢迎大家继续关注。

\---------------------

作者：弗兰克的猫\_\_

来源：CSDN

原文：[https://blog.csdn.net/MFrank2018/article/details/80296838][Link 1]

[Link 1]: http://c7.gg/fx7d3

【Java入门提高篇】Day3 抽象类与接口的比较

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关面向对象编程：Java中的抽象类与接口比较

相关 Java抽象类与接口

相关浅析JAVA抽象类和接口的比较

相关 Java 进阶之抽象类与接口比较（二）

相关抽象类与接口比较

相关 [Java] 抽象类与接口

相关 java提高篇（四）-----抽象类与接口

相关【Java入门提高篇】Day6 Java内部类——成员内部类

相关【Java入门提高篇】Day3 抽象类与接口的比较

相关浅析JAVA抽象类和接口的比较