个人中心
gpt4 book ai didi

Java 抽象类与接口的对比

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 25 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Java 抽象类与接口的对比由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

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

首先是语法层面上的对比 。

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

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

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

　　综上所述，抽象类中的抽象方法只能用public和protected修饰.

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

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

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

其次是概念上的比较 。

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

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

?
1
2
3
public abstract class Flyer {
   public abstract void fly();
}

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

?
1
2
3
4
5
6
7
public class Airplane extends Flyer {
 
   @Override
   public void fly() {
     System.out.println( "Airplane is flying." );
   }
}
?
1
2
3
4
5
6
7
public class Bird extends Flyer {
 
   @Override
   public void fly() {
     System.out.println( "Bird is flying." );
   }
}

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

?
1
2
3
4
5
6
7
8
9
10
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类就无法再继承其他类了，这样就反而限制了程序的灵活性。所以，这种时候，还是比较适合使用接口:

?
1
2
3
4
public interface IFlyable {
   //声明Fly方法
   void fly();
}

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

?
1
2
3
4
5
6
7
8
public class Airplane implements IFlyable {
 
   //实现Fly方法
   @Override
   public void fly() {
     System.out.println( "Airplane is flying." );
   }
}
?
1
2
3
4
5
6
7
public class Bird implements IFlyable {
   //实现Fly方法
   @Override
   public void fly() {
     System.out.println( "Bird is flying." );
   }
}

　　再修改一下Test类:

?
1
2
3
4
5
6
7
8
9
10
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. 。

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

?
1
2
3
4
5
public interface ICarryPassenger {
 
   //声明载客方法
   void carry(Passenger passenger);
}

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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接口（虽然没有用到。。）:

?
1
2
3
4
5
6
7
8
9
10
11
12
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." );
   }
}
?
1
2
3
4
5
6
7
8
9
10
11
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." );
   }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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." );
   }
}

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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. 。

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

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

以上就是Java 抽象类与接口的对比的详细内容，更多关于Java 抽象类与接口的资料请关注我其它相关文章！ 。

原文链接：https://cloud.tencent.com/developer/article/1016598 。

最后此篇关于Java 抽象类与接口的对比的文章就讲到这里了,如果你想了解更多关于Java 抽象类与接口的对比的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

25 4 0
文章推荐： 仿IOS的越界回弹效果和左右滑动功能
文章推荐： 详细分析Java内部类——局部内部类
文章推荐： Unity3D实验室之iOS真机闪退的解决方法
文章推荐： 利用Java反射机制实现对象相同字段的复制操作
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com