抽象类和接口
引入原因：
1、为了能够向上转型为多个基类（由此带来灵活性）
2、防止使用者创建对象
一、抽象类
抽象方法：只声明而未定义方法体的方法称为抽象方法，抽象方法必须使用abstract关键字声明。
抽象类: abstract修饰的类是抽象类，抽象类必须使用abstract关键字进行声明。 抽象类通常包含抽象方法。
说明：
1、抽象类不能直接实例化。编译器报错Cannot instantiate the type
2、如果从一个抽象类继承，并想创建新类的对象，必须为基类中的所有抽象方法提供方法定义，如果不这样做，那么子类也必须声明成抽象类。即包含抽象方法的类必须被声明为抽象类，否则编译器会报错。
3、抽象类也可以不包含抽象方法。
4、抽象类中能有构造方法吗？可以
可以存在，而且依然符合于子类对象的实例化过程的要求。
abstract class Demo { // 抽象类
public Demo() {
System.out.println("抽象类中的构造方法！");
}
public void print() {
System.out.println("Hello World!!!");
}
public abstract void fun(); // 抽象方法
};
class DemoImpl extends Demo {
public DemoImpl() {
super();
System.out.println("子类中的构造方法！");
}
public void fun() {}
};
public class AbsDemo03 {
public static void main(String args[]) {
DemoImpl di = new DemoImpl();
di.print();
}
};
抽象类和普通类相比，只是增加了抽象abstract class的声明，和增加了抽象方法而已。
范例：定义一个抽象类
abstract class Demo { // 抽象类
public void print() {
System.out.println("Hello World!!!");
}
public abstract void fun(); // 抽象方法
};
二、接口
当一个类中全部是由抽象方法和全局常量组成的时候，那么就可以将这个类定义成一个接口了， interface关键字产生一个完全抽象的类。接口被用来建立类与类之间的协议。
范例：定义接口
interface Demo{ // 接口
public static final String INFO = "hello world" ;
public abstract void print() ;
public abstract void fun() ;
}
一个接口定义完成之后，实际上与抽象类的使用原则是一样的：
1、 接口必须有子类，子类（如果不是抽象类）则必须覆写接口中的全部抽象方法；
2、 接口是不能直接进行对象的实例化操作。
3、 接口的访问权限和类相同。
4、 一个子类可以同时继承（实现）多个接口
5、 一个子类如果要实现接口又要继承类的话，则必须先继承类，再实现接口.即extends要写在implements的前面。
6、接口中的成员隐含是static和final的
接口中的全部组成都是抽象方法和全局常量的话，因此以下的两种定义接口的形式是完全一样的：
interface Demo{ //接口
public static final String INFO = "hello world" ;
public abstractvoid print() ;
}
interface Demo{ //接口
String INFO = "hello world" ;
void print() ;
}
所有的修饰符在接口中是否添加本身是没有任何意义的，而且接口中的方法全部都属于公共的方法操作（public）。
7、一个接口可以同时通过extends关键字继承多个接口。
interface A{
public void printA() ;
}
interface B{
public void printB() ;
}
interface C extends A,B{
public void printC() ;
}
class Demo implements C {
public void printA(){}
public void printB(){}
public void printC(){}
};
三、抽象类的使用——模板设计
例如：现在可以将一个人的划分成学生和工人。
·不管是工人还是学生肯定都有其共同的属性，例如：姓名、年龄。
·但是，既然是一个类，肯定就拥有自己的信息，例如：学生有学校，工人有工作。
abstract class Person {
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public void say(){
System.out.println(this.getContent()) ;
}
public abstract String getContent() ;
public String getName(){
return this.name ;
}
public int getAge(){
return this.age ;
}
};
class Student extends Person {
private String school ;
public Student(String name,int age,String school){
super(name,age) ;
this.school = school ;
}
public String getContent(){
return this.toString() ;
}
public String toString(){
return "姓名：" + super.getName() + "，年龄：" + super.getAge() + "学校：" + this.school ;
}
};
class Worker extends Person {
private String job ;
public Worker(String name,int age,String job){
super(name,age) ;
this.job = job ;
}
public String getContent(){
return this.toString() ;
}
public String toString(){
return "姓名：" + super.getName() + "，年龄：" + super.getAge() + "工作：" + this.job ;
}
};
public class CaseDemo02 {
public static void main(String args[]){
// Person per = new Student("张三",20,"清华大学") ;
Person per = new Worker("张三",20,"经理") ;
per.say() ;
}
};
在实际的开发中，所有的类永远不要去继承一个已经实现好的类，而只能继承抽象类或实现接口。
四、接口的使用——制定标准
接口主要有以下三大使用： 1、制定标准；2、表示能力；3、将远程方法的操作视图暴露给客户端。
电脑上有USB接口，只要是USB设备都可以向电脑上插入并使用
interface USB{ // 定义好了一个标准
public void use() ; // 使用
}
class Computer {
public static void plugIn(USB usb){
usb.use() ;
}
};
class Flash implements USB {
public void use(){
System.out.println("使用U盘。") ;
}
};
class Print implements USB {
private String name ;
public Print(String name){
this.name = name ;
}
public void use(){
System.out.println("欢迎使用" + this.name + "牌打印机！") ;
System.out.println("开始打印！") ;
}
};
public class CaseDemo04 {
public static void main(String args[]){
Computer.plugIn(new Flash());
Computer.plugIn(newPrint("HP")) ;
}
};
五、接口的使用——工厂设计模式
下面先来观察以下的一段代码：
interface Fruit{
public void eat() ;
}
class Apple implements Fruit {
public void eat(){
System.out.println("吃苹果。") ;
}
};
class Orange implements Fruit {
public void eat(){
System.out.println("吃橘子。") ;
}
};
public class CaseDemo05 {
public static void main(String args[]){
Fruit f = new Orange() ;
f.eat() ;
}
};
以上代码中存在的问题：现在的程序中可以发现，在主方法（客户端）上，是通过关键字new直接为接口进行实例化，也就是说以后在使用的时候如果要不更改主方法的话，则主方法中永远只能使用一个类，这样的耦合度太深了。
interface Fruit{
public 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 ;
}
};
public class CaseDemo06 {
public static void main(String args[]){
Fruit f = Factory.getInstance(args[0]) ;
f.eat() ;
}
};
此时，中间加入了一个过渡端（Factory），那么都通过过渡端找到接口的实例，这样的设计称为工厂设计，以后扩充子类的时候修改工厂即可：即：某一局部的修改不影响其他环境。
六、接口的使用——代理设计模式
代理：继承和组合的中庸之道。将一个成员对象置于要构造的类中（就像组合），与此同时在新类中暴露了该类成员所有的方法（就像继承)。类的复用-代理
一个代理人员可以代表一个真实的操作人员进行某些操作，但是两者的核心目的就是讨债。
interface Subject{
public void give() ;
}
class RealSubject implements Subject{
public void give(){
System.out.println("真正的讨债者：还我的钱。") ;
}
};
class ProxySubject implements Subject {
private Subject sub ; // 设置代理人
public ProxySubject(Subject sub){
this.sub = sub ;
}
public void before(){
System.out.println("准备刀子，绳索，毒药。。。") ;
}
public void give(){
this.before() ;
this.sub.give() ; // 真实主题
this.after() ;
}
public void after(){
System.out.println("跑路了。。。") ;
}
};
public class CaseDemo07 {
public static void main(String args[]){
Subject s = new ProxySubject(new RealSubject()) ;
s.give() ;
}
};
在此设计之中可以发现，真实主题完成具体的业务操作，而代理主题将完成与真实主题有关的其他的操作。现在的IDE都能自动生成代理。
七、接口的使用——适配器设计
在正常情况下，一个接口的子类肯定是要覆写一个接口中的全部抽象方法。
那么有没有一种可能性，通过代码的变更，让一个子类可以有选择性的来覆写自己所需要的抽象方法呢？
从概念上讲这样肯定不合适，所以中间就想一想加入一个过渡端，但是这个过渡端又不能直接使用。
interface Fun{
public void printA() ;
public void printB() ;
public void printC() ;
}
abstract class FunAdapter implements Fun {
public void printA(){}//空实现
public void printB(){}
public void printC(){}
};
class Demo extends FunAdapter {
public void printA(){
System.out.println("Hello World!!!") ;
}
};
一般在进行图形界面的开发中才会使用到适配器的设计思路。
八、抽象类和接口的区别
接口和抽象类从使用上看非常的相似，那么下面通过以下的表格对两者进行区分
|
No. |
比较 |
抽象类 |
接口 |
|
1 |
关键字 |
使用abstract class声明 |
使用interface声明 |
|
2 |
定义 |
包含一个抽象方法的类 |
抽象方法和全局常量的集合 |
|
3 |
组成 |
属性、方法、构造、常量、抽象方法 |
全局常量、抽象方法 |
|
4 |
权限 |
抽象方法的权限可以任意 |
只能是public权限 |
|
5 |
使用 |
通过extends关键字继承抽象类 |
通过implements关键字实现接口 |
|
6 |
局限 |
抽象类存在单继承局限 |
没有此局限，一个子类可以实现多个接口 |
|
7 |
顺序 |
一个子类只能先继承抽象类再实现多个接口 |
|
|
8 |
实际作用 |
只能做一个模板使用 |
作为标准、表示能力 |
|
9 |
使用 |
两者没有什么本质的区别，但是从实际上来看，如果一个程序中抽象类和接口都可以使用的话，则一定要优先考虑接口，因为接口可以避免单继承所带来的局限。 |
|
|
10 |
实例化 |
都是依靠对象多态性，通过子类进行对象实例化的 |
|