接口（策略设计模式）

最新推荐文章于 2024-08-21 17:27:05 发布

aihuai2731

最新推荐文章于 2024-08-21 17:27:05 发布

阅读量328

点赞数

文章标签：设计模式 java

原文链接：http://www.cnblogs.com/jiang0123/p/11192077.html

版权

总结接口的知识点

（菜鸟一只，有侵权或者不足之处请指出，谢谢）

Java接口

　　　接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

语法：
使用关键字interface关键字来定义。

注意：定义的接口文件仍然是.java文件。虽然声明的时候使用interface关键字，编译之后仍然是.class

　　　　接口可以理解为一种特殊的类（可以看成100%的抽象类），里面全部是由常量和公共的抽象方法所组成，接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定行为标准的。

（1）我们不能直接去实例化一个接口，因为接口中的方法都是抽象的，是没有方法体的。

　　但是，我们可以使用接口类型的引用指向一个实现了该接口的对象，并且可以调用这个接口中的方法。（实际上就是使用了Java中多态的特性），比如：

　　IStraegy con = new BackDoor();(语法：接口名接口类指引名 = new 实现了接口对象() )

　　con.operate();//通过接口类指引名调用方法

　　（个人觉得这是非常实用的）

（2）一个类可以实现不止一个接口。

（3）接口也可以继承，并且可以多继承，所以接口可以用来弥补类无法实现多继承的局限。

（4）一个类如果要实现某个接口的话，那么它必须要实现这个接口中的所有方法。

（5）接口中所有的方法都是抽象方法，所有的属性都是public static final的。接口类的中的抽象方法和接口的成员变量访问权限都是public，写和不写都是这个权限，实现类中的方法的权限也必须是public。否则报错！！！

（6）接口可以用来实现解耦

/*
 * Lambda表达式就是接口的实现的一种方式，Lambda表达式的参数列表就是接口中抽象方法的参数列表
 * Lambda表达式中所需要执行的功能就是接口中抽象方法具体实现要执行的功能
 * 
 * 左侧： Lambda表达式的参数列表
 * 右侧： Lambda表达式中所需要执行的功能，即Lambda体
 * 
 */

public class LambdaDemo {
    public static void main(String[] args) {
        
        test1();//实现的接口无参 无返回值   
        
        test2("hello lambda from test2");//实现的接口有一个参数 无返回值
        
        
    }
    /*
     *  语法格式一 ：实现的接口无参 无返回值   
     *    左侧直接写()  ,右侧是实现接口的功能
     *    () -> System.out.println("Hello Lambda");
     */
    public static void test1(){
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World from test1");
            }
        };
        r1.run();
 
        System.out.println("--------------------------------");
        
        //用lambda语法写
        Runnable r2 = () -> System.out.println("Hello Lambda from test1");//实现Runnable接口
        r2.run();
    }
    /*
     *  语法格式二 ：实现的接口有一个参数 无返回值
     *  (X) -> System.out.println(x);
     *  当左侧有且只有一个参数时，左侧括号可以省略
     *  X -> System.out.println(x);
     */
    public static void test2(String str){
        
        Consumer<String> con = (x) -> System.out.println(x);//实现consumer接口
        con.accept(str);
        
        System.out.println("--------------------------------");
        
        //lambda语法写
        Consumer<String> con1 = x -> System.out.println(x);//实现consumer接口
        con.accept(str);
        
    }

}

接口实现策略设计模式实例：

//接口
interface IStraegy{
    public void operate();
}
//锦囊1
class BackDoor implements IStraegy{
    @Override
    public void operate() {
        System.out.println("找乔国老帮忙，让吴国不杀刘备");
    }
}

//锦囊2
class GoBack implements IStraegy{
    @Override
    public void operate() {
        System.out.println("找吴国太帮忙，回国");
    }
}
//锦囊3
class BackThree implements IStraegy{
    @Override
    public void operate() {
        System.out.println("孙尚香断后");
    }
}
//环境类
class Context{
    
    private IStraegy istraegy;
    
    //构造器
    //接口类型的引用指向一个实现了该接口的对象，这里传入实现了该接口的对象
    public Context(IStraegy istraegy) {
        this.istraegy = istraegy;
    }
    
    public void operate() {
        this.istraegy.operate();
        
    }
}
//策略设计模式
public class TextDemo02 {
    
    public static void main(String[] args) {
        //使用一个接口引用指向对象
        //USB接口类引用可以指向一个实现了USB接口的对象
//        IStraegy con = new BackDoor();
//        con.operate();
        
        Context context;
        System.out.println("----刚到，拆第一个锦囊-----");
        
        context = new Context(new BackDoor());
        context.operate();
        
        System.out.println("\n\n");
        
        System.out.println("-----刘备乐不思蜀，拆第二个锦囊-----");
        context = new Context(new GoBack());
        context.operate();
        
        System.out.println("\n\n");
        
        System.out.println("----孙权追兵，拆第三个锦囊-----");
        context = new Context(new BackThree());
        context.operate();
        
        System.out.println("赔了夫人又折兵");
    }
}

该实例中使用了简单的策略设计模式（策略设计模式：体现了高内聚，低耦合）

简单介绍策略设计模式

策略（Strategy）模式

　　　　该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。

语法：

(1)抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。
(2)具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。
(3)环境（Context）类：持有一个策略类的引用，最终给客户端调用。

策略模式的主要优点如下。