浅谈抽象与接口（含工厂、适配器、代理模式应用）

抽象类和接口抽象类

abstract class A{      // 是定义了一个抽象类

       publicstatic final String FLAG = "CHINA" ;  //全局常量

       privateString name = "Cym" ;    // 定义一个普通的属性

       publicvoid setName(String name){

              this.name = name ;

       }

       publicString getName(){

              return this.name ;

       }

       publicabstract void print() ;           // 定义抽象方法

};
包含一个抽象方法的类称为抽象类，抽象方法是只声明而未实现的方法，所有的抽象方法必须使用abstract关键字声明，所有的抽象类也需要abstract关键字声明。

abstract class A{      // 是定义了一个抽象类

       publicstatic final String FLAG = "CHINA" ;  //全局常量

       privateString name = "Cym" ;       // 定义一个普通的属性

       publicvoid setName(String name){

              this.name = name ;

       }

       publicString getName(){

              return this.name ;

       }

       publicabstract void print() ;           // 定义抽象方法

};

class B extends A{  // 继承抽象类，因为B是普通类，所以必须覆写全部抽象方法

       publicvoid print(){

              System.out.println("FLAG = " +FLAG) ;

              System.out.println("姓名 = " + super.getName()) ;

       }

};

对于抽象类来将，不能直接实例化的操作，但是可以声明，如果要使用抽象类，则必须依靠子类，抽象类是必须被子类继承，而且被继承的子类需要实现抽象中的全部抽象方法。

问题：

抽象类是否可以使用final关键字修饰呢？

抽象类必须被子类继承。

被final修饰的类不能被继承。

所以得出结论，抽象类不能使用final关键子修饰。

抽象类是否可以存在构造方法？

abstract classA{      // 是定义了一个抽象类

              public A(){

                     System.out.println("A、抽象类中的构造方法。") ;

              }

};

class B extendsA{  // 继承抽象类，因为B是普通类，所以必须覆写全部抽象方法

              public B(){

                     super();

                     System.out.println("B、子类中的构造方法。") ;

              }

};

public classAbstractDemo03{

              public static void main(String args[]){

                     Bb = new B() ;

              }

};

抽象类中允许有构造方法，但是此构造方法不能直接调用的，是交给子类调用的，子类对象的实例化过程中，永远是先调用父类中的构造方法。

抽象类就是比普通类多了一个抽象方法而已。

抽象类属性如何初始化？

abstract class Person{

       privateString name ;              // 定义name属性

       privateint age ;                     // 定义age属性

       publicPerson(String name,int age){

              this.name = name ;

              this.age = age ;

       }

       publicvoid setName(String name){

              this.name = name ;

       }

       publicvoid setAge(int age){

              this.age = age ;

       }

       publicString getName(){

              return this.name ;

       }

       publicint getAge(){

              return this.age ;

       }

       publicabstract String getInfo() ;      // 抽象方法

};

使用super

class Student extends Person{

       privateString school ;

       publicStudent(String name,int age,String school){

              super(name,age) ;     // 指定要调用抽象类中有两个参数的构造方法

              this.school = school ;

       }

       publicvoid setSchool(String school){

              this.school = school ;

       }

       publicString getSchool(){

              return this.school ;

       }

       publicString getInfo(){

              return      "姓名：" + super.getName()  +

                            "；年龄：" + super.getAge() +

                            "；学校：" + this.getSchool() ;

       }

};

public class AbstractDemo04{

       publicstatic void main(String args[]){

              Student stu = new Student("张三",30,"清华大学") ;

              System.out.println(stu.getInfo()) ;

       }

};

抽象类中的属性如果要想初始化，则肯定还要依赖与构造方法。

接口

接口是一个特殊的类，在java中接口是由抽象方法和全局常量组成。

在java中使用interface定义一个接口

interface A{            // 定义接口A

       publicstatic final String AUTHOR = "CYM" ;      //全局常量

       publicabstract void print() ;    // 抽象方法

       publicabstract String getInfo() ;      // 抽象方法

}

在此接口中定义两个抽象方法，一个全局常量，那么接口与抽象类一样，需要有子类，那么子类此时不再称为继承类，而是实现类，通过implements关键字实现完成。

接口的方法和属性永远是pubic修饰符

默认是方法是abstract

属性是 static final

既然接口从定义上已经明确了要求是由抽象方法和全局常量组成，那么在接口定义的时候就可以简化操作

interface A{            // 定义接口A

       StringAUTHOR = "Cym" ;   // 全局常量

       voidprint() ;    // 抽象方法

       StringgetInfo() ;      // 抽象方法

}

一个类是虽然值能继承一个父类，但是一个类可以同时实现多个接口。

如果一个类既要实现接口又要继承抽象类的话，则必须按照一下的形式完成。

Class 子类extends 抽象类 implements 接口A，接口B，......{}

interface A{            // 定义接口A

       publicString AUTHOR = "CYM" ;       //全局常量

       publicvoid print() ; // 抽象方法

       publicString getInfo() ;   // 抽象方法

}

abstract class B{      // 定义抽象类B

       publicabstract void say() ;      // 定义抽象方法

}

class X extends B implements A{   // X类线继承B类，再实现A接口

       publicvoid say(){

              System.out.println("HelloWorld!!!") ;

       }

       publicString getInfo(){

              return "HELLO" ;

       }

       publicvoid print(){

              System.out.println("作者：" + AUTHOR) ;

       }

};

public class InterfaceDemo04{

       publicstatic void main(String args[]){

              X x = new X() ;      // 实例化子类对象

              x.say() ;

              x.print() ;

       }

};

接口里面的方法可以简写方法不写abstract关键字，但是抽象类里一定要修abstract关键字。

interface A{            // 定义接口A

       publicString AUTHOR = "CYM" ;       //全局常量

       publicvoid print() ; // 抽象方法

       publicString getInfo() ;   // 抽象方法

}

abstract class B implements A{       // 定义抽象类B，实现接口A

       publicabstract void say() ;      // 定义抽象方法

}

class X extends B{  // X类线继承B类

       publicvoid say(){

              System.out.println("HelloWorld!!!") ;

       }

       publicString getInfo(){

              return "HELLO" ;

       }

       publicvoid print(){

              System.out.println("作者：" + AUTHOR) ;

       }

};

public class InterfaceDemo05{

       publicstatic void main(String args[]){

              X x = new X() ;      // 实例化子类对象

              x.say() ;

              x.print() ;

       }

};

一个抽象类可以实现多个接口，但是一个接口不能继承一个抽象类。

interface A{            // 定义接口A

       publicString AUTHOR = "CYM" ;       //全局常量

       publicvoid printA() ;      // 抽象方法

}

interface B{

       publicvoid printB() ;

}

interface C extends A,B{

       publicvoid printC() ;

}

class X implements C{    // X类线继承B类

       publicvoid printA(){

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

       }

       publicvoid printB(){

              System.out.println("B、Hello MLDN") ;

       }

       publicvoid printC(){

              System.out.println("C、Hello LXH") ;

       }

};

public class InterfaceDemo06{

       publicstatic void main(String args[]){

              X x = new X() ;      // 实例化子类对象

              x.printA() ;

              x.printB() ;

              x.printC() ;

       }

};

一个接口虽然不可以继承一个抽象类，但是一个接口却可以同时继承多个接口。

对象多态性

接口和抽象类的基本概念完成了，下面最重要的就是对象的多态性，是整个java中最重要的一个部分，因为有多态性的存在，才可以让程序变的更加灵活。

多态性是面向对象的最后一个特征:

方法的重载和方法的覆写实际上就属于多态行的一种体现。

真正的多态性中还包含了一种为对象多态性概念。

对象多态性主要指的是,子类和父类对象的相互转换关系。

向上转型：父类 父类对象 = 子类实例  --》自动完成

向下转型：子类 子类对象 = （子类）父类实例 --》强制完成

   classA{

       publicvoid fun1(){

              System.out.println("1、A类 --> public void fun1(){}") ;

       }

       publicvoid fun2(){

              this.fun1() ;

       }

};

class B extends A{

       publicvoid fun1(){  // 将方法覆写了

              System.out.println("2、B类 --> public void fun1(){}") ;

       }

       publicvoid fun3(){  // 此操作为子类自己定义的，父类中不存在

              System.out.println("3、B类 --> public void fun3(){}") ;

       }

};

public class PolDemo01{

       publicstatic void main(String args[]){

              A a = new B() ;       // 发生向上转型关系，子类实例 --> 父类实例

              a.fun2() ;

       }

};

   父类对象 = 子类实例（向上转型）

   只能使用父类有的方法。(子类如果覆写则使用子类覆写的方法)

class A{

       publicvoid fun1(){

              System.out.println("1、A类 --> public void fun1(){}") ;

       }

       publicvoid fun2(){

              this.fun1() ;

       }

};

class B extends A{

       publicvoid fun1(){  // 将方法覆写了

              System.out.println("2、B类 --> public void fun1(){}") ;

       }

       publicvoid fun3(){  // 此操作为子类自己定义的，父类中不存在

              System.out.println("3、B类 --> public void fun3(){}") ;

       }

};

public class PolDemo02{

       publicstatic void main(String args[]){

              A a = new B() ;       // 发生向上转型关系，子类实例 --> 父类实例

              B b = (B)a ;    // 发生向下转型关系，强制

              b.fun3() ;

              b.fun2() ;

       }

};

   父类对象 = 子类实例

   子类对象 = （子类）父类对象（向下转型）

class A{

       publicvoid fun1(){

              System.out.println("1、A类 --> public void fun1(){}") ;

       }

       publicvoid fun2(){

              this.fun1() ;

       }

};

class B extends A{

       publicvoid fun1(){  // 将方法覆写了

              System.out.println("2、B类 --> public void fun1(){}") ;

       }

       publicvoid fun3(){  // 此操作为子类自己定义的，父类中不存在

              System.out.println("3、B类 --> public void fun3(){}") ;

       }

};

public class PolDemo03{

       publicstatic void main(String args[]){

              A a = new A() ;

              B b = (B)a ;

              b.fun2() ;

       }

};

会产生ClassCastException，表示转换异常，造成的根本原因是两个没有关系的类进行相互的对象操作。

观察对象多态性的作用：

           假如：现在要设计一个方法，那么此方法可以接受A类的所有子类的实例。

如果现在不使用对象多态性的概念完成

class A{

       public void fun1(){

              System.out.println("1、A类 -->public void fun1(){}") ;

       }

       public void fun2(){

              this.fun1() ;

       }

};

class B extends A{

       public void fun1(){  // 将方法覆写了

              System.out.println("2、B类 -->public void fun1(){}") ;

       }

       public void fun3(){  // 此操作为子类自己定义的，父类中不存在

              System.out.println("3、B类 -->public void fun3(){}") ;

       }

};

class C extends A{

       public void fun1(){  // 将方法覆写了

              System.out.println("4、C类 -->public void fun1(){}") ;

       }

       public void fun4(){  // 此操作为子类自己定义的，父类中不存在

              System.out.println("5、C类 -->public void fun4(){}") ;

       }

};

public class PolDemo04{

       public static voidmain(String args[]){

              fun(new B()) ;

              fun(new C()) ;

       }

       public static void fun(Bb){

              b.fun2() ;

              b.fun3() ;

       }

       public static void fun(Cc){

              c.fun2() ;

              c.fun4() ;

       }

};

以上的方式是通过重载完成，那么使用以上方法完成会存在以上的缺点，如果现在A类的子类有N个，那么方法就要重载N次，而且每次增加子类的时候都需要修改代码本身。

所以，此时使用对象多态性就可以很好的解决此类问题，因为所有的对象都会发生自动的向上转型操作。

class A{

       public void fun1(){

              System.out.println("1、A类 -->public void fun1(){}") ;

       }

       public void fun2(){

              this.fun1() ;

       }

};

class B extends A{

       public void fun1(){  // 将方法覆写了

              System.out.println("2、B类 -->public void fun1(){}") ;

       }

       public void fun3(){  // 此操作为子类自己定义的，父类中不存在

              System.out.println("3、B类 -->public void fun3(){}") ;

       }

};

class C extends A{

       public void fun1(){  // 将方法覆写了

              System.out.println("4、C类 -->public void fun1(){}") ;

       }

       public void fun4(){  // 此操作为子类自己定义的，父类中不存在

              System.out.println("5、C类 -->public void fun4(){}") ;

       }

};

public class PolDemo05{

       public static voidmain(String args[]){

              fun(new B()) ;

              fun(new C()) ;

       }

       public static void fun(Aa){

              a.fun2() ;

       }

};

class A{

       public void fun1(){

              System.out.println("1、A类 -->public void fun1(){}") ;

       }

       public void fun2(){

              this.fun1() ;

       }

};

class B extends A{

       public void fun1(){  // 将方法覆写了

              System.out.println("2、B类 -->public void fun1(){}") ;

       }

       public void fun3(){  // 此操作为子类自己定义的，父类中不存在

              System.out.println("3、B类 -->public void fun3(){}") ;

       }

};

class C extends A{

       public void fun1(){  // 将方法覆写了

              System.out.println("4、C类 -->public void fun1(){}") ;

       }

       public void fun4(){  // 此操作为子类自己定义的，父类中不存在

              System.out.println("5、C类 -->public void fun4(){}") ;

       }

};

public class PolDemo08{

       public static voidmain(String args[]){

              fun(new B()) ;

              fun(new C()) ;

       }

       public static void fun(Aa){

              a.fun2() ;

              if(a instanceof B){

                     B b = (B)a ;

                     b.fun3() ;

              }

              if(a instanceof C){

                     C c = (C)a ;

                     c.fun4() ;

              }

       }

};

如果要使用子类自身的方法为了保证对象向下转型操作正确，在操作前最好加上instanceof关键字判断。

在继承关系中，父类的设计很重要，只要父类的设计合理了，则代码开发非常简便。

抽象类的应用

从对象多态性的概念来看，子类为父类实例化是一个比较容易的操作，以为可以发生自动的向上转型关系，那么调用的方法永远是被子类覆写过的方法。

那么，此时就可以利用此概念通过对象多态性为抽象类实例化。

抽象类可以实现方法，当很多类有相同方法和并且相同实现的时候，我们就可以用抽象类。当然也可以覆写。

抽象类本身最大的用处就是在于模版设计。

接口的应用

接口也可以像抽象类那样通过多态性进行对象的实例化操作。

抽象类可以用于定义模版操作，但是接口呢？

接口实际上是作为一个标准存在的。

接口不可以的实现方法，但很多类只要有相同方法操作的时候，我们就可以用接口作为一种标准。

接口和抽象类适配器设计模式

正常情况下一个接口的子类要实现全部的抽象方法

interface Window{

       publicvoid open() ; // 打开窗口

       publicvoid close() ; // 关闭窗口

       publicvoid icon() ;  // 最小化

       publicvoid unicon() ;      // 最大化

}

Class MyWindow implements Window｛

｝

在MyWindow类此时肯定要覆写全部的抽象方法，但是现在希望可以根据自己的需要来选择覆写，那么该怎么实现？

用一个类先将接口实现了，但是所有的方法都属于空实现，之后再继承此类。

应该使用抽象类，因为抽象类也不能直接使用。

interfaceWindow{

       public void open() ; // 打开窗口

       public void close() ; // 关闭窗口

       public void icon() ;  // 最小化

       public void unicon() ;      // 最大化

}

abstract classWindowAdapter implements Window{

       public void open(){}

       public void close(){}

       public void icon(){}

       public void unicon(){}

};

class MyWindowextends WindowAdapter{

       public voidopen(){

              System.out.println("打开窗口！");

       }

};

public classAdpaterDemo{

       public static void main(String args[]){

              Windowwin = new MyWindow() ;

              win.open();

       }

}

工厂设计模式

interface Fruit{

       publicvoid eat() ;

}

class Apple implements Fruit{

       publicvoid eat(){

              System.out.println("吃苹果。。。") ;

       }

};

class Orange implements Fruit{

       publicvoid eat(){

              System.out.println("吃橘子。。。") ;

       }

};

Public class interDemo｛

Public staticvoid main（String args[]）{

Fruit f = new Apple();

F.eat();

}

｝

以上的程序如果开发的话是存在问题?

一直强调：主方法实际上就是一个客户端。客户端的代码越简单越好。

interface Fruit{

       publicvoid eat() ;

}

class Apple implements Fruit{

       publicvoid eat(){

              System.out.println("吃苹果。。。") ;

       }

};

class Orange implements Fruit{

       publicvoid eat(){

              System.out.println("吃橘子。。。") ;

       }

};

class Factory{  // 工厂类

       publicstatic Fruit getFruit(String className){

              Fruit f = null ;

              if("apple".equals(className)){

                     f= new Apple() ;

              }

              if("orange".equals(className)){

                     f= new Orange() ;

              }

              return f ;

       }

};

public class InterDemo{

       publicstatic void main(String args[]){

              Fruit f = Factory.getFruit(args[0]) ;

              if(f!=null){

                     f.eat();

              }

       }

}

所有接口的实例化对象都是工厂类取得的。那么客户端调用的时候根据传入的名称不同，完成不同的功能。

代理设计模式

interface Give{

       publicvoid giveMoney() ;

}

class RealGive implements Give{

       publicvoid giveMoney(){

              System.out.println("把钱还给我。。。。。") ;

       }

};

class ProxyGive implements Give{  // 代理公司

       privateGive give = null ;

       publicProxyGive(Give give){

              this.give = give ;

       }

       publicvoid before(){

              System.out.println("准备：小刀、绳索、钢筋、钢据、手枪、毒品") ;

       }

       publicvoid giveMoney(){

              this.before() ;

              this.give.giveMoney() ;   // 代表真正的讨债者完成讨债的操作

              this.after() ;

       }

       publicvoid after(){

              System.out.println("销毁所有罪证") ;

       }

};

public class ProxyDemo{

       publicstatic void main(String args[]){

              Give give = new ProxyGive(new RealGive());

              give.giveMoney() ;

       }

};

当两个类同时实现一个接口，一个类需要另外一个类代理才能实现该功能，这就叫代理模式。

抽象类与接口的区别
  

NO

  

比较点

抽象类

接口

1

组成

抽象方法、普通方法、常量、变量、构造、方法、全局变量

抽象方法、全局常量

2

定义

Abstract

interface

3

子类

子类通过extends继承抽象类

子类通过implements实现接口

4

限制

一个子类只能继承一个抽象类

一个子类能够同时实现多个接口

5

关系

一个抽象类可以实现多个接口

  

一个抽象类中可以包含多个接口

一个接口不能继承一个抽象类

  

一个接口可以包含多个抽象类

6

设计模式

模版设计

工厂模式、代理模式

7

实例化

都是通过对象的多态性、通过子类进行对象实例化操作

8

实现限制

存在单继承局限

不存在单继承局限

9

特性

一个标准、一种能力

     

如果抽象类和接口同时都可以使用的话、优先接口，以为接口可以避免单继承的局限。

抽象类包含接口

abstract class A{

       publicabstract void fun() ;

       interfaceB{     // 内部接口

              public void print() ;

       }

};

class X extends A{

       publicvoid fun(){

              System.out.println("****************");

       }

       classY implements B{

              public void print(){

                     System.out.println("===================");

              }

       };

};

public class TestDemo01{

       publicstatic void main(String args[]){

              A a = new X() ;

              a.fun() ;

              A.B b = new X().new Y() ;

              b.print() ;

       }

};

接口包含抽象类

interface A{

       publicvoid fun() ;

       abstractclass B{      // 内部抽象类

              public abstract void print() ;

       }

};

class X implements A{

       publicvoid fun(){

              System.out.println("****************");

       }

       classY extends B{

              public void print(){

                     System.out.println("===================");

              }

       };

};

public class TestDemo02{

       publicstatic void main(String args[]){

              A a = new X() ;

              a.fun() ;

              A.B b = new X().new Y() ;

              b.print() ;

       }

};