面向对象（高级）抽象类与接口的应用

本章目标：
掌握抽象类及接口的实例化操作
掌握模板设计的作用
掌握工厂设计模式应用
掌握代理设计模式应用
掌握适配器设计模式应用
掌握抽象类与接口的使用区别


为抽象类与接口实例化

在java中可以通过对象的多态性，为抽象类和接口实例化，这样再使用抽象类和接口的时候就可以本子类中所覆写过的方法了。
之所以抽象类和接口不能直接实例化，是因为其内部包含了各个抽象方法，抽象方法本身都是未实现的方法，所以无法调用。
通过对象多态性可以发现，子类发生了向上转型关系之后，所调用的全部方法都是被覆写过的方法。

abstract class A{//定义抽象类A    public  abstract void print();//定义抽象方法print};class B extends A{    public  void print(){//覆写抽象方法        System.out.println("Hello world!!!");    }};public class AbstractCaseDemo01{    public static void main(String args[]){        A a = new B();    //能过子类为抽象类实例化        a.print();    }}

可以继续使用此概念，为一个接口实例化

interface A{//定义接口A    public  void print();//定义抽象方法print}class B implements A{    public  void print(){//覆写抽象方法        System.out.println("Hello world!!!");    }};public class AbstractCaseDemo02{    public static void main(String args[]){        A a = new B();    //能过子类为抽象类实例化        a.print();    }}

证明，如果要使用抽象类或接口，则只能按照以上操作完成。

抽象类的应用————定义模板
来看下面这样一种场景：“假设人分为学生和工人，学生和工厂都可以说话，但是学生和工人说话的内容不是一样的，也就是说话这个功能应该是一个具体功能，而说话的内容就要由学生或工人来决定”，所以此时就可以使用抽象类实现这种场景

图形表示：人可以说话、说话的内容由工人或学生决定

实例：

abstract class Person{    private String name;    private int age;    public Person(String name,int age){        this.name = name;        this.age = age;    }    public String getName(){        return this.name;    }    public int getAge(){        return this.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.score = score;    }    public String getContent(){        return    "学生信息 --> 姓名："+super.getName()+            "年龄："+super.getAge()+            "成绩："+this.score;    }}class Worker extends Person{    private float salary;    public Worker(String name,int age,float salary){        super(name,age);        this.salary = salary;    }    public String getContent(){        return    "工人信息 ---> 姓名："+super.getName()+            "年龄："+super.getAge()+            "工资："+this.salary;        }}public class AbstractCaseDemo02{    public static void main(String args[]){        Person per1 = null;//声明Person对象        Person per2 = null;//声明person对象        per1 = new Student("张三",20,99.0f);//学生是一个人        per2 = new Worker("李四",30,3000.0f);//工人是一个人        per1.say();    }}

显示生活中的模板：
违纪卡：
姓名：
班级：
日期：
事由：


3.3 接口的实际应用————制定标准

接口在实际中更多的作用是用来制定标准的。比如说：“U盘和打印机都可以插在电脑上使用，这是因为它们都实现了USB接口，对于电脑来说，只要符合了USB接口标准的设备就都可以插进来”

实例一：

interface USB{    public void start();//USB设备开始工作    public void stop();//USB设备结束工作}class Computer{    public static void plugin(USB usb){        usb.start();        System.out.println("==========USB 设备工作==========");        usb.stop();        }}class Flash implements USB{    public void start(){        System.out.println("U盘开始工作");    }    public void stop(){        System.out.println("U盘停止工作");    }}class Print implements USB{    public void start(){        System.out.println("打印机开始工作");    }    public void stop(){        System.out.println("打印机停止工作");    }};public class InterfaceCaseDemo02{    public static void main(String args[]){        Computer.plugin(new Flash());        Computer.plugin(new print());    }}

如果深入学习的话，接口实际上还表示将方法的视图暴露给远程的客户端

3.4工厂设计模式

工厂设计模式，是在java开发中最常使用的一种设计模式

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("***吃橘子");    }}public InterfaceDemo03{    public static void main(String args[]){        Fruit f = new Apple();        f.eat();    }}

分析：主方法：应该就表示一个客户端，主方法的代码越少越好。此时，直接在主方法中指定了要操作的子类，如果要更换子类，则肯定要修改客户端。就表示跟特定的子类紧密耦合在一起了。
JVM的工作原理：程序->JVM->操作系统

问题的解决：
通过过度端在程序中就称为工厂模式

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;    }};public class InterfaceDemo05{    public static void main(String args[]){        Fruit f = Factory.getInstance(args[0]);        if(f!=null){            f.eat();        }    }}

3.5代理模式

假设现在有以下几种情况：
1.张三借李四 50000000这么多钱
2.李四不还了，张三生气了
3.张三找到王五，王五是要债公司
4.王五准备了枪支，绳索，刀子，刑法工具
5.王五把李四欠张三的钱要回来了
也就是说：张三委托王五跟李四要钱，也就是说王五代理了张三的请求

interface NetWork{    public void browse();//浏览}class Real implements NetWork{    public void browse(){        System.out.println("上网浏览信息");    }}class Proxy implements NetWork{    private NetWork network;    public Proxy(NetWork network){        this.network = network;    }    public void check(){        System.out.println("检查用户是否合法.");    }    public void browse(){        this.check();        this.network.browse();//调用真实用户主题操作    }}public class ProxyDemo{    public static void main(String args[]){        NetWork net = null;        net = new Proxy(new Real());//指定代理操作        net.browse();    //客户只关心上网浏览一个操作    }}

3.6适配器设计
此设计在今后的图形设计方面使用的很多。
例如：如果一个子类实现了一个接口，则肯定在子类中必须覆写此接口中的全部抽象方法，那么这样一来，如果一个接口中提供抽象方法过多，而且，没有必要全部实现的话，肯定很浪费。

实例一：

interface Window{    public void open();    public void close();    public void activated();    public void iconified();    public void deiconified();};abstract class WindowAdapter implements Window{    public void open(){};    public void close(){};    public void activated(){};    public void iconified(){};    public void deiconified(){};}class WindowImpl extends WindowAdapter{    public void open(){        System.out.println("窗口打开");    }    public void close(){        System.out.println("窗口关闭");    }}public class AdapterDemo{    public static void main(String args[]){        Window win = new WindowImpl();        win.open();        win.close();    }}

3.7内部类的扩展

之前已经讲过内部类的概念。实际上在一个抽象类中还可以包含一个接口。

abstract class A{//定义抽象类    public abstract void printA();    //抽象方法    interface B{//定义内部接口        public void printB();//定义抽象方法    }}class X extends A{    public void printA(){        System.out.println("Hello--->A");    }    class Y implements B{        public void printB(){            System.out.println("Hello--->B");        }    }}public class InnerExtDemo01{    public static void main(String args[]){        A.B b = new X().new Y();        b.printB();    }}

反之，在接口中也可以定义一个抽象类。

interface A{    public void printA();    //抽象方法    abstract class B{        public abstract void printB();    //定义抽象接口    }};class X implements A{    public void printA(){        System.out.println("hello--->A");    }    class Y extends B{        public void printB(){            System.out.println("hello--->B");        }    }}public class InnerExtDemo02{    public static void main(String args[]){        A.B b = new X().new Y();        b.printB();    }}

但是，从实际的个人开发角度来讲，此种设计并不是很常见，因为代码的结构有些混乱了。

3.8、抽象类与接口之间的关系

重要的提示:
    在开发中，一个类永远不要去继承一个已经实现好的类，要么继承抽象类，要么实现接口，如果接口和抽象类同时都可以使用的话，那么优先使用接口，避免单继承局限。

4.总结：
1.抽象类和接口实例化：通过对象多态性。
2.抽象类表示一个模板，接口制定的是一个标准。
3.常见的设计模式：模板设计、工厂设计、代理设计、适配器设计。