抽象类的常见实际应用——模板

public class AbstractCaseDemo01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person p=new Student("小明",18,99.9f);
		p.say();
		
	}

}
abstract class Person{
	private String name;
	private int age;
	public Person(String name,int age) {
		this.setAge(age);
		this.setName(name);
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public void say() {	//说话是具体功能要定义为普通方法
		System.out.println(this.getContent());
	}
	public abstract String getContent();
}
class Student extends Person{
	private float score;
	public Student(String name,int age,float score) {
		super(name,age);
		this.setScore(score);
	}
	public float getScore() {
		return score;
	}
	public void setScore(float score) {
		this.score = score;
	}
	public String getContent() {
		return "学生信息——>姓名："+super.getName()+"年龄："+super.getAge()+"成绩："+this.score;
	}
}
//结果：
//学生信息——>姓名：小明年龄：18成绩：99.9

接口的常见实际应用——工厂设计
工厂设计：在接口与具体子类之间加入一个过渡端，通过此过渡段取得接口实例。一般称这个过渡端为工厂类。
步骤：
1、创建接口和子类。
2、创建过渡端。
3、使过渡端作用于接口和接口子类之间。
4、在过渡端取得接口实例。

public class InterfaceCaseDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Fruit f=null;
		f=Factory.getInstance("apple");
		f.eat();
	}

}
interface Fruit{
	public abstract void eat();
}
class Apple implements Fruit{
	public void eat() {
		System.out.println("吃苹果");
	}
}
class Orange implements Fruit{
	public void eat() {
		System.out.println("吃橘子");
	}
}
class Factory{
	public static Fruit getInstance(String className) {
		//取得接口实例
		Fruit f=null;
		if("apple".equals(className)) {
			f=new Apple();
		}
		if("orange".equals(className)) {
			f=new Orange();
		}
		return f;
	}
}
//结果：
//吃苹果

接口的常见实际应用——代理设计
代理设计：就是指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。
步骤：
1、创建接口。
2、创建代理主题和真实主题并都实现接口。
3、代理主题操作真实主题。

public class ProxyDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		NetWork net=null;	//定义接口对象
		net=new Proxy(new Real());	//实例化代理，同时传入代理的真实操作
		net.browse();	//客户的实际操作
	}

}
interface NetWork{	//1、创建接口
	public void browse();
}
class Real implements NetWork{	//2、创建真实主题并实现接口
	public void browse() {
		System.out.println("上网浏览信息");
	}
}
class Proxy implements NetWork{	//3、创建代理主题并实现接口
	private NetWork network;
	public Proxy(NetWork network) {	//设置代理主题的真实操作
		this.network=network;	    //设置代理主题的子类
	}
	public void check() {	//代理主题自己的操作
		System.out.println("检查用户是否合法");
	}
	public void browse() {	
		this.check();		//调用代理主题具体业务的操作
		this.network.browse();	//4、调用（操作）真实主题
	}
}
//检查用户是否合法
//上网浏览信息

代理主题要做比真实主题更多的业务相关操作。

接口和抽象类有什么区别

在应用场景下，选择使用接口和抽象类的依据是什么？

一、抽象类和接口在语法上的异同：

1、相同点

都不能被实例化

2、不同点     

第一点． 接口是抽象类的变体，接口比抽象类更加抽象，接口中所有的方法都是抽象的。

第二点． 每个类只能继承一个抽象类，但是可以实现多个接口
第三点．抽象类中不一定都是抽象方法，抽象的而抽象类可以实现部分方法。但是接口中方法必须为public修饰的、抽象的不能实现具体的法。
第四点． 接口中基本数据类型为static 而抽象类不是的。

二、应用场景

应用都是基于规则的应用，也就是基于语法的应用，我们可以根据语法上的异同点来总结抽象类和接口的应用场景

相同点没有什么可说的，我们从不同点下手。

1、第一个重要的不同点就是，

抽象类中不一定都是抽象的方法，也可以有具体实现的方法，这样就可以把大家公用的方法提升到抽象类中，然后具体的方法可以留给子类自己实现（此处经典的应用，模板方法设计模式）。所以抽象类可以更好的实现代码的复用

2、另一个重要的不同就是类可以实现多个接口。

接口和抽象类的概念不一样。这个可以理解为接口是对动作的抽象，抽象类是对根源的抽象（即对本质的抽象与其他类的本质不同）。

抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.

所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。

当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。

另一个重要的概念就是多态，多态通过分离做什么和怎么做，从另一个角度将接口和实现分离出来。多态不但能够改善代码的组织结果和可读性，还能创建可扩展的程序----即无论在项目最初创建时还是在需要添加新功能时都可以“生长”的程序。由于接口更关注于动作的实现，多态主要是分离“做什么”和“怎么做”，所以接口的另一个重要的应用就是多态的实现（当然抽象类也可以实现多态，但是接口更加合适）。

抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度的。

（参考：http://blog.csdn.net/fenglibing/article/details/2745123，

 《java编程思想》）

原文链接： javacodegeeks 翻译： ImportNew.com - jessenpan
译文链接： http://www.importnew.com/12399.html

转自：http://www.importnew.com/12399.html

http://blog.xiaohansong.com/2015/12/02/abstract-class-and-interface/

很多常见的面试题都会出诸如抽象类和接口有什么区别，什么情况下会使用抽象类和什么情况你会使用接口这样的问题。本文我们将仔细讨论这些话题。

在讨论它们之间的不同点之前，我们先看看抽象类、接口各自的特性。

抽象类

抽象类是用来捕捉子类的通用特性的 。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。以JDK中的GenericServlet为例：

当HttpServlet类继承GenericServlet时，它提供了service方法的实现：

接口

接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法。这就像契约模式，如果实现了这个接口，那么就必须确保使用这些方法。接口只是一种形式，接口自身不能做任何事情。以Externalizable接口为例：

当你实现这个接口时，你就需要实现上面的两个方法：

抽象类和接口的对比

什么时候使用抽象类和接口

• 如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。
• 如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。
• 如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

什么时候使用抽象类？

抽象类让你可以定义一些默认行为并促使子类提供任意特殊化行为。

例如：Spring的依赖注入就使得代码实现了集合框架中的接口原则和抽象实现。

Java8中的默认方法和静态方法

Oracle已经开始尝试向接口中引入默认方法和静态方法，以此来减少抽象类和接口之间的差异。现在，我们可以为接口提供默认实现的方法了并且不用强制子类来实现它。这类内容我将在下篇博客进行阐述。

从 java 容器类的设计讨论抽象类和接口的应用

除了前面提到的一个问题：多态到底是用抽象类还是接口实现？我还看到有人评论说：现在都是提倡面向接口编程，使用抽象类的都被称为上世纪的老码农了。哈哈。看到这个说法我也是苦笑不得。不过，面向接口编程的确是一个趋势，java 8 已经支持接口实现默认方法和静态方法了，抽象类和接口之间的差异越来越小。闲话少说，我们开始讨论抽象类和接口的应用。

full_container_taxonomy

上图是 java 容器类的类继承关系。我们以容器类中 ArrayList 为例子来讨论抽象类和接口的应用。

ArrayList 类继承关系

ArrayList

上图是 ArrayList 的类继承关系。可以看到，ArrayList 的继承关系中既使用了抽象类，也使用了接口。

• 最顶层的接口是 Iterable，表示这是可迭代的类型。所有容器类都是可迭代的，这是一个极高的抽象。
• 第二层的接口是 Collection，这是单一元素容器的接口。集合，列表都属于此类。
• 第三层的接口是 List，这是所有列表的接口。

通过三个接口，我们可以找到容器类的三个抽象特性，实现这些接口就意味着拥有这些接口的特性。

• AbstractCollection 实现了 Collection 中的部分方法。
• AbstractList 实现了 AbstractCollection 和 List 中的部分方法。

上面的抽象类提供了一些方法的默认实现，给具体类提供了复用代码。

纯抽象类实现

如果我们像一个老码农一样，用抽象类来实现上面的接口会有怎样的效果？那么，类图可能变成这样。

AbtractList

抽象类在这里存在着一个很大的问题，它不能多继承，在抽象的层次上没有接口高，也没有接口灵活。例如说：

List + AbstractCollection -> AbstractList
Set  + AbstractCollection -> AbstractSet

单纯用抽象类无法实现像接口一样灵活的扩展。

纯接口实现

如果我们像一个新码农一样，用纯接口来实现呢？

InterfaceList

这样写理论上没有问题，实际写代码的时候问题就来了。所有的接口都要提供实现，于是你不得不在各个实现类中重复代码。

总结

经过上面的讨论，我们得出两个结论：

• 抽象类和接口并不能互相替代。
• 抽象类和接口各有不可替代的作用。

从容器类的类关系图中可以看到，接口主要是用来抽象类型的共性，例如说，容器的可迭代特性。抽象类主要是给具体实现类提供重用的代码，例如说，List 的一些默认方法。

抽象类和接口的使用时机

那么，什么时候该用抽象类，什么时候该用接口呢？

要解决上面的问题，我们先从弄清楚抽象类和接口之间的关系。首先，我们都知道类对事物的抽象，定义了事物的属性和行为。而抽象类是不完全的类，具有抽象方法。接口则比类的抽象层次更高。所以，我们可以这样理解它们之间的关系：类是对事物的抽象，抽象类是对类的抽象，接口是对抽象类的抽象。

从这个角度来看 java 容器类，你会发现，它的设计正体现了这种关系。不是吗？从 Iterable 接口，到 AbstractList 抽象类，再到 ArrayList 类。

现在回答前面的问题：在设计类的时候，首先考虑用接口抽象出类的特性，当你发现某些方法可以复用的时候，可以使用抽象类来复用代码。简单说，接口用于抽象事物的特性，抽象类用于代码复用。

当然，不是所有类的设计都要从接口到抽象类，再到类。程序设计本就没有绝对的范式可以遵循。上面的说法只是提供一个角度来理解抽象类和接口的关系，每个人都会有自己的理解，有人认为两者一点关系都没有，这也有道理。总之，模式和语法是死的，人是活的。