• day40 设计模式、jdk8新特性

    一、代理模式

    为其他对象提供一种代理控制此对象的访问

    若一个对象不适合直接引用另一个对象，

    代理对象在客户端和目标对象之间起到中介作用

    组成：

    抽象角色：通过接口 抽象类 真实角色实现了哪些方法

    代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法

    可以附加自己的操作

    真实角色：实现抽象角色，定义业务逻辑，供代理角色来调用

    1. 代理模式分类

      • 静态代理

      • 动态代理

        • JDK动态代理

        • cglib动态代理

    2. 静态代理： 抽象角色固定， 代理角色和代理的真实角色是固定。

    3. 动态代理

      通过反射机制来实现的，代理角色不在是固定的角色，而是一个通用的工具类，还可以代理很多操作

    动态代理是在静态代理的基础上，代理的真实角色由设置好的固定的一个变成自由的多个，实现更广泛的应用。

    动态代理的代理角色类Proxyutil需要实现接口InvocationHandler

    1. public class ProxyUtil经纪人 implements InvocationHandler {
    2.     private Object obj;
    3.  
    4.     public Object newProxyInstance(Object obj){
    5.         this.obj = obj;
    6.         return Proxy.newProxyInstance(this.obj.getClass().getClassLoader(),
    7.                 obj.getClass().getInterfaces(),
    8.                 this);
    9.     };
    10.  
    11.     @Override
    12.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    13.         return method.invoke(obj,args);
    14.     }
    15. }

    /**
     * 代理角色：
     */
    public class 经纪人 implements InvocationHandler {
        //真实角色，由于任何角色都可以使用此工具类，所以将真实角色定义成Object
        private Object obj;

        /**
         * 功能：创建真实角色，通过调用方法，获取代理角色代理的对象
         * @return
         */
        public Object newProxyInstance(Object obj){
            this.obj = obj;
            /*
                Proxy这个类是用于设置代理
                 newProxyInstance(
                                  ClassLoader loader, 参数1：类的加载器
                                  Class[] interfaces, 参数2.类的接口
                                  InvocationHandler h)  参数3： 本类的实例

              通过 newProxyInstance方法获取真实对象的接口，从而创建代理实例

             */
            Object o = Proxy.newProxyInstance(
                    this.obj.getClass().getClassLoader(), //我是谁？  真实对象
                    obj.getClass().getInterfaces(), //我干爹是谁？ 真实对象实现的接口
                    this // 代理是谁， 你要实现哪个接口
            );
            return o;
        }

        //用反射的方法调用真实角色中的方法

        /**
         *
         * @param proxy 代理对象
         * @param method 代理有哪些方法
         * @param args 包含传入代理实例上方法调用的参数值的对象数组
         * @return
         * @throws Throwable
         */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            return method.invoke(obj,args);
        }
    }

    1.  经纪公司 经纪公司 = new 经纪公司() {
    2.             @Override
    3.             public void 吃饭() {
    4.             }
    5.             @Override
    6.             public void 跳舞() {
    7.             }
    8.             @Override
    9.             public void 唱歌() {
    10.             }
    11.         };

    代理类实现了所代理的接口，可以在调用代理类方法时调用被代理的对象实现的方法。因此，当使用动态代理时，需要将代理对象转换为被代理对象的接口类型。

    二、原型模式

    原型模式用于创建重复对象 保证性能  这种类型的设计属于创建创建型模式

    方式是有一个原型接口

    父类实现Cloneable接口 

    1.   @Override
    2.     protected Object clone()  {
    3.         Object clone = null;
    4.         try {
    5.             clone = super.clone();
    6.         } catch (CloneNotSupportedException e) {
    7.             e.printStackTrace();
    8.         }
    9.         return clone;
    10.     }

    三、JDK8新特性

    支持Lambda表达式：是一种特殊的匿名内部类形式，语法更加简洁

    允许把函数作为一个方法的参数，将代码像数据一样进行传递

    基本语法：

    函数式接口 变量名 =  （参数，参数）—> {方法体}

    注意事项：

    形参列表数据类型会自动推断

    如果形参列表为空，只需要保留（）

    如果形参只有一个，（）可以省略，只需要参数名即可

    如果执行的代码只有一句话且无返回值 { }可省略，

    Lambda不会生成一个单独的内部类文件

    四、函数式接口

    如果一个接口只有  **一**个 抽象方法 该接口称之为函数式接口

    函数式接口可以使用Lambda，lambda表达式会自动匹配到这个抽象方法上

    @FunctionalInterface

    常见的函数式接口：

    Consumer消费型接口

    Supplier供给型接口

    Function函数型接口

    Predicate 断言型接口

    1. ackage com.oracle.methodinterface2;
    2.  
    3. import java.util.*;
    4. import java.util.function.Consumer;
    5. import java.util.function.Function;
    6. import java.util.function.Predicate;
    7. import java.util.function.Supplier;
    8.  
    9. /**
    10.  * 四个常见的函数式接口
    11.  * 1. Consumer  消费型接口  表示接受单个输入参数并且不返回结果的操作
    12.  */
    13. public class MethodInterface {
    14.     public static void main(String[] args) {
    15.         //1. Consumer  消费型接口
    16.         //匿名内部类的方式
    17.         Consumer consumer = new Consumer() {
    18.             @Override
    19.             public void accept(Double money) {
    20.                 System.out.println("聚餐消费：" + money);
    21.             }
    22.         };
    23.         happy(consumer, 500);
    24.  
    25.         //Lambda表达式写法
    26.         Consumer con = money -> System.out.println("聚餐消费：" + money);
    27.         happy(con,300);
    28.  
    29.         happy(money -> System.out.println("唱歌消费：" + money),1000);
    30.         happy(money -> System.out.println("洗澡消费" + money),2000);
    31.         happy(money -> System.out.println("足疗消费" + money),3000);
    32.  
    33.  
    34.         Supplier supplier = new Supplier() {
    35.             @Override
    36.             public Integer get() {
    37.                 return new Random().nextInt(100);
    38.             }
    39.         };
    40.  
    41.         int[] num = getNum(supplier,10);
    42.         System.out.println(Arrays.toString(num));
    43.  
    44.         int[] num1 = getNum(() -> new Random().nextInt(100),8);
    45.         System.out.println(Arrays.toString(num1));
    46.  
    47.  
    48.        // 3. Function
    49.         String str = handlerStr(s -> s.toUpperCase(), "zhangsan");
    50.         System.out.println(str);
    51.  
    52.         String str2 = handlerStr(s -> s.trim(), "      zhang       ");
    53.         System.out.println(str2);
    54.  
    55.  
    56.         //4. //4.Predicate  的使用
    57.         List names = new ArrayList<>();
    58.         names.add("张三丰");
    59.         names.add("张无忌");
    60.         names.add("宋远桥");
    61.         names.add("俞莲舟");
    62.         names.add("俞岱岩");
    63.         names.add("张松溪");
    64.         names.add("张翠山");
    65.         names.add("殷梨亭");
    66.         names.add("莫声谷");
    67.  
    68.         List list = filterName(s -> s.startsWith("张"), names);
    69.         System.out.println(list);
    70.  
    71.  
    72.     }
    73.  
    74.     // 1.Consumer  消费型接口
    75.     public static void happy(Consumer con, double money) {
    76.         con.accept(money);
    77.     }
    78.  
    79.     //2. SUpplier 供给型接口  给方法提供数据
    80.     public static int[] getNum(Suppliersup,int count){
    81.         int[] arr = new int[count];
    82.         for (int i = 0; i < count; i++) {
    83.             arr[i] = sup.get();
    84.         }
    85.         return arr;
    86.     }
    87.  
    88.     //3. Function    函数式接口  对传入数据进行操作后返回 T 传入的数据，  R 返回的数据
    89.     public static String handlerStr(Function fun,String str){
    90.         return  fun.apply(str);
    91.     }
    92.  
    93.     //4.Predicate  断言型接口  判断，返回boolean类型
    94.     public static List filterName(Predicate pre, List list){
    95.         List resultList = new ArrayList<>();
    96.         for (String s : list) {
    97.             if(pre.test(s)){
    98.                 resultList.add(s);
    99.             }
    100.         }
    101.         return resultList;
    102.     }
    103.  
    104. }

    五、方法引用

    方法应用是Lambda表达式的一种简写形式。如果lambda表达式只是调用类已经存在的方法、则可以使用方法引用。

    对象：：实例方法

     类：：静态方法

    类：：实例方法

    类：：new

    1.   //1. 对象：：实例方法
    2.         Consumer con = s -> System.out.println(s);
    3.         con.accept("Hello");
    4.  
    5.         Consumer con2 = System.out::println;
    6.         con2.accept("World");
    7.  
    8.         //2. 类：：静态方法
    9.         /**
    10.          *  static int compare(int x, int y)
    11.          * 比较两个 int数字值。
    12.          */
    13.        // Comparator com = (o1,o2)->Integer.compare(o2,o1);
    14.         Comparator com2 = Integer::compare;
    15.         Set set = new TreeSet<>(com2);
    16.         set.add(1);
    17.         set.add(2);
    18.         set.add(3);
    19.         set.add(4);
    20.         set.add(5);
    21.         set.add(6);
    22.         set.add(7);
    23.         System.out.println(set);
    24.  
    25.         // 类：：实例方法
    26.         Function fun = s -> s.getName();
    27.         Function fun2 = Student::getName;
    28.  
    29.         //类：：new
    30.         Supplier sup = () ->new Student();
    31.         Supplier sup2 = Student::new;
    32.  
    33.         Student student = sup2.get();
    34.         System.out.println(student);
    35.  
    36.         List list = new ArrayList<>();
    37.         list.add("宋江");
    38.         list.add("卢俊义");
    39.         list.add("公孙胜");
    40.         list.add("吴用");
    41.         list.add("关胜");
    42.         list.add("林冲");
    43.  
    44.         //list.forEach(s-> System.out.println(s));
    45.         list.forEach(System.out::println);
    46.  
    47.     }
    48. }

  • 相关阅读:
    StyleLint入门配置
    okcc坐席进线太慢，怎么办？
    千峰商城-springboot项目搭建-82-订单提交及支付-支付回调
    QListWidget 类使用教程
    galeracluster高可用集群异常恢复
    专题 递归与递推
    一、八大排序（sort）
    C#的基本知识（1）
    栈的实现（c语言）
    python内置函数+lambda函数
  • 原文地址：https://blog.csdn.net/weixin_45939821/article/details/132869096