精华内容
下载资源
问答
  • 个人笔记之为什么要使用spring而不用工厂模式来管理实例对象 使用spring的话,如果在我们需求需要变更的情况下,比如需要把person类换成human类,则只需要在beans.xml文件修改class属性即可,即包名+类名的形式,...

    个人笔记之为什么要使用spring而不用工厂模式来管理实例对象

    使用spring的话,如果在我们需求需要变更的情况下,比如需要把person类换成human类,则只需要在beans.xml文件修改class属性即可,即包名+类名的形式,因为spring中对象的创建是动态的,如果使用工厂模式的情况下,变更需求则需要修改整个person类,包括这个类里面的属性和方法,这就增加了操作的复杂性,变得更加麻烦。

    以上只是本人对这个问题的自身的理解,只作为个人的笔记,如果有说得不对的地方,希望各位大神不要吐槽我,我还只是个小白

    展开全文
  • 模式的代码示例:熟悉该模式的代码长什么样子 该模式的优缺点:模式不是万金油,不可以滥用模式模式的应用案例:了解它在哪些重要的源码中被使用 该系列会逐步更新于我的博客和公众号(博客见文章底部),也...

    前言

    《设计模式自习室》系列,顾名思义,本系列文章带你温习常见的设计模式。主要内容有:

    • 该模式的介绍,包括:
      • 引子、意图(大白话解释)
      • 类图、时序图(理论规范)
    • 该模式的代码示例:熟悉该模式的代码长什么样子
    • 该模式的优缺点:模式不是万金油,不可以滥用模式
    • 该模式的应用案例:了解它在哪些重要的源码中被使用

    该系列会逐步更新于我的博客和公众号(博客见文章底部),也希望各位观众老爷能够关注我的个人公众号:后端技术漫谈,不会错过精彩好看的文章。

    系列文章回顾

    结构型——享元模式 Flyweight Pattern

    引子

    主要用于减少创建对象的数量,以减少内存占用和提高性能。

    在享元模式中通常会出现工厂模式,需要创建一个享元工厂来负责维护一个享元池(Flyweight Pool)用于存储具有相同内部状态的享元对象。

    最经典的享元模式代码:

    class FlyweightFactory {
    
        //定义一个HashMap用于存储享元对象,实现享元池
        private HashMap flyweights = newHashMap();
        
        public Flyweight getFlyweight(String key){
        
            //如果对象存在,则直接从享元池获取
            if(flyweights.containsKey(key)){
                return(Flyweight)flyweights.get(key);
            }
            
            //如果对象不存在,先创建一个新的对象添加到享元池中,然后返回
            else {
                Flyweight fw = newConcreteFlyweight();
                flyweights.put(key,fw);
                return fw;
            }
        }
    }
    

    定义

    运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象,而这些对象都很相似,状态变化很小,可以实现对象的多次复用。由于享元模式要求能够共享的对象必须是细粒度对象,因此它又称为轻量级模式,它是一种对象结构型模式。

    两个概念:

    • 内部状态:在享元对象内部不随外界环境改变而改变的共享部分。
    • 外部状态:随着环境的改变而改变,不能够共享的状态就是外部状态。

    在享元类中要将内部状态和外部状态分开处理,通常将内部状态作为享元类的成员变量,而外部状态通过注入的方式添加到享元类中。

    类图

    如果看不懂UML类图,可以先粗略浏览下该图,想深入了解的话,可以继续谷歌,深入学习:

    享元模式包含如下角色:

    • Flyweight: 抽象享元类
    • ConcreteFlyweight: 具体享元类
    • UnsharedConcreteFlyweight: 非共享具体享元类
    • FlyweightFactory: 享元工厂类

    时序图

    时序图(Sequence Diagram)是显示对象之间交互的图,这些对象是按时间顺序排列的。时序图中显示的是参与交互的对象及其对象之间消息交互的顺序。

    我们可以大致浏览下时序图,如果感兴趣的小伙伴可以去深究一下:

    代码实现

    代码参考:

    https://www.cnblogs.com/chenssy/p/3330555.html

    假设:我们有一个绘图的应用程序,通过它我们可以出绘制各种各样的形状、颜色的图形,那么这里形状和颜色就是内部状态了,通过享元模式我们就可以实现该属性的共享了。

    抽象享元类Flyweight:绘制图像的抽象方法

    public abstract class Shape {
        public abstract void draw();
    }
    

    具体享元类ConcreteFlyweight:例子中则是一种绘制某种图像(圆形)的具体实现类,里面的颜色则是一个可以共享的内部对象。

    public class Circle extends Shape{
        private String color;
        public Circle(String color){
            this.color = color;
        }
    
        public void draw() {
            System.out.println("画了一个" + color +"的圆形");
        }
        
    }
    

    享元工厂类FlyweightFactory:

    利用了HashMap保存已经创建的颜色

    public class FlyweightFactory{
        static Map<String, Shape> shapes = new HashMap<String, Shape>();
        
        public static Shape getShape(String key){
            Shape shape = shapes.get(key);
            //如果shape==null,表示不存在,则新建,并且保持到共享池中
            if(shape == null){
                shape = new Circle(key);
                shapes.put(key, shape);
            }
            return shape;
        }
        
        public static int getSum(){
            return shapes.size();
        }
    }
    

    客户端调用:

    调用相同颜色时,会直接从HashMap中取那个颜色的对象,而不会重复创建相同颜色的对象。

    public class Client {
        public static void main(String[] args) {
            Shape shape1 = FlyweightFactory.getShape("红色");
            shape1.draw();
            
            Shape shape2 = FlyweightFactory.getShape("灰色");
            shape2.draw();
            
            Shape shape3 = FlyweightFactory.getShape("绿色");
            shape3.draw();
            
            Shape shape4 = FlyweightFactory.getShape("红色");
            shape4.draw();
            
            Shape shape5 = FlyweightFactory.getShape("灰色");
            shape5.draw();
            
            Shape shape6 = FlyweightFactory.getShape("灰色");
            shape6.draw();
            
            System.out.println("一共绘制了"+FlyweightFactory.getSum()+"中颜色的圆形");
        }
    }
    

    使用场景举例

    如果一个系统中存在大量的相同或者相似的对象,由于这类对象的大量使用,会造成系统内存的耗费,可以使用享元模式来减少系统中对象的数量。

    Integer 中的享元模式

    public static void main(String[] args) {
            Integer i1 = 12 ;
            Integer i2 = 12 ;
            System.out.println(i1 == i2);
    
            Integer b1 = 128 ;
            Integer b2 = 128 ;
            System.out.println(b1 == b2);
        }
    

    输出是

    true
    false
    

    在Java中,Integer是有缓存池的,缓存了-128~127的int对象

    IntegerCache 缓存类:

    //是Integer内部的私有静态类,里面的cache[]就是jdk事先缓存的Integer。
    private static class IntegerCache {
        static final int low = -128;//区间的最低值
        static final int high;//区间的最高值,后面默认赋值为127,也可以用户手动设置虚拟机参数
        static final Integer cache[]; //缓存数组
    
        static {
            // high value may be configured by property
            int h = 127;
            //这里可以在运行时设置虚拟机参数来确定h  :-Djava.lang.Integer.IntegerCache.high=250
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {//用户设置了
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);//虽然设置了但是还是不能小于127
                // 也不能超过最大值
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            }
            high = h;
    
            cache = new Integer[(high - low) + 1];
            int j = low;
            //循环将区间的数赋值给cache[]数组
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }
    
        private IntegerCache() {}
    }
    

    其他

    同理,Long也有缓存池。

    String类定义为final(不可改变的),JVM中字符串一般保存在字符串常量池中,java会确保一个字符串在常量池中只有一个拷贝,这个字符串常量池在JDK6.0以前是位于常量池中,位于永久代,而在JDK7.0中,JVM将其从永久代拿出来放置于堆中。

    详细可参考:

    http://laijianfeng.org/2018/09/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E4%BA%AB%E5%85%83%E6%A8%A1%E5%BC%8F%E5%8F%8A%E5%85%B8%E5%9E%8B%E5%BA%94%E7%94%A8/

    优缺点

    优点

    • 享元模式的优点在于它能够极大的减少系统中对象的个数
    • 享元模式由于使用了外部状态,外部状态相对独立,不会影响到内部状态,所以享元模式使得享元对象能够在不同的环境被共享。

    缺点

    • 由于享元模式需要区分外部状态和内部状态,使得应用程序在某种程度上来说更加复杂化了。

    参考

    • 《HEAD FIRST设计模式》
    • https://design-patterns.readthedocs.io/zh_CN/latest/structural_patterns/flyweight.html
    • https://www.cnblogs.com/chenssy/p/3330555.html
    • http://laijianfeng.org/2018/09/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E4%BA%AB%E5%85%83%E6%A8%A1%E5%BC%8F%E5%8F%8A%E5%85%B8%E5%9E%8B%E5%BA%94%E7%94%A8/

    关注我

    我是一名后端开发工程师。

    主要关注后端开发,数据安全,爬虫,物联网,边缘计算等方向,欢迎交流。

    各大平台都可以找到我

    原创博客主要内容

    • Java面试知识点复习全手册
    • 设计模式/数据结构 自习室
    • Leetcode/剑指offer 算法题解析
    • SpringBoot/SpringCloud菜鸟入门实战系列
    • 爬虫相关技术文章
    • 后端开发相关技术文章
    • 逸闻趣事/好书分享/个人兴趣

    个人公众号:后端技术漫谈

    公众号:后端技术漫谈.jpg

    如果文章对你有帮助,不妨收藏,投币,转发,在看起来~

    展开全文
  • 设计模式系列-面向对象葵花宝典-面向对象基础声明:本系列为面向对象葵花宝典一书学习总结内容,原作者博客链接书籍简介 面向对象葵花宝典:思想、技巧与实践》系统地讲述了面向对象技术的相关内容,包括面向对象的...

    设计模式系列-面向对象葵花宝典-面向对象基础

    声明:本系列为面向对象葵花宝典一书学习总结内容,原作者博客链接

    书籍简介

    面向对象葵花宝典:思想、技巧与实践》系统地讲述了面向对象技术的相关内容,包括面向对象的基本概念、面向对象开发的流程、面向对象的各种技巧,以及如何应用面向对象思想进行架构设计。在讲述相关知识或技术的时候,除了从“是什么”这个角度进行介绍外,更加着重于从“为什么”和“如何用”这两个角度进行剖析,力争让读者做到“知其然,并知其所以然”,从而达到在实践中既能正确又能优秀地应用面向对象的相关技术和技巧。
    《面向对象葵花宝典:思想、技巧与实践》的内容涵盖广泛,无论读者已有的水平如何,都能够从书中获益。
    如果你是刚入门的程序员,书中有详尽的和通俗易懂的概念和方法介绍,有完整的面向对象开发流程,让你能够快速掌握面向对象开发的基本技巧,从容不迫地完成开发任务;
    如果你有了一定经验,能够熟练应用各种面向对象技术和技巧,但却没有深入地去探索,书中有独辟蹊径的解读,能够让你“知其然,并知其所以然”;
    如果你已经成为了面向对象的大牛程序员,但苦于不能继续提升,书中有“面向对象架构设计”的点石成金术,让你从程序员秒变架构师。


    读后推荐心得

    文中阐述了作者对面向对象的深入理解,全面阐述了面向对象的理论基础,以及通过面向对象的实战指导进行分析,尤为重点让人容易忽视的需求分析过程,让程序更具有建造者的设计气息。最后一部分讲解了面向对象的技巧,以及设计模式的内在剖析。
    以下内容在原作基础上进行了删减或者自我理解加工,详细内容请查看原作书籍。

    第一部分:面向对象基础

    1. 面向对象概述

    1.1. 程序设计思想的发展
    - 史前时代:面向机器 直接编写0和1的序列来代表程序语言
    - 机器第一步:面向过程 解决问题的过程,这应该也是面向过程说法的来由
    - 当今主流:面向对象 可扩展性、可维护性
    1.3. 面向过程
    面向过程是一种以“过程”作为中心的编程思想,其中过程的含义就是“完成一件事情的步骤”。
    面向过程其实是一种“机械的思想”,它就像流水线一样,一个阶段衔接一个阶段,每个阶段都有自己的
    输入、处理、输出,而在流水线上流动的就是我们的原料或者中间产品,每个阶段都有一个机械进行处理,
    最后的输出就是我们的产品。
    1.4. 面向对象
    面向对象是一种以“对象”作为中心的编程思想,其中对象的含义可以理解为“存在的东西”。
    与面向过程的方法相比,面向对象不再局限于计算机的机器本质,而更加侧重于对现实世界的模拟。
    面向对象的方法中,设计了很多对象,并且指定了这些对象需要完成的任务,以及这些对象如何对外界的刺激做出反应。
    面向过程中有“程序=算法+数据结构”的经典总结,面向对象也有类似的总结:“程序=对象 + 交互”。其中对象就是具体存在的事物,而交互则是事物之间的相互作用、互动等。
    1.5. 为什么要面向对象?
    面向过程同流水线一样的缺点,即:流程和原料相对固定,扩展比较麻烦。
    而面向对象正是为了解决面向过程的这个缺点儿诞生的,面向对象思想的核心是“可扩展性”!
    1.6. 面向对象应用范围
    经常变化的地方就是面向对象应用的地方
    对于软件系统来说,常见的可变的主要集中在客户需求部分,而不变的一般都是属于计算机系统的基础
    因此,操作系统、数据库、协议(TCP、3GPP 等) 这些并不适合面向对象大展身手,因为这些基础软件
    一般都比较稳定(相对稳定,并不是不变)。而对于企业应用、互联网等应用,需求经常变更,功能不断扩展,这正是面向对象大展身手的地方。
    软件质量属性的全图
    这里写图片描述
    大家可以看到,“可扩展性”只是软件质量属性中很小的一部分,其它的属性都不是面向对象能够解决的明白了面向对象的特点和适用范围,是应用面向对象的关键,经过前面的分析,我们知道,面向对象不是瑞士军刀,而只是一个普通的锤子而已,千万不要拿着锤子到处敲!

    2. 面向对象理论

    2.1.类
    何为类? 物以类聚,人以群分,这里的“类”,其实和面向对象中的“类”的逻辑含义并无不同。简单来说,类就是一组相似事物的统称。 站在你的观察角度,具有相似点的事物就是同一类。
    面向对象类
    面向对象的类由两部分组成:属性和方法。名词是属性,动词是方法
    属性:指类具有的特性 属性最小化原则,即:“属性不可再分”更灵活的应对变化
    方法:指类具有的功能 方法单一化原则,即:一个方法只做一件事。比如玩?玩什么 玩乒乓球
    2.2. 对象
    对象就是一个具体的类,一个真实存在的类。
    这里写图片描述
    2.3. 接口
    接口是一组相关的交互功能点定义的集合。
    【相关】 接口中包含的功能点是相关的,而不是一堆无关功能的堆砌。
    【交互】 接口是用于不同物体交互,如果只是自己玩,那么就不能成为接口;
    【定义】 接口中的功能点只是定义,并不涉及具体实现。
    【集合】 接口是多个功能点的集合,而不是一个具体的功能点。

    2.4. 抽象类
    抽象类是一种特殊的类,其特殊性在于抽象类只能用于继承,不能被实例化为具体的对象。
    有了类,为什么还要抽象类,为什么设计一种只能继承,不能实例化的类?
    答案就在于:某些场景下普通类不够用。例如,“苹果”、“桔子”、“香蕉”都是“水果”,这里的“水果”就是一个抽象类。你可以说你喜欢吃“水果”,但你真正吃“水果”的时候,要么是“苹果”,要么是“桔子”,要么是“香蕉”。。。。。。但你绝不可能真正吃到一个叫做“水果”的东东。
    抽象类和接口有什么区别,为什么有了接口,还要有抽象类?
    答案就在于:抽象类本质上还是类,强调一组事物的相似性,包括属性和方法的相似性;而接口只强调方法的相似性,并且仅仅体现在方法声明上的相似性,而没有方法定义上的相似性。
    2.5. 抽象
    抽象的中文概念非常形象,简单来说就是“抽取出来比较像的部分”。
    抽象的层次是不限的,根据业务的需要,或者不同的观察角度,可以抽象出很多层。
    抽象最主要的作用是“划分类别”,而划分类别的主要目的其实还是“隔离关注点,降低复杂度
    2.6. 三大核心特征
    封装 封装数据的主要原因是“保护隐私” 封装方法的主要原因是“隔离复杂度”
    继承 = 遗传了父辈的特征 同时你还可能变异(子类)
    多态 多 指向父类的指针或者引用,能够调用多个子类的对象。

    展开全文
  • 以前,销售商需要什么(产品)对象就先创造什么工厂,自己创建工厂自己生产产品: public class OldFactory { public static void main(String[] args) { XiaoMi9 xiaoMi9 = new XiaoMi9(); XiaoMi10 xiaoMi10 = ...
    工厂模式

    一、 简单工厂模式

    以前,销售商需要什么(产品)对象就先创造什么工厂,自己创建工厂自己生产产品:

    public class OldFactory {
        public static void main(String[] args) {
            XiaoMi9 xiaoMi9 = new XiaoMi9();
            XiaoMi10 xiaoMi10 = new XiaoMi10();
        }
    }
    class XiaoMi9{
        public XiaoMi9(){
          System.out.println("生成了一台小米9");
        }
    }
    
    class XiaoMi10{
        public XiaoMi10(){
          System.out.println("生产了一台小米10");
        }
    }
    

    为了降低耦合度,将生产商和销售商进行分离。当销售商提出要求时,将产品型号直接告诉生成商,生产商拿到设计图纸后生成出相应型号的产品交给生产商,销售商不知道产品的具体生产过程,他只负责销售啦。

    public class SimpleFactory {
        public static void main(String[] args) {
            XiaoMiFactory factory = new XiaoMiFactory();
            XiaoMi xiaoMi9 = factory.createXiaomi(9);
            xiaoMi9.produce();
            XiaoMi xiaoMi10 = factory.createXiaomi(10);
            xiaoMi9.produce();
        }
    }
    
    //抽象类(xiaomi设计图纸)
    abstract class XiaoMi{
        public abstract void produce();
    }
    
    //图纸的具体实现
    class XiaoMi9 extends XiaoMi{
        @Override
        public void produce() {
            System.out.println("生成出小米9");
        }
    }
    class XiaoMi10 extends XiaoMi{
        @Override
        public void produce() {
            System.out.println("生成出小米10");  
        }
    }
    //xiaomi工厂根据销售商需要的型号进行生产
    class XiaoMiFactory{
        public XiaoMi createXiaomi(int type) {
            switch (type) {
                case 9:
                    return new XiaoMi9();
                case 10:
                    return new XiaoMi10();
                default:
                    break;
            }
            return null;
        }
    }
    

    二、 工厂方法模式

    上述简单工厂模式有些问题,现在xiaomi又出了个产品,例如:xiaomi11,这时,它除了需要在"图纸的实现"部分新增

    class XiaoMi11 extends XiaoMi{
        @Override
        public void produce() {
            System.out.println("生成出小米11");  
        }
    }
    

    ,还需要对工厂(XiaoMiFactory)进行修改,新增

    case 11:
    	return new XiaoMi11();
    

    这明显违背了“开闭原则”(对扩展开放,对修改关闭原则)。

    下面是工厂方法模式:

    public class PlantFactory {
        public static void main(String[] args) {
            XiaoMi9Factory xiaoMi9Factory = new XiaoMi9Factory();
            XiaoMi xiaomi9 = xiaoMi9Factory.getProduct();
            xiaomi9.produce();
            XiaoMi10Factory xiaoMi10Factory = new XiaoMi10Factory();
            xiaoMi10Factory.getProduct().produce();
        }
    }
    //抽象类(xiaomi设计图纸)
    abstract class XiaoMi{
        public abstract void produce();
    }
    //图纸的具体实现
    class XiaoMi9 extends XiaoMi{
        @Override
        public void produce() {
            System.out.println("生产了小米9");
        }
    }
    class XiaoMi10 extends XiaoMi{
        @Override
        public void produce() {
            System.out.println("生产了小米10");  
        }
    }
    //工厂接口(总部:制定分工厂规则)
    interface XiaoMiFactory{
        XiaoMi getProduct();
    }
    //分工厂(实现总部制定的规则)
    class XiaoMi9Factory implements XiaoMiFactory{
        @Override
        public XiaoMi getProduct() {
            return new XiaoMi9();
        }     
    }
    class XiaoMi10Factory implements XiaoMiFactory{
        @Override
        public XiaoMi getProduct() {
            return new XiaoMi10();
        }
    }
    

    工厂方法模式的组成:

    • 抽象产品类(XiaoMi):提供抽象方法供具体产品类实现
    • 具体产品类(XiaoMi9、XiaoMi10):提供具体的产品
    • 抽象工厂类(XiaoMiFactory):提供抽象方法供具体工厂实现
    • 具体工厂类(XiaoMi9Factory、XiaoMi10Factory):提供具体的工厂

    通过工厂方法模式,xiaomi发布新产品后,就不需要对原有代码就行更改了,例如:xiaomi11发布后,它需要进行:

    1.产品图纸的具体实现部分新增:

    class XiaoMi11 extends XiaoMi{
        @Override
        public void produce() {
            System.out.println("生产了小米11");  
        }
    }
    

    2.增加一个工厂或流水线对其进行生产:

    class XiaoMi11Factory implements XiaoMiFactory{
        @Override
        public XiaoMi getProduct() {
            return new XiaoMi11();
        }     
    }
    

    符合了“开闭原则”,并且,代码易用性高,新增的代码可以根据以前的代码进行适当修改(以前的产品线进行升级改装后可生产新产品)。

    三、 抽象工厂模式

    抽象工厂模式与工厂方法模式类似,但它们的侧重点不一样。工厂方法模式侧重于同一产品等级(例如xiaomi8、xiaomi9、xiaomi10等);而抽象工厂模式侧重于一个产品族(例如:xiaomi9、xiaomi9 Pro、xiaomi9 cc)。

    public class AbstractFactory {
        public static void main(String[] args) {
            XiaoMi9Factory xiaoMi9Factory = new XiaoMi9Factory();
            Camera xiaoMi9Camera = xiaoMi9Factory.useCamera();
            xiaoMi9Camera.pixel();
            FingerRecog xiaoMi9FingerRecog = xiaoMi9Factory.useFingerRecog();
            xiaoMi9FingerRecog.position();
            
            XiaoMi9ProFactory xiaoMi9ProFactory = new XiaoMi9ProFactory();
            xiaoMi9ProFactory.useCamera().pixel();
            xiaoMi9ProFactory.useFingerRecog().position();
        }
    }
    
    //相机
    abstract class Camera{
        //像素
        public abstract void pixel();
    }
    class CameraA extends Camera{
        public void pixel() {
            System.out.println("1200w像素");
        }
    }
    class CameraB extends Camera{
        public void pixel() {
            System.out.println("2400w像素");
        }    
    }
    //指纹识别
    abstract class FingerRecog{
        abstract void position();
    }
    
    class FingerRecogA extends FingerRecog{
        public void position() {
            System.out.println("背部指纹识别");
        }
    }
    class FingerRecogB extends FingerRecog{
        public void position() {
            System.out.println("屏下指纹识别");
        }   
    }
    
    //抽象工厂(xiaomi总部)
    interface XiaoMiFactory{
        Camera useCamera();
        FingerRecog useFingerRecog();
    }
    //1200w和背部识别
    class XiaoMi9Factory implements XiaoMiFactory{
        @Override
        public Camera useCamera() {
            return new CameraA();
        }
        @Override
        public FingerRecog useFingerRecog() {
            return new FingerRecogA();
        }
    }
    //2400w像素和屏下识别
    class XiaoMi9ProFactory implements XiaoMiFactory{
        @Override
        public Camera useCamera() {
            return new CameraB();
        }
        @Override
        public FingerRecog useFingerRecog() {
            return new FingerRecogB();
        }
    }
    
    //2400w像素和背部指纹识别
    class XiaoMi9CCFactory implements XiaoMiFactory{
        @Override
        public Camera useCamera() {
            return new CameraB();
        }
        @Override
        public FingerRecog useFingerRecog() {
            return new FingerRecogA();
        }
    }
    

    四、工厂方法模式与抽象工厂模式的区别:

    • 工厂方法模式只有一个抽象产品类(工厂方法模式中的XiaoMi抽象类),只能创建一个具体产品类的实例。
    • 抽象工厂模式有多个抽象产品类(抽象工厂模式中的Camera、FingerRecog抽象类),可以创建多个具体产品类的实例。
    • 自我感觉这两个的区别有点难以区分。工厂方法模式中,就只有小米系列的区分(xiaomi9、xiaomi10的型号),而抽象工厂模式中,(xiaomi9、xiaomi9Plus、xiaomi9cc在像素和指纹识别上都有区分)。感觉就是抽象工厂模式中存在了多个工厂方法模式。
    展开全文
  • 亚历山大对模式的描述包括如下四项: 1、模式的名称 2、模式的目的,也就是解决的问题 3、实现方法 4、为了实现该模式我们必须考虑的限制和约束因素 在20世纪90年代,软件界有好多人在想,软件开发中是否存在以某种...
  • Symbol对象什么

    2020-12-27 09:27:49
    猜想输出什么? </p><pre><code>javascript class MyClass{ static <a href="num">Symbol.hasInstance</a> { return num % 2 === 0 } <p><a href="...
  • 1. 什么是设计模式? 设计模式描述了软件设计过程中某一类常见问题的一般性的解决方案。2. 什么是面向对象设计模式? 面向对象设计模式描述...面向对象设计模式解决的是“类与相互通信的对象之间的组织关系,包括
  • MVC、面向对象模式

    千次阅读 2012-08-24 10:53:02
    ...但是到底什么才是mvc,mvc的编程到底又有什么好处和坏处,下面,就我一个php新手谈一下我对于mvc的理解。 说到mvc其实就不得不说面向对象,其实php...包括现在她也并不是纯的面向对象的语言,php可以面向对象编程
  • 主要讲解了ES6对字符串的拓展,包括includes,startsWith和endsWith,另外增加了字符串模板。 Start includes()是否包含 startsWith()以什么开头 endsWith()以什么结尾 &lt;!DOCTYPE html&gt;...
  • JS中总共有六种继承模式包括原型链、借用构造函数、组合继承、原型式继承寄生式继承和寄生组合式继承。为了便于理解记忆,我遐想了一个过程,对6中模式进行了简单的阐述。 很长的一个故事,姑且起个名字叫女娲造人...
  • 什么是工厂模式

    2014-02-08 17:36:00
    1.工厂模式具体包括了简单工厂、工厂方法、抽象工厂,它们是按照从简单到复杂的顺序排列的,属于设计模式中的创建型,其中简单工厂并不属于GOF的23中模式。但是它是理解其它的工厂模式的一个很好的基础,所以很多人...
  • 什么是软件开发模式

    2021-02-25 15:02:11
    软件开发模式又称开发范型、风范;具体描述如下 开发过程遵循的步骤:如面向过程的开发模式是对特定问题执行...面向对象模式使用的是对象之间通讯协作(消息)完成的,基本成分包括类、接口、消息。 得到问题的结构
  • 本书论述运用UML(统一建模语言)和模式进行对象建模的方法和技巧,重点讨论了如何使用面向对象的分析和设计技术来建造一个健壮的和易于维护的系统。 全书叙述清晰、图文并茂、实例丰富,是一部来自于大量经验的...
  •  第7章 什么是设计模式?为何使用它们   第8章 模式原则   第 9章 生成对象   第10章 让面向对象编程更加灵活的模式   第11章 执行及描述任务   第12章 企业模式   第13章 数据库模式  第四...
  • 在一定的环境中解决某一问题的方案,包括三个基本元素——问题、解决方案和环境。   二、设计模式 这是一套被反复使用,多数人知晓的,经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让...
  •  第7章 什么是设计模式?为何使用它们   第8章 模式原则   第 9章 生成对象   第10章 让面向对象编程更加灵活的模式   第11章 执行及描述任务   第12章 企业模式   第13章 数据库模式  第四...
  • 什么是设计模式

    2014-06-07 20:16:29
    让我们首先来看一下对于模式的定义,模式是一种问题的解决思路,它已经适用于一个实践环境,并且可以适用于其它... 设计模式的种类很多,包括分布式编程模式、用户界面模式、数据模型模式三大类。目前流行的面向对象
  • 一、什么是不可变类 所谓不可变类,一旦创建后,成员变量值不可再修改。 不可变是线程安全的 可变线程也可能是安全的 StringBuffer是线程安全的(里面使用大量的sychonrized,但又提供了修改方法)。 StringBuilder...
  • 也就是说,在编程中,工厂模式,就是效仿工厂,进行集中、高效实例化对象。(实例化就是生产商品) 二、简单工厂模式小案例 首先,我们先来确定一下案例的流程 1. 创建一个工厂; 2.工厂要生产一些皮制品; 3. ...
  • 什么是mvc模式

    千次阅读 2010-05-22 10:44:00
    什么是mvc模式 MVC(Model/View/Controller)模式是国外用得比较多的一种设计模式,好象最早是在Smalltalk中出现。MVC包括三类对象。Model是应用对象,View是它在屏幕上的表示,Controller定义用户界面对用户输入的...
  • 当然这已经不包括在本文的范畴了。 现在主程序界面发生了稍许的改变: 程序代码 Public void BtnPlay_Click(object sender,EventArgs e) { IMediaFactory factory = null; switch (cbbMediaType.SelectItem....
  • JS中总共有六种继承模式包括原型链、借用构造函数、组合继承、原型式继承寄生式继承和寄生组合式继承。为了便于理解记忆,我遐想了一个过程,对6中模式进行了简单的阐述。  很长的一个故事,姑且起个名字叫女娲...
  • JS中总共有六种继承模式包括原型链、借用构造函数、组合继承、原型式继承寄生式继承和寄生组合式继承。为了便于理解记忆,我遐想了一个过程,对6中模式进行了简单的阐述。  很长的一个故事,姑且起个名字叫女娲...
  • 面向对象主要是把事物给对象化,包括其属性和行为。面向对象编程更贴近实际生活的思想。 3.类 4.什么对象的属性 5.什么对象的方法 6.类与对象的关系和区别 面向对象三大特性: 1、封装 隐藏对象的属性和实现细节...
  • ( MVC设计与MVP )模式已使用了好几年,解决的一个关键问题即面向对象主要关注点,分离的用户界面和业务层。 还有一些框架,是目前使用的是基于这些模式包括: JAVA Struts, ROR, Microsoft Smart Client ...
  • 有一个业务领域概念模型,其中包括了业务逻辑和关系。 如果业务操作只有很少、什么没有业务逻辑,那么应用系统通常会让客户端直接访问数据存储中的业务数据。比如说,一个表现层组件(比如一个命令助手或者一个...
  • 当Active Object模式对外暴露的异步方法被调用时,与该方法调用相关的上下文信息,包括被调用的异步方法名、参数等,会被封装成一个对象。该方法请求对象会被存入缓冲区中,由专门的工作者线程负责执行。 错误隔离:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,667
精华内容 666
关键字:

模式对象包括什么