本文将详细解释java中抽象类和接口之间的异同。文章内容质量较高，边肖分享给大家参考。希望大家看完这篇文章能有所了解。
前言
下面简单介绍抽象类、接口及其异同，并附上简单的代码示例。
00-1010抽象类用于定义Java语言中的抽象类。抽象类不能实例化，也就是说，对象不能用new关键字实例化。抽象类必须包含抽象方法，但抽象类不一定包含抽象方法。如果一个子类实现了父类(抽象类)的所有抽象方法，那么这个子类就不需要是抽象类，否则就是抽象类。抽象类中抽象方法的修饰符只能是公共的或受保护的。
为什么要在抽象类中定义抽象方法？让我们看一个代码示例：
packageexample
import Java . util . date；
publicatabstractclassgeometricobject {
privateStringcolor=' white
privatebooleanfilled
private Java . util . DateDateCreated；
protectedgemetricobject(){ 0
date created=new Java . util . date()；
}//构建默认的几何对象
protectedgemetricobject(StringColor，booleanfiled){ 0
date created=new Java . util . date()；
this.color=color
this.filled=已填充；
}
public stringgetcolor(){ 0
returncolor
}//返回颜色
public void setcolor(StringColor){ 0
this.color=color
}//设置新颜色
publicBooleanGetFilled(){ 0
returnfilled
}
public void setfiled(booleanfiled){ 0
this.filled=已填充；
}
public Java . util . DateGetDateCreated(){ 0
returndateCreated
}
publicatabstractdoublegetarea()；//抽象方法定义获得的区域。
publicatabstractdoublegetperimeter()；//获取周长的抽象方法
}我们假设自定义的Circle类和Rectangle类是GeometricObject的子类，两者都有getArea()方法和getPerimeter()方法来计算各自的面积，但是这些方法不能在父类中定义，因为具体的计算方法取决于GeometricObject的具体类型。因此采用抽象方法进行定义，可以保证父类中的抽象方法可以在子类中重写。
抽象类只定义了，没有实现。
以下是抽象类的一些注意点：
1.抽象方法不能包含在非抽象类中。如果抽象父类的子类不能实现所有的抽象方法，那么子类也必须被定义为抽象的。也就是说，所有的抽象方法都必须在继承自抽象类的非抽象子类中实现。还要注意，抽象方法是静态的。
2.抽象类不能用新运算符初始化。但是您仍然可以定义它的构造函数，该构造函数在其子类的构造函数中被调用。
3.包含抽象方法的类必须是抽象的。但是，可以定义一个没有抽象方法的抽象类，它被用作定义新子类的基类。
4.即使子类的父类是具体的，这个子类也可以是抽象的。
5.您不能使用新运算符从抽象类创建实例，但是抽象类可以用作数据类型。
示例：几何对象[]对象=新的几何对象[10]；是正确的，
6.子类可以覆盖父类的方法，定义为抽象的，这种情况并不常见，但是非常适合父类的方法实现在子类中失效的情况。
00-1010接口是一种类似于类的结构，用于定义对象的公共操作，但其目的是指示相关或不相关类的对象的公共行为。
Java中的接口是用接口关键字修饰的。接口是抽象方法的集合。如果一个类实现了一个接口，它将继承该接口的抽象方法。
类和接口之间的关系称为接口继承。
下面是一个简单的代码示例：
rush:java;">package example;
public class TestEdible {
public static void main(String[] args) {
// TODO Auto-generated method stub
Object[] objects= {new Tiger(),new Chicken(),new Apple()};
//创建由Tiger，Chicken和Apple类型的三个对象构成的数组
for(int i=0;i<objects.length;i++) {
if(objects[i] instanceof Edible)
System.out.println(((Edible)objects[i]).howToEat());
if(objects[i] instanceof Animal) {
System.out.println(((Animal)objects[i]).sound());
}
}//如果可食用，则调用howToEat方法，如果是动物，则调用sound方法
}
}
abstract class Animal{
private double weight;
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight=weight;
}
public abstract String sound();//返回动物的声音，是抽象方法，被具体的animal类实现
}
class Chicken extends Animal implements Edible{
@Override
public String howToEat() {
return "Chicken: Fry it";
}//实现了Edible接口。当一个类实现接口时，该类实现定义在接口中的所有方法。
@Override
public String sound() {
return "Chicken: cock-a-doodle-doo";
}
}
class Tiger extends Animal{
@Override
public String sound() {
return "Tiger:RROOAARR";
}
}
abstract class Fruit implements Edible{
}//Fruit类实现了Edible，但没有实现howToEat方法，所以它必须定义为abstract。
class Apple extends Fruit{
@Override
public String howToEat() {
return "Apple:Make apple cider";
}
}//Fruit的具体子类必须实现howToEat方法，所以Apple类实现了howToEat方法。
需要注意的是，接口中所有的数据域都是public static final，而且所有方法都是public abstract，但Java允许忽略这些修饰符。
即下面的两个代码是等价的：
public interface T {
public static final int K=1;
public abstract void p();
}
public interface T {
int K=1;
void p();
}
尽管public修饰符对于定义在接口中的方法可以省略，但是在子类实现中方法必须定义为public。
三、抽象类和接口的异同点
一个类可以实现多个接口，但是只能继承一个父类。
首先我们先来列举个表格简单讲述一下抽象类和接口之间的异同点：
| 比较点 | 抽象类 | 接口 |
| 关键字 | abstract class | interface |
| 字段 | 无限制 | 变量必须是public static final |
| 方法 | 既可以含普通方法，又可以含抽象方法，无限制 | 只能含抽象方法，且必须是public的 |
| 继承/实现 | 只能被类或抽象类继承 | 既可以被接口继承，也能被类或抽象类实现 |
| 多重继承 | 不支持 | 可以继承多个父接口 |
java只允许为类的继承做单一继承，但是允许使用接口做多重继承。例如：
public class NewClass extends BaseClass implements Interface1,...,InterfaceN{
}
利用extends，接口可以继承其他接口，这样的接口被称为子接口。例如：下面的代码中，NewInterface是Interface1,...,InterfaceN的子接口。
public interface NewInterface extends Interface1,...,InterfaceN{
}
一个实现NewInterface的类必须实现在NewInterface，Interface1,...,InterfaceN中定义的抽象方法。接口可以继承其他接口但不能继承类。一个类可以继承它的父类同时实现多个接口。
所有的类都有一个共同的根类Object，但是接口并没有共同的根。与类相似，接口同样也可以定义一种类型。一个接口类型的变量可以引用任何实现该接口的类的实例。如果一个类实现了一个接口，那么这个接口就类似于该类的一个父类。可以将接口当作一种数据类型使用，将接口类型的变量转换为它的子类，反过来同样可以。
通常情况下，使用接口的频率更高，因为接口比类更加灵活，不用使所有东西都属于同一个类型的类。
下面进行一个简单的代码举例：
abstract class Animal{
public abstract String howToEat();
}//在Animal中定义howToEat方法
//Animal的两个子类定义如下
class Chicken extends Animal{
@Override
public String howToEat() {
return "Chicken: Fry it";
}
}
class Duck extends Animal{
@Override
public String howToEat() {
return "Roast it";
}
}
public static void main(String[] args) {
Animal animal = new Chicken();
eat(animal);
Animal animal = new Duck();
eat(animal);
}
public static void eat(Animal animal){
System.out.println(animal.howToEat());
}
假设给定这个继承结构，java在调用方法时可以根据对象动态地决定调用具体的howToEat方法。但有一个限制条件，即该子类必须是另一种动物才可以。如果一种动物不可食用，那么此刻再继承Animal类就并不合适了。
限制条件这个问题在接口中可以被解决，例如：
public class Demo{
public static void main(String[] args) {
Edible stuff = new Chicken();
eat(stuff);
Edible stuff = new Broccoli();
eat(stuff);
}
public static void eat(Edible stuff){
System.out.println(stuff.howToEat());
}
}
interface Edible{
public String howToEat();
}
class Chicken implements Edible{
@Override
public String howToEat() {
return "Chicken: Fry it";
}
}
class Broccoli implements Edible{
@Override
public String howToEat() {
return "Broccoli: Stir-fty it";
}
}
定义表示可食用对象的一个类，只须让该类实现Edible接口即可。任何Edible对象都可以被传递以调用HowToEat方法。
关于java中抽象类和接口的相同和不同点是什么就分享到这里了，希望
内容来源网络，如有侵权，联系删除，本文地址：https://www.230890.com/zhan/153083.html