java基础---->接口和抽象类

抽象类和接口

引入原因：

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

实例化

都是依靠对象多态性，通过子类进行对象实例化的