【保姆级教程】一篇让你学会——JAVA之抽象类和接口异同点

catalogue

Part one.抽象类

Tip1.了解抽象类

Tip2.几点说明

Tip3.试试吧~

Tip4.抽象类的应用

Part two.接口

Tip1.了解接口

Tip2.接口的意义

Tip3.接口的定义

Tip4.接口的实际运用

Part3.比较接口与抽象类

---

Part one.抽象类

Tip1.了解抽象类

        要点：抽象类不可以用于创建对象。抽象类可以包含抽象方法，这些方法将在具体的子类中实现。

       在继承的层次结构中，每个新的子类都使类变得更加明确和具体。如果从一个子类向父类追溯，类就会变得更通用、更加不明确。类的设计应该确保父类包含它的子类的共同特征。有时候，一个父类设计得非常抽象，以至于它都没有任何具体的实例。例如，动物作为一个基类可以派生出猫、狗等子类，但动物类本身生成对象明显不合常理。这样的类称为抽象类。在类的头部使用abstract修饰。

例：比较普通方法和抽象类

（在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。）

abstract class A{//定义一个抽象类
	
	public void fun(){//普通方法
		System.out.println("存在方法体的方法");
	}
	
	public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
	
}

例：抽象方法的声明格式

【抽象方法只有声明没有实现，即没有方法体】

abstract void fun();

Tip2.几点说明

• 抽象方法不能包含在非抽象类中。如果抽象父类的子类不能实现所有的抽象方法，那么子类也必须定义为抽象的。抽象方法是非静态的。
• 抽象类不能使用new操作符来初始化。但是，仍然可以定义它的构造方法，这个构造方法在它的子类的构造方法中调用。
• 子类可以重写父类的方法并将它定义为抽象的。
• 即使子类的父类是具体的，这个子类也可以是抽象的。
• 不能使用new操作符从一个抽象类创建一个实例，但是抽象类可以用作一种数据类型。
• 派生类继承抽象类必须实现抽象类中所有的抽象方法，否则派生类也必须定义为抽象类。

Tip3.试试吧~

//单继承
class B extends A{//B类是抽象类的子类，是一个普通类

	@Override
	public void print() {//强制要求覆写

		System.out.println("Hello World !");

	}
	
}
public class TestDemo {

	public static void main(String[] args) {

		A a = new B();//向上转型
		
		a.print();//被子类所覆写的过的方法
	}
}

运行结果：

Hello World !

Tip4.抽象类的应用

参考某博主链接在这里：抽象类理解

例如，现在有两类事物：
（1）人：吃饭，工作，睡觉；
（2）猪：进食，睡觉。
现要求实现一个程序，可以实现两种不同事物的行为。

先定义一个抽象行为类：

public abstract class Action{
	
	public static final int EAT = 1 ;
	public static final int SLEEP = 3 ;
	public static final int WORK = 5 ;
	
	public abstract void eat();
	public abstract void sleep();
	public abstract void work();
	
	public void commond(int flags){
	  switch(flags){
		case EAT:
			this.eat();
			break;
		case SLEEP:
			this.sleep();
			break;
		case WORK:
			this.work();
			break;
		case EAT + SLEEP:
			this.eat();
			this.sleep();
			break;
		case SLEEP + WORK:
			this.sleep();
			this.work();
			break;
		default:
			break;
		}
	}
}

定义一个人的类：

public class Human extends Action{

	@Override
	public void eat() {
		System.out.println("人吃饭");
	}

	@Override
	public void sleep() {
		System.out.println("人睡觉");
	}

	@Override
	public void work() {
		System.out.println("人工作");
	}
}

定义一个猪🐖的类：

public class Pig extends Action{

	@Override
	public void eat() {
		System.out.println("猪进食");	
	}

	@Override
	public void sleep() {
		System.out.println("猪睡觉");	
	}

	@Override
	public void work() {		
		
	}	
}

测试主类：

public class AbstractDemo {

	public static void main(String[] args) {
		
		fun(new Human());	
		fun(new Pig());

	}
	
	public static void fun(Action act){
		act.commond(Action.EAT);
		act.commond(Action.SLEEP);
		act.commond(Action.WORK);
	}
}

运行结果：

人吃饭

人睡觉

人工作

猪进食

猪睡觉

---

Part two.接口

Tip1.了解接口

       要点：接口是一种与类相似的结构，用于为对象定义共同的操作。其目的是指明相关或者不想管类的对象的共同行为。  

       Java中的接口是一系列方法的声明，可以看做是特殊的抽象类，包含常量和方法的声明，而没有变量和方法的实现。（即只有方法标识符，而没有方法体）。

为了区分接口和类，采用下面的语法来定义接口：

modifier interface InterfaceName{
  /** Constant declarations */
  /** Abstract method signatures */
}

下面是一个接口的例子：

public interface Edible {
  /** Describe how to eat */
  public abstract String 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();

}

Tip2.接口的意义

• 弥补Java中单继承机制的不足。
• 接口只有方法的定义没有方法的实现，即都是抽象方法，这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

Tip3.接口的定义

interface 接口名称 {
               常量
               抽象方法
}

interface A{//定义一个接口

    public static final String MSG = "hello";//全局常量
    public abstract void print();//抽象方法
}

类可以通过实现接口的方式来具有接口中定义的功能，基本语法：

class 类名 implements 接口名 {

}

• 一个类可以同时实现多个接口。
• 一个接口可以被多个无关的类实现。
• 一个类实现接口必须实现接口中所有的抽象方法，否则必须定义为抽象类。

Tip4.接口的实际运用

参考某博主链接放这里：接口详解

现在假设每一个USB设备只有两个功能：安装驱动程序、工作。

定义一个USB的标准：

interface USB {   // 操作标准       
    public void install() ;
    public void work() ;
}

在电脑上应用此接口：

class Computer {
   public void plugin(USB usb) {
          usb.install() ;
          usb.work() ;
   }
}

定义USB设备——手机：

class Phone implements USB {
     public void install() {
           System.out.println("安装手机驱动程序。") ;
     }
     public void work() {
           System.out.println("手机与电脑进行工作。") ;
     }
}

定义USB设备——MP3：

class MP3 implements USB {
      public void install() {
           System.out.println("安装MP3驱动程序。") ;
      }
      public void work() {
           System.out.println("进行MP3拷贝。") ;
      }
}

测试主类：

public class TestDemo {
    public static void main(String args[]) {
        Computer c = new Computer() ;
        c.plugin(new Phone()) ;
        c.plugin(new MP3());
    }
}

测试结果：

安装手机驱动程序。

手机与电脑进行工作。

安装MP3驱动程序。

进行MP3拷贝。

---

Part3.比较接口与抽象类

	变量	构造方法	方法
抽象类	无限制	子类通过构造方法链调用构造方法，抽象类不能用new操作符实例化	无限制
接口	所有的变量必须是public static final	没有构造方法。接口不能用new操作符实例化	可以包含public的抽象实例方法、public的默认方法以及public的静态方法

       接口与抽象类

Java只允许为类的继承做单一继承，但是允许使用接口做多重继承。例如：

public class NewClass extends BaseClass
    implements Interface1,...,InterfaceN {
...
}

利用关键字extends，接口可以继承其他接口。这样的接口称为子接口（subinterface）。例如，以下代码，NewInterface是I内特容法测，...，InterfaceN的子接口。

public interface NewInterface extends Interface1,...,InterfaceN {
  //constants and abstract methods
}

       通常，推荐使用接口而非抽象类，因为接口可以为不相关类定义共同的父类型。接口比类更加灵活。然而接口不能包含数据域。

       所以，在开发之中，抽象类和接口实际上都是可以使用的，并且使用那一个都没有明确的限制，可是抽象类有一个最大的缺点 ： 一个子类只能够继承一个抽象类，存在单继承的局限。所以当遇到抽象类和接口都可以使用的情况下，优先考虑接口，避免单继承局限。

酱酱！！以上是我的接口和抽象类的全部学习内容~