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

本章目标：

掌握抽象类及接口的实例化操作

掌握模板设计的作用

掌握工厂设计模式应用

掌握代理设计模式应用

掌握适配器设计模式应用

掌握抽象类与接口的使用区别

为抽象类与接口实例化

在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.常见的设计模式：模板设计、工厂设计、代理设计、适配器设计。

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

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method