Java-java疯狂讲义-第六章面向对象（下）-6.6Java9改进的接口

迷南。 2023-05-30 03:48 3阅读 0赞

## 6.6Java9改进的接口 ##

抽象类如果抽象的更彻底就是接口

### 6.6.1接口的概念 ###

类是具体的实现，接口是一种规范。接口体现的是一种设计和实现分离的原则。

### 6.6.2Java9中接口的定义  ###

接口定义不适用class，使用interface。默认public修饰符。一个接口可以有多个直接接口，但是不能继承类。

【修饰符】 interface 接口名 extends 接口1，接口2
    {
        。。。。。todo
    }

忧郁接口定义是一种规范，因此接口里面不能包含构造器、初始化块定义。接口包含成员变量（只能是静态常量）、方法（只能是抽象实例方法、类方法、默认方法或者私有方法）、内部类（包括内部接口、枚举）

PS：对比接口和类的定义方式，不难发现接口的成员比类里的成员少了两种，而且接口里的成员变量只能是静态常量，接口里的方法只能是抽象方法、类方法、默认方法或私有方法。

package com.cdmt.demo.abstractclass;
    
    /**
     * @ClassName: Output
     * @Description: 定义一个接口
     **/
    public interface Output {
        //接口里定义的成员变量只能是常量,默认public static final修饰
        //直接跟public static final  int MAX_CACHE_LINE = 50;效果一样
        int MAX_CACHE_LINE = 50;
        //接口里定义普通的方法只能是public的抽象方法
        void out();
        void getData(String msg);
        //在接口中定义默认方法，需要使用default修饰
        default void print(String ...msgs){
            for(String msg : msgs){
                System.out.println(msg);
            }
        }
        //在接口中定义默认方法,需要使用default修饰
        default void test(){
            System.out.println("默认test（）方法");
        }
        //在接口中定义类方法，需要使用static修饰
        static String staticTest(){
            return "接口里的类方法";
        }
        //定义私有方法，Java9才有主要提供接口里的工具，不能与default一起使用，可以使用static
        private void foo(){
            System.out.println("foo的私有方法");
        }
        //定义私有静态方法，Java8使用私有会报错，接口私有方法成为类的方法也可以成为实例方法
        private static void bar(){
            System.out.println("bar 私有静态方法");
        }
    }

PS：Java9提供了私有方法，可以为类方法，也可以成为私有方法。Java8允许接口定义默认方法，默认方法必须使用default修饰。Java9的私有方法是Java8默认方法埋下的伏笔。

### 6.6.3接口的继承  ###

接口的继承和类继承不一样，接口支持多继承，即一个接口可以有多个直接父类接口。

### 6.6.4使用接口 ###

【修饰符】 class 类名 extends 父类 impleaments 接口1，接口2
    {
        。。。。。todo
    }

### 6.6.5接口与抽象类 ###

接口和抽象类相同点：

1.  接口和抽象类都不能被实例化，用于其他类的实现和继承
2.  接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。

接口和抽象类不同点：

1.  接口是一种规范，在系统中是总纲，一般不会随便改变。抽象类作为多个子类的共同父类，体现的是一种模板设计模式
2.  接口不能包含不同方法，抽象类可以
3.  接口指定定义静态常量，抽象类常量、普通变量都可以定义
4.  接口不含构造器，抽象类可以包含构造器
5.  接口不包含初始化块，抽象类可以
6.  一个类只能有一个直接父类，包括抽象类。一个类可以实现多个接口

### 6.6.6面向接口编程 ###

接口体现一种规范和实现分离的设计思想。充分利用接口可以降低程序各模块间的耦合，从而提高程序的扩展性和维护性。

1.简单工厂模式

我们要做一个output接口，实现打印机功能，然后有两个打印机对象类Printer和HpPrinter继承output接口标准。还有一个Factory工厂类来判断使用到底哪个打印机。

接口：

打印机类：

package com.cdmt.demo.abstractclass;
    
    /**
     *
     * @ClassName: Printer
     * @Description: TODO
     **/
    public class Printer implements Output {
        @Override
        public void out() {
            System.out.println("Printer的out方法");
        }
    
        @Override
        public void getData(String msg) {
            System.out.println("Printer的getData方法");
        }
    
        @Override
        public void print(String... msgs) {
            System.out.println("Printer的getData方法:"+msgs);
        }
    
        @Override
        public void test() {
            System.out.println("Printer的test方法:");
        }
    }

package com.cdmt.demo.abstractclass;
    
    /**
     * @ClassName: HpPrinter
     * @Description: TODO
     **/
    public class HpPrinter implements Output{
        @Override
        public void out() {
            System.out.println("Hp的out方法");
        }
    
        @Override
        public void getData(String msg) {
            System.out.println("Hp的getData方法");
        }
    
        @Override
        public void print(String... msgs) {
            System.out.println("Hp的print方法"+msgs);
        }
    
        @Override
        public void test() {
            System.out.println("Hp的test方法");
        }
    }

电脑类中组合了output接口对象：

package com.cdmt.demo.abstractclass;
    
    /**
     * @ClassName: Computer
     * @Description: TODO
     **/
    public class Computer {
        private Output out;
    
        public Computer(Output out) {
            this.out = out;
        }
    
        public void keyIn(String msg){
            out.getData(msg);
        }
    
        public void print(){
            out.out();
        }
    }

工厂类兼测试方法：

package com.cdmt.demo.abstractclass;
    
    /**
     * @ClassName: OutputFactory
     * @Description: TODO
     **/
    public class OutputFactory {
    
        public OutputFactory() {
        }
    
        public Output getOutput(String s){
            if(s.equals("Printer")){
                return new Printer();
            }
            if(s.equals("HpPrinter")){
                return new HpPrinter();
            }
            return null;
        }
        public static void main(String[] args) {
            OutputFactory of = new OutputFactory();
            Computer c = new Computer(of.getOutput("Printer"));
            c.keyIn("aaaaaa");
            c.keyIn("bbbbbb");
            c.print();
            System.out.println("--------------------------------");
            Computer hp = new Computer(of.getOutput("HpPrinter"));
            hp.keyIn("aaaaaa");
            hp.keyIn("bbbbbb");
            hp.print();
        }
    }

结果：

![20191107135010662.png][]

总结上面实现一个简单工厂的设计模式。所谓设计模式，就是对经常出现的软件问题的一种成熟解决方案。

2.命令模式

某个方法 需要完成某一个行为，但是这个行为的具体实现无法确定，必须等到执行该方法的时候才可以确定。

PS：可以把处理行为作为参数传入该方法。Java8Lambda表达式可以传入代码块作为参数

设计针对数组操作的方法，一个指令接口，当调用方法时才执行数组调用指令

接口：

package com.cdmt.demo.CommandMode;
    
    /**
     *
     * @ClassName: Command
     * @Description: TODO
     **/
    public interface Command {
    
        //接口定义的process方法用于封装处理行为
        void process(int[] target);
    }

接口实现类：

package com.cdmt.demo.CommandMode;
    
    /**
     *
     * @ClassName: AddCommand
     * @Description: TODO
     **/
    public class AddCommand implements  Command{
        @Override
        public void process(int[] target) {
            int sum = 0;
            for(int tmp : target){
                sum += tmp;
            }
            System.out.println("数组元素的总和是： " + sum);
        }
    }

package com.cdmt.demo.CommandMode;
    
    /**
     *
     * @ClassName: PrintCommand
     * @Description: TODO
     **/
    public class PrintCommand implements Command{
        @Override
        public void process(int[] target) {
            for(int tmp : target){
                System.out.println("打印目标数组元素: " + tmp);
            }
        }
    }

针对数组操作的工具类：

package com.cdmt.demo.CommandMode;
    
    /**
     * @ClassName: ProcessArray
     * @Description: 一个对素组的处理类
     **/
    public class ProcessArray {
        //一个对素组的处理类
        public void process(int[] target , Command cmd){
            cmd.process(target);
        }
    }

测试类：

package com.cdmt.demo.CommandMode;
    
    /**
     * @ClassName: CommandModeTest
     * @Description: TODO
     **/
    public class CommandModeTest {
        public static void main(String[] args) {
            ProcessArray pa1 = new ProcessArray();
            ProcessArray pa2 = new ProcessArray();
            int[] target = {3,-4,1,1};
    
            pa1.process(target,new PrintCommand());
            pa1.process(target,new AddCommand());
        }
    }

结果：

![20191107143137116.png][]

总结：

命令模式实现一种实现和处理方式分离的设计思路

[20191107135010662.png]: https://img-blog.csdnimg.cn/20191107135010662.png
[20191107143137116.png]: https://img-blog.csdnimg.cn/20191107143137116.png