day23【设计模式】、单例设计模式、 多例设计模式、代理模式、动态代理、工厂设计模式

最新推荐文章于 2022-03-28 17:59:42 发布
最新推荐文章于 2022-03-28 17:59:42 发布
阅读量171 收藏
点赞数
分类专栏： 【模块1】JAVAEE进阶模块 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44845814/article/details/105322008
版权

day23【设计模式】

反馈和复习
1.File[读音:fail]
2.SAXReader read方法  
    public class TestDemo {
    public static void main(String[] args) throws DocumentException {
        SAXReader reader = new SAXReader();
        // 根目录下的books.xml
        Document document1 = reader.read(new File("books.xml")); 
        //根目录下day23模块下的books.xml
        Document document2 = reader.read(new File("day23/books.xml"));
        //在src下的books.xml
        InputStream in = TestDemo.class.getResourceAsStream("/books.xml");
        Document document3 = reader.read(in); 
    }
}

复习:
1.XML语法(不再啰嗦)
2.XML约束(DTD,Schema)
    我们重点是根据约束写出符合规则的文档(IDEA提示)
3.XML的解析
    a.直接解析
    SAXReader reader = new SAXReader();
	Document document = reader.read(new File("books.xml")); 
	Element rootElement = document.getRootElement();
	List<Element> elements = rootElement.elements();
	getName();//获取标签名
	getText();//获取标签内容
	attributeValue(String attrName);//获取标签某个属性值

	b.集合XPath
    List<Element> elements = selectNodes(String xpath);  
	Element element = selectSingleNode(String xpath);
今日内容
设计模式!【重点】
1.单例设计模式
2.多例设计模式
3.动态代理【超难,现在1次,web阶段1次,框架阶段1次】  
    今日目标: 把格式学会(怎么用)
4.工厂设计模式(解耦) 
5.Lombok【自学】

第一章 单例设计模式【重点】

1. 单例设计模式介绍
a.正常情况下一个类可以创建多个对象
b.单例设计模式作用就是让某个类只能有一个对象
2. 单例设计模式实现步骤
a.将构造方法私有化(不让别人直接new对象)
b.在该类内部产生一个唯一的实例化对象,并且使用private static修饰 
c.提供一个public staic 的静态方法,该方法返回这个静态对象
3 单例设计模式的类型
懒汉式:
	不立即创建本类的对象,当别人调用静态方法获取本类的对象时,才去创建
饿汉式: 
	先把对象创建出来,当别人调用静态方法获取本类的对象时,直接返回对象即可
4, 饿汉单例设计模式
/**
 * 要求Dog类采用单例模式中的饿汉式
 */
public class Dog {

    //3.提供一个静态方法,获取dd对象
    public static Dog getInstance(){
        return dd;
    }

    //2.自己定义一个对象
    private static final Dog dd = new Dog();

    //1.私有化构造
    private Dog(){

    }
}

public class TestDog {		
    public static void main(String[] args) {
        //1.获取Dog对象
        for (int i = 0; i < 5; i++) {
            Dog dog = Dog.getInstance();
            System.out.println(dog);
        }
    }
}

输出结果:
com.itheima.demo02_singleInstance.Dog@14ae5a5
com.itheima.demo02_singleInstance.Dog@14ae5a5
com.itheima.demo02_singleInstance.Dog@14ae5a5
com.itheima.demo02_singleInstance.Dog@14ae5a5
com.itheima.demo02_singleInstance.Dog@14ae5a5
5. 懒汉单例设计模式
/**
 * 要求Cat类采用单例模式中的懒汉式
 */
public class Cat {

    //1.私有化构造
    private Cat(){}

    //2.内部定义一个Cat类的对象
    private static Cat cc = null;

    //3.提供静态方法,多线程情况下 需要使用synchronized保证该方法的原子性
    public synchronized static Cat getInstance(){
        //判断
        if (cc == null) {
            //如果不加synchronized,可能会出现
            //线程1执行到这,被线程2抢走了
            //线程2也进来了,执行到这
            cc = new Cat();
        }
        //再返回
        return cc;
    }
}

public class TestCat {
    public static void main(String[] args) {
        //1.获取Cat对象
        for (int i = 0; i < 5; i++) {
            Cat cc = Cat.getInstance();
            System.out.println(cc);
        }
    }
}

输出结果:
com.itheima.demo02_singleInstance.Cat@14ae5a5
com.itheima.demo02_singleInstance.Cat@14ae5a5
com.itheima.demo02_singleInstance.Cat@14ae5a5
com.itheima.demo02_singleInstance.Cat@14ae5a5
com.itheima.demo02_singleInstance.Cat@14ae5a5

第二章 多例设计模式【重点】

1. 多例设计模式的介绍
多例设计模式保证我们的类具有指定个数的对象
2. 多例设计模式的实现步骤
a.私有化构造(不让别人可以正常创建对象)
b.在类内部创建一个private static修饰的集合,用于保存我们自己创建的对象
c.使用静态代码块,向集合中添加指定个数对象
d.通过一个public static静态方法,随机返回集合中的某个对象
3. 多例设计模式的代码实现
/**
 * 要求Pig类使用多例设计模式
 */
public class Pig {
    //0.定义一个变量,指定集合中对象个数
    private static final int COUNT = 4;

    //1.私有化构造
    private Pig() {
    }

    //2.创建一个集合
    private static ArrayList<Pig> list = new ArrayList<Pig>();

    //3.静态代码块
    static {
        //添加指定个数的对象
        for (int i = 0; i < COUNT; i++) {
            list.add(new Pig());
        }
    }

    //4.提供一个静态方法
    public static Pig getInstance() {
        int index = new Random().nextInt(COUNT);
        Pig pig = list.get(index);
        return pig;
    }
}
public class TestPig {
    public static void main(String[] args) {
        //1.获取Pig对象
        for (int i = 0; i < 10; i++) {
            Pig p1 = Pig.getInstance();
            System.out.println(p1);
        }
    }
}

输出结果:
com.itheima.demo03_multiInstance.Pig@7f31245a	【1】
com.itheima.demo03_multiInstance.Pig@6d6f6e28	【2】
com.itheima.demo03_multiInstance.Pig@135fbaa4	【3】
com.itheima.demo03_multiInstance.Pig@45ee12a7	【4】
com.itheima.demo03_multiInstance.Pig@135fbaa4	【重复】
com.itheima.demo03_multiInstance.Pig@6d6f6e28	【重复】
com.itheima.demo03_multiInstance.Pig@7f31245a	【重复】
com.itheima.demo03_multiInstance.Pig@7f31245a	【重复】
com.itheima.demo03_multiInstance.Pig@7f31245a	【重复】
com.itheima.demo03_multiInstance.Pig@135fbaa4	【重复】

第三章 动态代理【理解】

3.1 代理模式介绍

  • 什么是代理

    代理就是被代理者,没有能力或者不愿意完成某件事情,找一个可以帮助其完成该事件的对象,该对象称为代理

  • 生活中的代理

    我们 通过 中介(房东的代理) 找房东租房子
我们 通过 外卖平台(店家代理) 订饭吃

    在这里插入图片描述

  • 代码中的代理案例

    a.用户登录到我们的系统后，我们的系统会为其产生一个ArrayList集合对象，内部存储了一些用户信息
b.这个对象需要被传给后面的很多其它对象，但要求其它对象不能对这个ArrayList对象执行添加、删除、修改操作，只能get()获取元素
c.分析: 我们无法控制用户如何操作集合,我们可以给这个集合找一个代理,判断他会判断方法,如果是和增删改有关的直接抛出异常(不让操作),如果是获取相关的找到真正得被代理集合,获取数据即可

 
/**
 * 此类就是普通ArrayList类的代理
 */
//1.让代理对象实现被代理对象一样的接口,目的是让代理对象和被代理对象具有一样的方法
public class ArrayListProxy implements List<String>{
    //2.要在代理对象中保存一个被代理对象
    private ArrayList<String> list;

    public ArrayListProxy(ArrayList<String> list) {
        this.list = list;
    }

    //3.下面的一堆方法中,如果是不修改集合数据的方法,就调用list的方法
    //如果是修改集合的方法,直接抛出异常
    @Override
    public boolean add(String s) {
        //直接抛出异常
        throw new UnsupportedOperationException("不允许调用add方法");
    }
    @Override
    public String get(int index) {
        return list.get(index);
    }
    @Override
    public String set(int index, String element) {
        //直接抛出异常
        throw new UnsupportedOperationException("不允许调用set方法");
    }
    @Override
    public String remove(int index) {
        //直接抛出异常
        throw new UnsupportedOperationException("不允许调用remove方法");
    }
}

public class TestProxyDemo {
    public static void main(String[] args) {
        //1.创建一个ArrayList
        ArrayList<String> arr = new ArrayList<String>();
        //保存用户的信息
        arr.add("张三");
        arr.add("18");
        arr.add("北京中关村");
        arr.add("188888块");

        //2.要集合arr先交给代理对象
        List<String> list = getArrayListProxy(arr);

        //3.操作
//        list.add("李四");  抛出异常!
//        list.remove(1); 抛出异常!
//        list.set(1, "28"); 抛出异常!
        System.out.println(list.get(2)); //OK 正常操作
    }

    public static List<String> getArrayListProxy(ArrayList<String> arr) {
        //创建一个ArrayList的代理
        ArrayListProxy arrayListProxy = new ArrayListProxy(arr);
        //返回代理对象
        return arrayListProxy;
    }
}
3.2 动态代理概述
动态代理和静态代理区别在于代理类是否已经写好,
	上面案例中就是静态代理,代理类ArrayListProxy已经编译时期定义好了
    而动态代理,它的代理类在运行时期通过代码动态生成!!!
     
动态代理的作用:
	拦截对真实对象(被代理对象)方法的直接访问，增强真实对象(被代理对象)方法的功能进行增强(减弱)

3.3 案例引出

public class DynamicProxy {
    public static void main(String[] args) {
        //1.创建一个ArrayList
        ArrayList<String> arr = new ArrayList<String>();
        //保存用户的信息
        arr.add("张三");
        arr.add("18");
        arr.add("北京中关村");
        arr.add("188888块");

        //2.使用arr这个集合,生成一个它的代理
        List<String> list = Collections.unmodifiableList(arr);
		//unmodifiableList 该方法返回的就是arr的代理对象,类似于我们自己的ArraylistProxy对象
        //但是unmodifiableList生成的代理对象,是通过动态方式在运行时期创建出来
        //3.调用方法
//        list.add("李四");
//        list.remove(1);
//        list.set(1, "28");
        System.out.println(list.get(2));
    }
}

3.4 重点类和方法

1.java.lang.reflect.Proxy类 他可以为我们动态生成一个对象的代理对象
    public static Object newProxyInstance(
    ClassLoader classLoader, //类加载器,一般我们使用和被代理对象一样类加载器
    Class[] interfaces, // 被代理对象实现的所有接口的字节码文件数组
    InvocationHandler h);//处理类对象,用于拦截我们调用的所有方法,判断到底是否应该被代理对象的真实方法

2.InvocationHandler处理类,实际上它是一个接口
    //invoke方法就是用于拦截我们调用的真实方法
    public Object invoke(Object proxy, Method method, Object[] args)
    					Object proxy  代理对象
    					Method method 被拦截到的方法
    					Object[] args 被拦截到方法的参数,如果没有就是null

3.5 动态代理综合案例

public class DynamicProxy {
    public static void main(String[] args) {
        //1.创建一个ArrayList
        ArrayList<String> arr = new ArrayList<String>();
        //保存用户的信息
        arr.add("张三");
        arr.add("18");
        arr.add("北京中关村");
        arr.add("188888块");
        //2.调用unmodifiableList
        List<String> list = unmodifiableList(arr);
//        list.add("aaa");
//        list.set(1, "28");
//        list.remove(1);
//        System.out.println(list.get(1));
        System.out.println(list.indexOf("18"));

    }
    //要求该方法和Collections的unmodifiableList一样,接收一个集合,返回一个该集合的代理对象(是动态代理对象)
    public static List<String> unmodifiableList(List<String> arr){
        //1.使用API 创建一个动态代理对象
        List<String> list = (List<String>) Proxy.newProxyInstance(DynamicProxy.class.getClassLoader(), arr.getClass().getInterfaces(), new InvocationHandler() {
            //该方法就是用来拦截真实对象方法
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //获取方法名字
                String name = method.getName();
                //需要拦截 add set remove 开头的哪些方法
                if (name.startsWith("add")) {
                    throw  new UnsupportedOperationException("add相关方法不让执行!");
                }
                if (name.startsWith("set")) {
                    throw  new UnsupportedOperationException("set相关方法不让执行!");
                }
                if (name.startsWith("remove")) {
                    throw new UnsupportedOperationException("remove相关方法不让执行!");
                }
                //其他方法正常执行
                Object result = method.invoke(arr, args);
                return result;
            }
        });

        return list;
    }
}

3.6 动态代理的优缺点总结

Proxy创建动态代理的优点: 
	  a,可以为任意接口的实现类做动态代理
      b.极大提高了我们的开发效率
      c.不会改变被代理对象的代码
Proxy创建动态代理的缺点:  
	  java的Proxy创建动态代理必须有接口,没有接口不行(以后的CGLib可以)

第四章 Lombok【自学扩展】

第五章 工厂设计模式

1.工厂模式概述
以前我们创建对象,都是通过直接new的方式创建的
而工厂模式,将创建对象的过程交给工厂去执行,我们只从工厂中获取对象即可
2.工厂模式作用
解决类与类之间的耦合问题
3.工厂模式实现步骤
a.提供一个所有类的父类/接口,提供一个Car接口
b.我们的各种实现类都需要实现该接口,重写接口中的方法 
c.提供一个返回不同实现类对象的工厂
4.工厂模式实现代码
/**
 * 所有汽车的共同接口
 */
public interface Car {
    void run();
}

public class Aotuo implements Car{
    public void run() {
        System.out.println("奥拓以8公里/小时的速度慢游...");
    }
}
public class BenChi implements Car{
    public void run() {
        System.out.println("奔驰以500公里/小时的速度奔驰...");
    }
}
public class FaLaLi implements Car{
    public void run() {
        System.out.println("法拉利以800公里/小时的速度飞驰...");
    }
}
/**
 * 提供工厂
 */
public class CarFactory {
    //定义方法,生产汽车
    public static Car getACar(int id) {
        //返回一辆真正的汽车对象
        if (id == 1) {
            return new Aotuo();
        } else if (id == 2) {
            return new BenChi();
        } else if (id == 3) {
            return new FaLaLi();
        }else{
            throw new NoSuchIdCarException("您的id:"+id+"不存在!");
        }
    }
}

public class TestCar {
    public static void main(String[] args) {
        //1.创建一辆汽车
        Car aCar = CarFactory.getACar(2);
        aCar.run();
    }
}
补充:我们可以使用配置文件,来代替具体的代码中的id值
car.properties
id=3
       
public class TestCar {
    public static void main(String[] args) throws IOException {
        //0.从配置文件去读id
        Properties ps = new Properties();
        //加载配置文件
        ps.load(new FileInputStream("day23/car.properties"));
        //取出数据
        String id = ps.getProperty("id");
        //转成int
        int ID = Integer.parseInt(id);
        //1.创建一辆汽车 高耦合  低耦合
        Car aCar = CarFactory.getACar(ID);
        aCar.run();
    }
}
总结
能够说出单例设计模式的好处【重点】
    可以让一个类只有一个对象
    饿汉式: 直接在类内部定义本类对象并创建对象
    懒汉式: 在类内部定义本类对象,在getInstance方法中判断再创建对象
能够说出多例模式的好处【重点】
    可以让一个类只有指定个数的对象
    在类内部创建一个集合,用来保存多个本类的对象
    一般来说我们都使用静态代码块向集合中添加固定个数的对象    
能够说出动态代理模式的作用【理解】
    在程序运行期间，为一个被代理对象动态创建一个代理对象
    当我们调用 代理对象的方法时，都会被拦截，拦截之后我们可以判断   
能够使用Proxy的方法生成代理对象【理解】
    Proxy.newProxyInstance(ClassLoader cl,Class[] interfaces,InvocationHandler handler)
        
    InvocationHandler接口
        //invoke方法就是用于拦截的
        public Object invoke(Object proxy,Method method,Object[] args);
										  被调用的方法	被调用的方法时的参数
       在此方法中我们会自己判断
               如果满足条件,我们正常调用:   method.invoke(被代理对象,args);                              	  如果不满足条件,我们不让调用: 什么都不做,抛出异常,输出一句话...
        
        
能够使用工厂模式编写java程序【重点】
编程叮当猫
关注
专栏目录
常用工厂设计模式之代理模式---用几个demo就能理解的代理模式
weixin_46816383的博客
04-01 1426
常用工厂设计模式之代理模式---用几个demo就能理解的代理模式一、什么是代理二、静态代理1、代理类和目标类实现同一个接口建一个接口建一个目标类建一个代理类测试运行结果2、代理类继承目标类修改一下代理类修改一下目标类测试运行结果三、动态代理1、目标类实现接口---jdk代理接口目标类实现接口JdkProxy代理类（这里相对比较难理解）测试运行结果2、目标类没有实现接口---cglib代理目标类cglib代理类测试运行结果四、由程序自己动态生成的代理类 首先我们要知道，工厂设计模式分为三类：创建型模式、行为型
Java设计模式资料day01
10-01
本课程从设计模式的一些相关的概念开始，再到软件设计原则，重点讲解23种设计模式，针对每一种模式都配备了相关的代码。最后通过一个综合案例将常用的设计模式使用起来。 市面上已经有很多的设计模式的教程，而我们...
JAVA设计模式 工厂模式 单例模式 动态代理模式
qq_43361467的博客
04-16 169
设计模式 工厂模式 Spring IOC 简单工厂模式 public class FactoryDemo { // 消费者 @Test public void test() { Car bmw = simpleFactory.creatCar("BMW"); bmw.DiDi(); Car benz = simpleFactory.creatCar("Benz"); benz.DiDi(); } } // 产品接口 interface Car { pub
常见程序设计模式1（合成、模板、工厂、代理、单例、多例）
weixin_45176509的博客
10-24 287
合成设计模式 任何人类产品都是可以拆分的，而后进行重新组合，所以这样设计中被称为合成设计模式。 定义出一种可以描述电脑组成的类，在这样状态下就应该进行拆分：显示器与主机。 例子： class 电脑{ //1 private 显示器 对象数组[]; private 主机 主机； } class 显示器{} //1.1 class 主机{ //1.2 private 主板 对象; private ...
单例，动态代理
weixin_34245169的博客
08-29 203
2019独角兽企业重金招聘Python工程师标准>>> ...
工厂设计模式与代理设计模式
weixin_44397040的博客
07-31 296
工厂设计模式分为三种： 简单工厂模式 工厂方法模式 抽象工厂模式 简单工厂模式 专门定义一个类来创建其他类的实例（将类的实例化交给工厂来实现） 简单工厂模式： //简单实现一个客户买手机的过程 import java.util.Scanner; public class Main { public static void main(String args[]) { ...
Java设计模式资料day02
10-01
本课程从设计模式的一些相关的概念开始，再到软件设计原则，重点讲解23种设计模式，针对每一种模式都配备了相关的代码。最后通过一个综合案例将常用的设计模式使用起来。 市面上已经有很多的设计模式的教程，而我们...
Java结构型设计模式资料day03
最新发布
10-01
本课程从设计模式的一些相关的概念开始，再到软件设计原则，重点讲解23种设计模式，针对每一种模式都配备了相关的代码。最后通过一个综合案例将常用的设计模式使用起来。 市面上已经有很多的设计模式的教程，而我们...
day40 设计模式、jdk8新特性
09-14
day40 设计模式、jdk8新特性
设计模式（一）（单例，工厂，代理，代理工厂）
weixin_46744534的博客
07-28 302
设计模式 1.单例模式 单例模式：为了解决同一对象要创建很多次的问题。因为同一个对象只创建一次，为了节约内存空间。比如很多用户浏览同一商品，当点击同一商品的信息时，其实创建相同的对象. 我们可以通过地址是否相等来判断对象new了几次。 本次单例模式学习到的有三种： 懒汉式 饿汉式 枚举 一般情况下使用的是饿汉式，但是枚举是实现单例模式的最佳方法。 懒汉式： 懒汉式没那么“饿”，只有在真正需要的时候再去创建实例。所以在类中先判断实例是否为空，为空再去创建。但是在多线程中会出问题，因为可能同时创建多个实例。
设计模式专题，代理模式，工厂模式
12-20
设计模式专题，代理模式，工厂模式
工厂设计模式与代理设计模式【带样例】
chaim16的博客
11-18 264
工厂设计模式 先来看看一个代码： /** 食物接口 */ interface IFood{ public void eat(); } /** 米饭类，实现食物接口 */ class Rice implements IFood{ @Override public void eat() { System.out.println("吃米饭咯！"); } } public class Main { public static void main(Stri
Java模板设计模式&工厂设计模式&代理设计模式
perfectmatch_G的博客
07-18 311
文章目录模板设计模式1.定义2.实现3.钩子方法工厂设计模式一、简单工厂模式1.特点2.结构图3.实现二、工厂方法模式1.特点2.结构图3.实现代理设计模式1.特点2.本质3.实现 模板设计模式 1.定义 在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。 2.实现 abstract class Beverage{ ...
设计模式(工厂和代理)
song_skytiger的博客
11-07 1613
工厂设计模式：        是Java用的最多的一种设计模式               在接口与具体子类之间加入一个过度端 案例： class  FactoryDemo {  public static void main(String[] args)  {   Fruit f = null;   f = Factory.get("橘子");   f.eat();
什么是工厂设计模式和什么是代理模式？
nanZhaiXiaoLang的博客
10-08 552
什么是工厂设计模式和什么是代理模式？ 工厂模式： IOC控制反转，给属性赋值的控制权转移到了Spring工厂中。 用spring提供的工厂来动态的生成实例对象，取代之前new的创建操作。 ID依赖注入 给工厂中的对象赋值。 依赖注入的几种方式： 1.设值注入：反射加载无参构造方法，set方法给属性赋值。 2.构造注入：反射加载带参数的构造方法，创建对象的同时给属性赋值。 3.自动装配：反射加载无参...
设计模式之多例模式
qq_39600525的博客
06-12 228
1、定义：作为对象的创建模式，多例模式中的多例类可以有多个实例，而且多例类必须自己创建、管理自己的实例，并向外界提供自己的实例。（可以控制自己想外界提供多少个实例）（这仅仅是学习笔记哦，真有了什么更深的理解，我会往上加的） 2、特点： （1）多例类可以有多个实例。 （2）多例类必须自己创建、管理自己的实例，并向外界提供自己的实例。 （3）根据是否有实例上线，可分为有上限多例类和无上限多例类...
深入浅出设计模式---3、代理模式和工厂模式
热门推荐
u014526891的博客
03-28 1万+
代理模式 **定义：**给某对象提供一个代理对象，通过代理对象可以访问该对象的功能。主要解决通过代理去访问[不能直接访问的对象，例如 租房中介，你可以直接通过中介去了解房东的房源信息，此时中介就可以称为代理。 优点： 1、职责清晰。 2、高扩展性。 3、智能化。 缺点： 1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。 代理实现方式： 基于接口的动态代理 提供者：JDK官方的Proxy类。 要求
第十天Python之面向对象（OOP）基本概念
Sunshine________的博客
09-21 351
面向对象编程—— Object Oriented Programming 简写 OOP 目标 了解 面向对象基本概念 一、 面向对象基本概念 我们之前学习的编程方式就是 面向过程 的 面向过程 和 面向对象，是两种不同的 编程方式 对比 面向过程 的特点，可以更好的了解什么是 面向对象 1. 过程和函数（科普） 过程 是早期的一个编程概念 过程 类似于函数，只能执行，但是没有返回值 函数 不仅能执行，还可以返回结果 2. 面向过程 和 面向对象 基本概念 1）面向过程 —— 怎么做？ 把完成某
三种动态代理和三种工厂模式，单例模式
weixin_42765975的博客
11-06 917
工厂模式：一种把创造（实例化）各种类类对象的工作抽出来的思想 简单的工厂模式：也叫静态的工厂模式，因为这个工厂类就办一件事创建实例化对象，方法可以定为static类型； 工厂方法模式：把实例化类的工作抽象成一个抽象方法，让实现这个抽象方法的类来完成实例化的工作， 抽象工厂模式：把实例化对象的工作抽象成一个接口，让实现这个接口的类去完成实例化工作： 代理：一句话说完，把调用某个类方法的工作（办...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值