Java-抽象类和接口的区别及其使用场景

一、抽象类

一直不太理解为什么要使用抽象类，实际所有使用抽象类的实现都可以用普通类代替，昨晚突发奇想，把这块深入的啃一下。

看到一个很好的例子，由此例子做进一步剖析。比如公司有工程师，管理员。二者都有姓名（name），工号（id），工资（pay）的属性，二者也有同样的方法，工作（work）。但不一样的是管理员属性会多一项奖金（bouns），而且虽然二者都有同样的方法，工作，但工作内容不一样。

这个时候，如果用普通类实现，工程师和管理员只能是分别写一个类去实现，可读性不好

 

在讲抽象类之前有必要强调一下abstract修饰符：

     1.abstract修饰的类为抽象类，此类不能有对象，（无法对此类进行实例化）；

     2.abstract修饰的方法为抽象方法，此方法不能有方法体（为空）

1.整体实现步骤

1) 创建抽象类Employee包含了属性和空方法

2) 创建普通类继承抽象类，并实现构造方法

3) 实例化第二步中的普通类

2.抽象类的使用特点

•  抽象类不能有对象，（不能用new此关键字来创建抽象类的对象）；
•  有抽象方法的类一定是抽象类，但是抽象类中不一定有抽象方法；
•  抽象类中的抽象方法必须在子类中被重写，除非该子类也是抽象类
•  抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能
•  构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法

3.抽象类的使用场景

父抽象类

/**
 * 定义一个员工抽象类Employee：属性：name，id，pay。方法：work
 * 抽象方法work，空，没有具体实现形式。子类继承必须需要实现
 */
public abstract class Employee {
	String name;
	String id;
	double pay; 
	//员工类
	Employee (String name,String id,double pay){
		this.name = name;
		this.id = id;
		this.pay = pay;
	}
	public abstract void work(); //抽象方法,可以在抽象类和接口中实现
}

子类一

/**
 * 定义普通工程师类Programmer 继承 员工抽象类
 * 必须实现work()方法
 */
public class Programmer extends Employee{
	
	public Programmer(String name,String id,double pay){
		super(name,id,pay); 
	}
	public void work(){
		System.out.println("我是工程师工作...."); 
	} 

}

子类二

/**
 * 定义普通管理员类Manage 继承 员工抽象类
 * 必须实现work()方法
 */
public class Manage extends Employee{
	int bouns; 
	
	public Manage(String name,String id,double pay,int bouns){ 
		super(name,id,pay); 
		this.bouns = bouns; 
	} 
	
	public void work(){ 
		System.out.println("我是管理员工作...."); 
	} 
}

实现主体

import dom.Manage;
import dom.Programmer;

public class DoAbstract {
	public static void main (String[] args){
		Programmer  pro = new Programmer("mahuateng","10000",10000); 
		Manage man = new Manage("mayun","10086",88888,10000); 
		pro.work();
		man.work();
	}
}

结果：

我是工程师工作....
我是管理员工作....

 

二、接口类

那么为什么要使用接口类呢，所有的接口类也同样可以用普通类代替。

同理，从一个例子引入，比如一个猫的属性有吃，睡，而人的属性有吃，睡，学习，行走等等，当这些属性在不同的接口中时，这个时候我们就需要用到implements实现多接口，提高代码可读性

 

1.整体实现步骤

1）创建接口Sleep，Eat，包含属性，普通方法或者抽象方法

2）创建普通类实现接口

3）实例化第二步中的普通类

 

2.接口的使用特点

• 接口中的所有属性默认为：public static final ****；
• 接口中的所有方法默认为：public abstract ****；

3.接口的使用场景

/**
 * 接口类，其中包含抽象方法
 */
public interface Sleep {
	public abstract void ioSleep();//接口中可以写抽象方法，但是子类实现此接口，必须要实现此抽象方法
}

/**
 * 接口类，其中包含属性和普通方法
 */
public interface Eat {
	public static String romm = "abc";
	public static String bed = "cbd";
	public void eat();
}

import dom.Eat;
import dom.Sleep;

public class DoInterface implements Sleep,Eat{

	//必须要实现所有接口中的方法，不管是抽象方法还是普通方法
	@Override
	public void eat() {
		System.out.println("吃吃吃....");		
	}

	@Override
	public void ioSleep() {
		System.out.println("睡睡睡....");		
	}
	
}

三、区别总结

1.接口的方法默认是public，所有方法在接口中不能有实现，抽象类可以有非抽象的方法

2.接口中的实例变量默认是final类型的，而抽象类中则不一定

3.一个类可以实现多个接口（implements），但最多只能继承一个抽象类（extends）

4.一个类实现接口的话要实现接口的所有方法，而抽象类只需要实现抽象方法

5.接口不能用new实例化，抽象类也不能

 

欢迎补充~