精华内容
下载资源
问答
  • 常见思维模型汇总(一)

    万次阅读 2019-02-08 14:43:28
     两个处于同行业或不同行业中的企业,可能会由于所生产的产品是互为替代品,从而在它们之间产生相互竞争行为,这种源自于替代品的竞争会以各种形式影响行业中现有企业的竞争战略。首先,现有企业产品售价以及获利...

    一、SWOT模型

    1、简介

           SWOT分析代表分析企业优势(strengths)、劣势(weakness)、机会(opportunity)和威胁(threats)。因此,SWOT分析实际上是将对企业内外部条件各方面内容进行综合和概括,进而分析组织的优劣势、面临的机会和威胁的一种方法。
    在这里插入图片描述

    2、SWOT模型的拆解

           SWOT分析有四种不同类型的组合:优势——机会(SO)组合、弱点——机会(WO)组合、优势——威胁(ST)组合和弱点——威胁(WT)组合。

           优势——机会(SO)战略是一种发展企业内部优势与利用外部机会的战略,是一种理想的战略模式。当企业具有特定方面的优势,而外部环境又为发挥这种优势提供有利机会时,可以采取该战略。例如良好的产品市场前景、供应商规模扩大和竞争对手有财务危机等外部条件,配以企业市场份额提高等内在优势可成为企业收购竞争对手、扩大生产规模的有利条件。

           弱点——机会(WO)战略是利用外部机会来弥补内部弱点,使企业改劣势而获取优势的战略。存在外部机会,但由于企业存在一些内部弱点而妨碍其利用机会,可[1]采取措施先克服这些弱点。例如,若企业弱点是原材料供应不足和生产能力不够,从成本角度看,前者会导致开工不足、生产能力闲置、单位成本上升,而加班加点会导致一些附加费用。在产品市场前景看好的前提下,企业可利用供应商扩大规模、新技术设备降价、竞争对手财务危机等机会,实现纵向整合战略,重构企业价值链,以保证原材料供应,同时可考虑购置生产线来克服生产能力不足及设备老化等缺点。通过克服这些弱点,企业可能进一步利用各种外部机会,降低成本,取得成本优势,最终赢得竞争优势。

           优势——威胁(ST)战略是指企业利用自身优势,回避或减轻外部威胁所造成的影响。如竞争对手利用新技术大幅度降低成本,给企业很大成本压力;同时材料供应紧张,其价格可能上涨;消费者要求大幅度提高产品质量;企业还要支付高额环保成本;等等,这些都会导致企业成本状况进一步恶化,使之在竞争中处于非常不利的地位,但若企业拥有充足的现金、熟练的技术工人和较强的产品开发能力,便可利用这些优势开发新工艺,简化生产工艺过程,提高原材料利用率,从而降低材料消耗和生产成本。另外,开发新技术产品也是企业可选择的战略。新技术、新材料和新工艺的开发与应用是最具潜力的成本降低措施,同时它可提高产品质量,从而回避外部威胁影响。

           弱点——威胁(WT)战略是一种旨在减少内部弱点,回避外部环境威胁的防御性技术。当企业存在内忧外患时,往往面临生存危机,降低成本也许成为改变劣势的主要措施。当企业成本状况恶化,原材料供应不足,生产能力不够,无法实现规模效益,且设备老化,使企业在成本方面难以有大作为,这时将迫使企业采取目标聚集战略或差异化战略,以回避成本方面的劣势,并回避成本原因带来的威胁。

    二、波士顿5力模型

    1、简介

           波特五力模型是企业制定竞争战略时经常利用的战略分析工具。波特五力模型将大量不同的因素汇集在一个简便的模型中,以此分析一个行业的基本竞争态势。五种力量模型确定了竞争的五种主要来源,即供应商和购买者的讨价还价能力,潜在进入者的威胁,替代品的威胁以及最后一点,来自在同一行业的公司间的竞争。
    在这里插入图片描述

    2、缺陷

           实际上,关于五力分析模型的实践运用一直存在许多争论。目前较为一致的看法是:该模型更多是一种理论思考工具,而非可以实际操作的战略工具。
      该模型的理论是建立在以下三个假定基础之上的:
      1、制定战略者可以了解整个行业的信息,显然现实中是难于做到的;
      2、同行业之间只有竞争关系,没有合作关系。但现实中企业之间存在多种合作关系,不一定是你死我活的竞争关系;
      3、行业的规模是固定的,因此,只有通过夺取对手的份额来占有更大的资源和市场。但现实中企业之间往往不是通过吃掉对手而是与对手共同做大行业的蛋糕来获取更大的资源和市场。同时,市场可以通过不断的开发和创新来增大容量。
           因此,要将波特的竞争力模型有效地用于实践操作,以上在现实中并不存在的三项假设就会使操作者要么束手无策,要么头绪万千。

    3、分解
    3.1.供应商的议价能力(Bargaining Power of Suppliers)

           供方主要通过其提高投入要素价格与降低单位价值质量的能力,来影响行业中现有企业的盈利能力与产品竞争力。供方力量的强弱主要取决于他们所提供给买主的是什么投入要素,当供方所提供的投入要素其价值构成了买主产品总成本的较大比例、对买主产品生产过程非常重要、或者严重影响买主产品的质量时,供方对于买主的潜在讨价还价力量就大大增强。一般来说,满足如下条件的供方集团会具有比较强大的讨价还价力量:

    • 供方行业为一些具有比较稳固市场地位而不受市场剧烈竞争困挠的企业所控制,其产品的买主很多,以致于每一单个买主都不可能成为供方的重要客户。

    • 供方各企业的产品各具有一定特色,以致于买主难以转换或转换成本太高,或者很难找到可与供方企业产品相竞争的替代品。

    • 供方能够方便地实行前向联合或一体化(产业链纵向延伸的能力),而买主难以进行后向联合或一体化。

    3.2.购买者的议价能力 (Bargaining Power of Buyers)

           购买者主要通过其压价与要求提供较高的产品或服务质量的能力,来影响行业中现有企业的盈利能力。一般来说,满足如下条件的购买者可能具有较强的讨价还价力量:

    • 购买者的总数较少,而每个购买者的购买量较大,占了卖方销售量的很大比例。

    • 卖方行业由大量相对来说规模较小的企业所组成。

    • 购买者所购买的基本上是一种标准化产品,同时向多个卖主购买产品在经济上也完全可行。

    • 购买者有能力实现后向一体化,而卖主不可能前向一体化。(注:简单按中国说法,客大欺主)

    3.3.新进入者的威胁(Threat of New Entrants)

           新进入者在给行业带来新生产能力、新资源的同时,将希望在已被现有企业瓜分完毕的市场中赢得一席之地,这就有可能会与现有企业发生原材料与市场份额的竞争,最终导致行业中现有企业盈利水平降低,严重的话还有可能危及这些企业的生存。竞争性进入威胁的严重程度取决于两方面的因素,这就是进入新领域的障碍大小与预期现有企业对于进入者的反应情况。

    3.4.替代品的威胁 (Substitutes)

           两个处于同行业或不同行业中的企业,可能会由于所生产的产品是互为替代品,从而在它们之间产生相互竞争行为,这种源自于替代品的竞争会以各种形式影响行业中现有企业的竞争战略。首先,现有企业产品售价以及获利潜力的提高,将由于存在着能被用户方便接受的替代品而受到限制;第二,由于替代品生产者的侵入,使得现有企业必须提高产品质量、或者通过降低成本来降低售价、或者使其产品具有特色,否则其销量与利润增长的目标就有可能受挫;第三,源自替代品生产者的竞争强度,受产品买主转换成本高低的影响。总之,替代品价格越低、质量越好、用户转换成本越低,其所能产生的竞争压力就强;而这种来自替代品生产者的竞争压力的强度,可以具体通过考察替代品销售增长率、替代品厂家生产能力与盈利扩张情况来加以描述。

    3.5.同业竞争者的竞争程度 (Rivalry)

           大部分行业中的企业,相互之间的利益都是紧密联系在一起的,作为企业整体战略一部分的各企业竞争战略,其目标都在于使得自己的企业获得相对于竞争对手的优势,所以,在实施中就必然会产生冲突与对抗现象,这些冲突与对抗就构成了现有企业之间的竞争。现有企业之间的竞争常常表现在价格、广告、产品介绍、售后服务等方面,其竞争强度与许多因素有关。

    三、STAR原则

    1、简介

           所谓STAR原则,即 Situation(情景)、Task(任务)、Action(行动)和Result(结果) 四个英文单词的首字母组合。STAR原则是结构化面试当中非常重要的一个理论。

    2、具体含义
    • Situation情境:HR希望你描述一个你遇到的挑战、项目。(曾经完成的某件重要的且可以当作考评标准的任务的背景状况。比较绕口好好理解下)
    • Task任务:你当时的任务是什么?HR想知道你是怎样在上述情境下明确自己的任务的。
    • Action行动:你做了什么?HR要知道你为上边的任务所付出的行动,为什么这么做?还有其他方案吗?
    • Result结果:结果怎样?从你的行动中,得到了什么?有没有完成目标呢?你获得了那些经验教训呢?之后有没有再用到那些经验呢?

           通常,我们在求职材料上写的都是一些结果,描述自己做过什么,成绩怎样,比较简单和宽泛。HR在面试的时候需要了解应聘者如何做出这样的业绩,做出这样的业绩都使用了一些什么样的方法,采取了什么样的手段。通过这些过程,从而可以全面了解该应聘者的知识、经验、技能的掌握程度以及他的工作风格、性格特点等与工作有关的方面。简而言之,STAR法则就是一种通过结构化思考来讲述故事的方式,能够清晰的向HR展示自己的信息与能力

    四、6W2H法则

    1、简介

           6W2H法也叫八何分析法、6W2H标准化决策&评价模型,常常被运用到企业战略的决策和制定计划以及对工作的规划与分析。
           同时对于设定有效的目标、分析客户需求、制定工作计划等方面,这个工具也非常实用,它能帮我们提高效率和使工作有效地执行。
    在这里插入图片描述

    2、具体含义
    • What:研究的是什么问题?问题和哪些因素有关?条件是什么?重点是什么?与什么有关系?功能是什么?规范是什么?工作对象是什么?

    • Why:为什么要研究这个问题,目的或希望的状态是什么?为什么要用这个参数条件?为什么用这个方法,不能用别的方法替代?为什么非做不可?

    • Who:决策者、行动者、客户等关键干洗人是谁?对项目的影响有多大?谁被忽略了?谁会收益?

    • When:何时能完成?分析的是什么时候的情况?何时验收、安装、销售?需要几天才合理?

    • Where:项目范围边界如何?在哪里进行?环境如何?资源在什么地方?销售、安装在何地?

    • How:如何实现目标?怎么效率更高、更快、更省力?怎样改进?怎样降低风险、避免失败?怎样让成果的价值得以转化?

    • How much:项目指标是什么?预算多少?效率多高?产品参数多少?

    • Which:技术方案有几个?如何选择?最终选择了哪些方案?

    五、黄金思维圈法则

           所谓黄金思维圈,其实是我们认知世界的方式。我们看问题的方式可以分为三个层面。

    • What层面,也就是事情的表象,我们具体做的每一件事;
    • How层面,也就是我们如何去实现我们想要做的事情;
    • Why层面,也就是我们为什么要做这样的事情。

    这是成甲老师在《好好学习》这本书中对黄金思维圈中what-how-why的解释。
           普通人的思维方式是“what-how-why”,黄金思维圈是一种全新的思维方式:先思考why,然后再思考how和what。 黄金思维圈最基本的应用便是:当你遇到每一件事情,首先问自己“为什么”,也就是,问自己为什么要做这件事。
    在这里插入图片描述

    展开全文
  • 单例模式有 3 个特点: 单例类只有一个实例对象; 该单例对象必须由单例类自行创建; 单例类对外提供一个访问该单例的全局访问点; 单例模式的结构与实现 单例模式是设计模式中最简单的模式之一。通常,普通类的构造...

    ☀️一张思维图带大家了解Java常见设计模式☀️《❤️记得收藏❤️》

    目录

    🏳️‍🌈开讲啦!!!!🏳️‍🌈

    在这里插入图片描述

    🏳️‍🌈1、前言

    设计模式的本质是面向对象设计原则的实际运用,是对类的封装性、继承性和多态性以及类的关联关系和组合关系的充分理解,本文主要列举了常用的几种设计模式。

    在这里插入图片描述

    🚂2、单例模式

    🚃2.1、单例模式的定义与特点

    单例(Singleton)模式的定义:

    指一个类只有一个实例,且该类能自行创建这个实例的一种模式。

    单例模式有 3 个特点:

    • 单例类只有一个实例对象;

    • 该单例对象必须由单例类自行创建;

    • 单例类对外提供一个访问该单例的全局访问点;

    🚄2.2、单例模式的结构与实现

    单例模式是设计模式中最简单的模式之一。通常,普通类的构造函数是公有的,外部类可以通过“new 构造函数()”来生成多个实例。但是,如果将类的构造函数设为私有的,外部类就无法调用该构造函数,也就无法生成多个实例。这时该类自身必须定义一个静态私有实例,并向外提供一个静态的公有函数用于创建或获取该静态私有实例。

    🚅2.3、单例模式的结构

    单例模式的主要角色如下:

    • 单例类:包含一个实例且能自行创建这个实例的类。

    • 访问类:使用单例的类。

    在这里插入图片描述

    🚆2.4、单例模式的实现

    Singleton 模式通常有两种实现形式。

    1 、懒汉式单例

    该模式的特点是类加载时没有生成单例,只有当第一次调用 getlnstance 方法时才去创建这个单例。代码如下:

    public class LazySingleton { private static volatile LazySingleton instance=null; 
     //保证 instance 在所有线程中同步
     private LazySingleton(){} 
     //private 避免类在外部被实例化 
     public static synchronized LazySingleton getInstance() 
    { 
    //getInstance 方法前加同步 
    if(instance==null) 
    { 
       instance=new LazySingleton();
    } 
     return instance; 
     }
     }
    

    注意:如果编写的是多线程程序,则必须有上例代码中的关键字 volatilesynchronized,否则将存在线程非安全的问题。这两个关键字保证了线程安全,但是每次访问时都要同步,会影响性能,且消耗更多的资源,这是懒汉式单例的缺点。

    2 、饿汉式单例

    该模式的特点是类一旦加载就创建一个单例,保证在调用 getInstance 方法之前单例已经存在了。

    public class HungrySingleton 
    { 
    private static final HungrySingleton instance=new HungrySingleton();
    private HungrySingleton(){} 
    public static HungrySingleton getInstance() 
     { 
     return instance;
     } 
     }
    
    

    饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用,以后不再改变,所以是线程安全的,可以直接用于多线程而不会出现问题。

    单例模式的应用实例

    用懒汉式单例模式模拟产生董事长对象。

    public class SingletonLazy
    { 
    public static void main(String[] args) 
    { President zt1=President.getInstance(); zt1.getName(); 
    //输出董事长名字 
    President zt2=President.getInstance(); zt2.getName(); 
    //输出董事长名字 
    if(zt1==zt2) 
     { 
    System.out.println("他们是同一人!"); 
     } 
    else
     { 
    System.out.println("他们不是同一人!"); } 
      }
     } 
     class President 
     {
      private static volatile President instance=null; 
      //保证instance在所有线程中同步 
      //private避免类在外部被实例化 
      private President()
       { 
       System.out.println("产生一个董事长!"); 
       } 
       public static synchronized President getInstance() 
       { 
       //在getInstance方法上加同步 if(instance==null)
       { instance=new President(); 
       }
        else 
        { System.out.println("已经有一个董事长,不能产生新董事长!"); }
         return instance; 
        } 
        public void getName() 
        { System.out.println("我是董事长:xxx。"); 
        } 
        }
    

    运行结果:
    在这里插入图片描述

    🚇3、原型模式

    🚈3.1、原型模式的定义与特点

    原型(Prototype)模式的定义如下:

    用一个已经创建的实例作为原型,通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里,原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效,根本无须知道对象创建的细节。

    🚉3.2、原型模式的结构与实现

    由于 Java提供了对象的 clone() 方法,所以用 Java 实现原型模式很简单。
    在这里插入图片描述
    1、模式的结构:

    原型模式包含以下主要角色:

    • 抽象原型类:规定了具体原型对象必须实现的接口。

    • 具体原型类:实现抽象原型类的 clone() 方法,它是可被复制的对象。

    • 访问类:使用具体原型类中的 clone() 方法来复制新的对象。

    2、 模式的实现

    原型模式的克隆分为浅克隆深克隆,Java 中的 Object 类提供了浅克隆的 clone() 方法,具体原型类只要实现 Cloneable 接口就可实现对象的浅克隆,这里的 Cloneable 接口就是抽象原型类。其代码如下:

    //具体原型类 
    class Realizetype implements Cloneable 
    { 
    Realizetype() { System.out.println("具体原型创建成功!"); 
    } 
    public Object clone() throws CloneNotSupportedException 
    { 
    System.out.println("具体原型复制成功!"); return (Realizetype)super.clone(); 
    } 
    } 
    //原型模式的测试类 
    public class PrototypeTest 
      { 
    public static void main(String[] args)throws CloneNotSupportedException 
      { 
    Realizetype obj1=new Realizetype(); 
    Realizetype obj2=(Realizetype)obj1.clone();
    System.out.println("obj1==obj2?"+(obj1==obj2));
     }
      }
    
    

    运行结果:
    在这里插入图片描述

    🚊3.3、原型模式的应用实例

    用原型模式生成“三好学生”奖状。

    public class ProtoTypeCitation 
    {
     public static void main(String[] args) throws CloneNotSupportedException 
     { 
     citation obj1=new citation("小红","同学:在2020学年第一学期中表现优秀,被评为三好学生。","信息学院"); 
     obj1.display(); 
     citation obj2=(citation) obj1.clone(); 
     obj2.setName("小明"); 
     obj2.display(); 
     } 
     } 
     //奖状类 
     class citation implements Cloneable 
     { 
     String name; String info; 
     String college; citation(String name,String info,String college) 
     { 
     this.name=name; this.info=info;
      this.college=college;
       System.out.println("奖状创建成功!");
       } 
       void setName(String name) 
       {
        this.name=name; 
        } 
        String getName()
         { 
        return(this.name);
         } 
         void display() 
         { 
         System.out.println(name+info+college);
          }
           public Object clone() throws CloneNotSupportedException 
           {
            System.out.println("奖状拷贝成功!"); 
            return (citation)super.clone();
             } 
             }
    

    运行结果:
    在这里插入图片描述

    🚝4、工厂方法模式

    🚞4.1、工厂方法模式的定义与特点

    工厂方法(FactoryMethod)模式的定义:

    定义一个创建产品对象的工厂接口,将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点,被创建的对象称为“产品”,把创建产品的对象称为“工厂。

    工厂方法模式的主要优点和缺点有:

    • 用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程

    • 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类,无须对原工厂进行任何修改,满足开闭原则;

    • 其缺点是:每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类,这增加了系统的复杂度。

    🚋4.2、工厂方法模式的结构与实现

    工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。

    1、模式的结构:

    工厂方法模式的主要角色如下:

    • 抽象工厂(Abstract Factory):提供了创建产品的接口,调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。

    • 具体工厂(ConcreteFactory):主要是实现抽象工厂中的抽象方法,完成具体产品的创建。

    • 抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能。

    • 具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间一一对应。

    2、模式的实现

    /** 
    * 冰箱接口 
    * */ 
    public interface IRefrigerator 
    { 
    //获取品牌名
     String getBrandName(); 
     //获取价格 
     double getPrice();
      }
    
    /**
     * 冰箱工厂接口
     */
    public interface IRefrigeratorFactory {
    
        IRefrigerator getIRefrigerator();
    }
    /** * 海尔冰箱 */
     public class HaiErRefrigerator implements IRefrigerator { 
     @Override 
     public String getBrandName() { return "海尔冰箱"; 
     }
     @Override 
     public double getPrice() { return 5999; 
     } 
     } 
     /** * 美的冰箱 */
      public class MeiDiRefrigerator implements IRefrigerator { 
      @Override
      public String getBrandName() { return "美的冰箱";
       } 
        @Override 
        public double getPrice() { return 2999;} 
         } 
         /** * 格力冰箱 */ 
         public class GeLiRefrigerator implements IRefrigerator 
         { 
         @Override 
         public String getBrandName() { 
         return "格力冰箱";
          } 
          @Override
           public double getPrice()
            { 
            return 3999; 
            } 
            }
    
    /** * 海尔冰箱工厂 */ 
    public class HaiErRefrigeratorFactory implements IRefrigeratorFactory 
    {
     @Override 
     public IRefrigerator getIRefrigerator() 
     { 
     return new HaiErRefrigerator(); 
     } 
     } 
     /** * 美的冰箱工厂 */ 
     public class MeiDiRefrigeratorFactory implements IRefrigeratorFactory { 
     @Override 
     public IRefrigerator getIRefrigerator() { 
     return new MeiDiRefrigerator(); 
     } 
     }
      /** * 格力冰箱工厂 */
       public class GeLiRefrigeratorFactory implements IRefrigeratorFactory 
       { 
       @Override
       public IRefrigerator getIRefrigerator() 
       { 
       return new GeLiRefrigerator(); 
       } 
       }
    /** * 测试类 */ 
    public class Test { 
    public static void main(String[] args) 
    { 
    IRefrigeratorFactory refrigeratorFactory = new HaiErRefrigeratorFactory(); 
    IRefrigeratorFactory refrigeratorFactory2 = new GeLiRefrigeratorFactory();
     IRefrigeratorFactory refrigeratorFactory3 = new MeiDiRefrigeratorFactory(); 
     IRefrigerator refrigerator = refrigeratorFactory.getIRefrigerator();
    
     System.out.println("您购买了:" + refrigerator.getBrandName() + ",您需要支付:" + refrigerator.getPrice()); 
     }
      }
    
    

    运行结果:
    在这里插入图片描述

    🚌5、抽象工厂模式

    🚍5.1、抽象工厂模式的定义与特点

    抽象工厂(AbstractFactory)模式的定义:是一种为访问类提供一个创建一组相关或相互依赖对象的接口,且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

    抽象工厂模式是工厂方法模式的升级版本,工厂方法模式只生产一个等级的产品,而抽象工厂模式可生产多个等级的产品。

    使用抽象工厂模式一般要满足以下条件。

    系统中有多个产品族,每个具体工厂创建同一族但属于不同等级结构的产品。
    系统一次只可能消费其中某一族产品,即同族的产品一起使用。

    🚎5.2、抽象工厂模式的结构与实现

    抽象工厂模式同工厂方法模式一样,也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成,但抽象工厂中方法个数不同,抽象产品的个数也不同。

    1、抽象工厂模式的结构

    抽象工厂模式的主要角色如下:

    • 抽象工厂(Abstract Factory):提供了创建产品的接口,它包含多个创建产品的方法 newProduct(),可以创建多个不同等级的产品。

    • 具体工厂(Concrete Factory):主要是实现抽象工厂中的多个抽象方法,完成具体产品的创建。

    • 抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能,抽象工厂模式有多个抽象产品。

    • 具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它 同具体工厂之间是多对一的关系。

    2、抽象工厂模式的实现

    • 1、抽象工厂:提供了产品的生成方法。
    interface AbstractFactory
    {
        public Product1 newProduct1();
        public Product2 newProduct2();
    }
    
    • 2、具体工厂:实现了产品的生成方法。
    class ConcreteFactory1 implements AbstractFactory 
    {
     public Product1 newProduct1()
      { 
      System.out.println("具体工厂 1 生成-->具体产品 11..."); 
      return new ConcreteProduct11(); 
      } 
      public Product2 newProduct2()
       { 
       System.out.println("具体工厂 1 生成-->具体产品 21...");
        return new ConcreteProduct21();
         } 
         }
    
    • 3、抽象工厂模式的应用实例
    /** * 为形状创建一个接口 */
     public interface Shape 
     {
      void draw(); 
      } 
      ** * 为颜色创建一个接口 */ 
      public interface Color 
      { 
      void fill();
       }
    /** * 创建实现接口的实体类 */ 
    public class Rectangle implements Shape 
    {
     @Override 
     public void draw() 
     {
     System.out.println("Inside Rectangle::draw() method."); 
     }
     } 
     public class Square implements Shape
      {
       @Override 
       public void draw() { 
       System.out.println("Inside Square::draw() method."); 
       } 
       } 
       public class Circle implements Shape
       { 
       @Override
       public void draw()
         { 
         System.out.println("Inside Circle::draw() method.");
         } 
         } 
         /** * 创建实现接口的实体类 */
          public class Red implements Color 
          {
           @Override
            public void fill() 
            { 
            System.out.println("Inside Red::fill() method.");   } 
            }
             public class Green implements Color 
             { 
             @Override
              public void fill() { 
              System.out.println("Inside Green::fill() method.");  } 
              } 
              public class Blue implements Color 
              {
               @Override public void fill() 
               { 
               System.out.println("Inside Blue::fill() method."); 
               } 
               }
    /** * 为 Color 和 Shape 对象创建抽象类来获取工厂 */ 
    interface AbstractFactory 
    { 
     public Color getColor(String color);
     public Shape getShape(String shape) ;
      }
    /** * 创建扩展了 AbstractFactory 的工厂类,基于给定的信息生成实体类的对象 */ 
    public class ShapeFactory extends AbstractFactory {
     @Override 
     public Shape getShape(String shapeType){ 
     if(shapeType == null){ 
     return null; 
     } 
     if(shapeType.equalsIgnoreCase("CIRCLE")){
      return new Circle(); 
      } 
      else if(shapeType.equalsIgnoreCase("RECTANGLE"))
      {
      return new Rectangle(); }
       else if(shapeType.equalsIgnoreCase("SQUARE"))
       {
        return new Square(); 
        } return null; 
        }
         @Override 
         public Color getColor(String color) {
          return null; 
          } 
          }
    /** * 创建一个工厂创造器/生成器类,通过传递形状或颜色信息来获取工厂 */ 
    public class FactoryProducer {
     public static AbstractFactory getFactory(String choice){ 
     if(choice.equalsIgnoreCase("SHAPE")){ 
     return new ShapeFactory(); 
     } 
     else if(choice.equalsIgnoreCase("COLOR")){ 
     return new ColorFactory(); 
     } 
     return null; 
     } 
     
     }
    public class AbstractFactoryPatternDemo 
    { 
    public static void main(String[] args)
     { 
     //获取形状工厂
      AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE"); 
      //获取形状为 Circle 的对象
       Shape shape1 = shapeFactory.getShape("CIRCLE"); 
       //调用 
       Circle 的 draw 方法 shape1.draw(); 
       //获取形状为 Rectangle 的对象 
       Shape shape2 = shapeFactory.getShape("RECTANGLE");
        //调用 Rectangle 的 draw 方法 
        shape2.draw(); 
        //获取形状为 Square 的对象 
        Shape shape3 = shapeFactory.getShape("SQUARE"); 
        //调用 Square 的 draw 方法 
        shape3.draw(); 
        //获取颜色工厂
         AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
        //获取颜色为 Red 的对象 
        Color color1 = colorFactory.getColor("RED"); 
       //调用 Red 的 fill 方法 color1.fill(); 
       //获取颜色为 Green 的对象 
       Color color2 = colorFactory.getColor("Green"); 
       //调用 Green 的 fill 方法 color2.fill(); 
       //获取颜色为 Blue 的对象 
       Color color3 = colorFactory.getColor("BLUE"); 
       //调用 Blue 的 fill 方法 
       color3.fill(); 
       }
        }
    

    运行结果:

    Inside Circle::draw() method.
    Inside Rectangle::draw() method.
    Inside Square::draw() method.
    Inside Red::fill() method.
    Inside Green::fill() method.
    Inside Blue::fill() method.
    

    🚐6、设计代理模式

    🚑6.1、代理模式的定义与特点

    代理模式的定义:

    由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时,访问对象不适合或者不能直接引用目标对象,代理对象作为访问对象和目标对象之间的中介。

    代理模式的主要优点有:

    代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用;

    代理对象可以扩展目标对象的功能;

    代理模式能将客户端与目标对象分离,在一定程度上降低了系统的耦合度;

    其主要缺点是:

    在客户端和目标对象之间增加一个代理对象,会造成请求处理速度变慢;

    增加了系统的复杂度;

    🚒6.2、代理模式的结构与实现

    代理模式的结构比较简单,主要是通过定义一个继承抽象主题的代理来包含真实主题,从而实现对真实主题的访问,下面来分析其基本结构和实现方法。

    1、模式的结构

    代理模式的主要角色如下:

    • 抽象主题(Subject)类:通过接口或抽象类声明真实主题和代理对象实现的业务方法。

    • 真实主题(Real Subject)类:实现了抽象主题中的具体业务,是代理对象所代表的真实对象,是最终要引用的对象。

    • 代理(Proxy)类:提供了与真实主题相同的接口,其内部含有对真实主题的引用,它可以访问、控制或扩展真实主题的功能

    在这里插入图片描述
    2、模式的实现

    代理模式的实现代码如下:

    //抽象主题
    interface Subject
    {
        void Request();
    }
    //真实主题
    class RealSubject implements Subject
    {
        public void Request()
        {
            System.out.println("访问真实主题方法...");
        }
    }
    //代理
    class Proxy implements Subject
    {
        private RealSubject realSubject;
        public void Request()
        {
            if (realSubject==null)
            {
                realSubject=new RealSubject();
            }
            preRequest();
            realSubject.Request();
            postRequest();
        }
        public void preRequest()
        {
            System.out.println("访问真实主题之前的预处理。");
        }
        public void postRequest()
        {
            System.out.println("访问真实主题之后的后续处理。");
        }
    }
       public static void main(String[] args)
        {
            Proxy proxy=new Proxy();
            proxy.Request();
        }
    
    

    运行结果

    访问真实主题之前的预处理。
    访问真实主题方法...
    访问真实主题之后的后续处理。
    

    🚓6.3、代理模式的应用实例

    interface Manager 
    {
        void doSomething();
    }
    class Admin implements Manager{
    
        @Override
        public void doSomething() {
            System.out.println("来自Admin方法doSomething!");
        }
    
    }
    
    class AdminProxy implements Manager{
        Admin admin;
        public AdminProxy(Admin admin){
            this.admin = admin;
        }
    
        @Override
        public void doSomething() {
            System.out.println("----开始了----");
            admin.doSomething();
            System.out.println("----结束了----");
        }
    
    }
    
    public static void main(String[] args) {
            AdminProxy ap = new AdminProxy(new Admin());
            ap.doSomething();
    
        }
    

    运行结果

    ----开始了----
    来自Admin方法doSomething!
    ----结束了----
    

    🚔7、动态代理

    代理类在程序运行时创建的代理方式被成为动态代理。 我们上面静态代理的例子中,代理类(Proxy)是自己定义好的,在程序运行之前就已经编译完成。然而动态代理,代理类并不是在Java代码中定义的,而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理, 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理,而不用修改每个代理类中的方法。

    🚕7.1、JDK动态代理

    代理步骤:

    • 定义一个事件管理器类实现InvocationHandler接口,并重写invoke(代理类,被代理的方法,方法的参数列表)方法。

    • 实现被代理类及其实现的接口。

    • 调用Proxy.newProxyInstance(类加载器,类实现的接口,事务处理器对象);生成一个代理实例。

    • 通过该代理实例调用方法。

    实现代码:

    public interface Moveable {  
        void move()  throws Exception;  
    }  
    //2. 真实主题  
    public class Car implements Moveable {  
        public void move() throws Exception {  
            Thread.sleep(new Random().nextInt(1000));  
            System.out.println("汽车行进中…");  
        }  
    }
    //3.事务处理器  
    public class TimeHandler implements InvocationHandler {  
        private Object target;  
    
        public TimeHandler(Object target) {  
            super();  
            this.target = target;  
        }  
    
        /** 
         * 参数: 
         *proxy 被代理的对象 
         *method 被代理对象的方法 
         *args 方法的参数  
         *Object 方法返回值 
         */  
        public Object invoke(Object proxy, Method method, Object[] args)  
                throws Throwable {  
            long startTime = System.currentTimeMillis();  
            System.out.println("汽车开始行进…");  
            method.invoke(target, args);  
            long stopTime = System.currentTimeMillis();  
            System.out.println("汽车结束行进…汽车行驶时间:" + (stopTime - startTime) + "毫秒!");  
            return null;  
        }  
    
    }  
    
        public static void main(String[] args) throws Exception {
            Car car=new Car();
            InvocationHandler h=new TimeHandler(car);
            Moveable moveable=(Moveable)Proxy.newProxyInstance(car.getClass().getClassLoader(),car.getClass().getInterfaces(),h);
            moveable.move();
        }
    

    运行结果

    汽车开始行进…
    汽车行进中…
    汽车结束行进…汽车行驶时间:19毫秒!
    

    在测试代码中,Proxy.newProxyInstance()方法需要3个参数:类加载器(要进行代理的类)、被代理类实现的接口,事务处理器。所以先实例化Car,实例化InvocationHandler的子类TimeHandler,将各参数传入Proxy的静态方法newProxyInstance()即可获得Car的代理类,前面的静态代理,代理类是我们编写好的,而动态代理则不需要我们去编写代理类,是在程序中动态生成的。

    🚖7.2、cglib动态代理

    Java只允许单继承,而JDK生成的代理类本身就继承了Proxy类,因此,使用JDK实现的动态代理不能完成继承式的动态代理,但是我们可以使用cglib来实现继承式的动态代理。

        public void move(){
            System.out.println("火车行驶中…");
        }
    }
    
    public class CGLibProxy implements MethodInterceptor {
    
        private  Object target;
    
        public Object getProxy(Object target)
        {
            this.target=target;
            Enhancer enhancer=new Enhancer();
            enhancer.setSuperclass(this.target.getClass());
            enhancer.setCallback(this);
           return enhancer.create();
        }
    
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            //代理类调用父类的方法
            System.out.println("日志开始");
            methodProxy.invokeSuper(o,objects);
            System.out.println("日志结束");
            return null;
        }
    }
    
        public static void main(String[] args) {
    
          CGLibProxy proxy=new CGLibProxy();
            Train res = (Train) proxy.getProxy(new Train());
            res.move();
        }
    

    运行结果:

    日志开始
    火车行驶中…
    日志结束
    

    分析:

    动态代理与静态代理相比较,最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理。在接口方法数量比较多的时候,我们可以进行灵活处理,而不需要像静态代理那样对每一个方法或方法组合进行处理。Proxy 确实很强大,但是仅支持 interface 代理。Java 的单继承机制注定了这些动态代理类们无法实现对 class 的动态代理。好在有cglib为Proxy提供了弥补,它允许类在不实现接口的前提下而实现动态代理。

    🚗8、装饰模式

    🚘8.1、装饰模式的定义与特点

    装饰(Decorator)模式的定义:指在不改变现有对象结构的情况下,动态地给该对象增加一些职责(即增加其额外功能)的模式,它属于对象结构型模式。

    装饰(Decorator)模式的主要优点有:

    采用装饰模式扩展对象的功能比采用继承方式更加灵活。

    可以设计出多个不同的具体装饰类,创造出多个不同行为的组合。

    其主要缺点是:装饰模式增加了许多子类,如果过度使用会使程序变得很复杂。

    🚙8.2、装饰模式的结构与实现

    通常情况下,扩展一个类的功能会使用继承方式来实现。但继承具有静态特征,耦合度高,并且随着扩展功能的增多,子类会很膨胀。如果使用组合关系来创建一个包装对象(即装饰对象)来包裹真实对象,并在保持真实对象的类结构不变的前提下,为其提供额外的功能,这就是装饰模式的目标。下面来分析其基本结构和实现方法。

    1、模式的结构

    装饰模式主要包含以下角色。

    • 抽象构件(Component)角色:定义一个抽象接口以规范准备接收附加责任的对象。

    • 具体构件(Concrete Component)角色:实现抽象构件,通过装饰角色为其添加一些职责。

    • 抽象装饰(Decorator)角色:继承抽象构件,并包含具体构件的实例,可以通过其子类扩展具体构件的功能。

    • 具体装饰(ConcreteDecorator)角色:实现抽象装饰的相关方法,并给具体构件对象添加附加的责任。

    2、模式的实现

    装饰模式的实现代码如下:

    //抽象构件角色
    interface  Component
    {
        public void operation();
    }
    
    //具体构件角色
    class ConcreteComponent implements Component
    {
        public ConcreteComponent()
        {
            System.out.println("创建具体构件角色");       
        }   
        public void operation()
        {
            System.out.println("调用具体构件角色的方法operation()");           
        }
    }
    
    //抽象装饰角色
    class Decorator implements Component
    {
        private Component component;   
        public Decorator(Component component)
        {
            this.component=component;
        }   
        public void operation()
        {
            component.operation();
        }
    }
    
    //具体装饰角色
    class ConcreteDecorator extends Decorator
    {
        public ConcreteDecorator(Component component)
        {
            super(component);
        }   
        public void operation()
        {
            super.operation();
            addedFunction();
        }
        public void addedFunction()
        {
            System.out.println("为具体构件角色增加额外的功能addedFunction()");           
        }
    }
    
      public static void main(String[] args)
        {
            Component p=new ConcreteComponent();
            p.operation();
            System.out.println("---------------------------------");
            Component d=new ConcreteDecorator(p);
            d.operation();
        }
    

    运行结果

    创建具体构件角色
    调用具体构件角色的方法operation()
    ---------------------------------
    调用具体构件角色的方法operation()
    为具体构件角色增加额外的功能addedFunction()
    

    🚚8.3装饰模式的应用实例

    首先定义一个接口Human

    public interface Human 
    {
        public void run();
    }
    

    其次定义一个被装饰的类Man

    public class Man implements Human
     {
        @Override
        public void run() {
            System.out.println("人会跑步");
        }
    }
    

    然后定义一个装饰的抽象类

    
    public abstract class AbstractDecorator implements Human
    {
        //持有被装饰类的引用 
        private Human human;
    
        //构造函数注入被装饰者
        public AbstractDecorator(Human human) {
            this.human = human;
        }
    
        //调用被装饰类的方法
        @Override
        public void run() {
            human.run();
        }
    }
    

    最后定义一个装饰的实现类

    public class ManDecorator extends AbstractDecorator {
        public ManDecorator(Human human) {
            //调用父类的构造方法
            super(human);
        }
    
        //装饰类增加的功能
        private void fly() {
            System.out.println("人也许飞哦");
        }
    
        //增强了功能的run方法
        @Override
        public void run() {
            super.run();
            fly();
        }
    }
    

    主方法:

    public static void main(String[] args) {
            //创建被装饰的类
            Human human = new Man();
    
            //创建装饰的类,并添加被装饰类的引用
            Human superMan = new ManDecorator(human);
    
            //执行增强后的run方法
            superMan.run();
        }
    

    运行结果

    人会跑步
    人也许飞哦
    

    🚛8.3、装饰模式的应用场景

    当需要给一个现有类添加附加职责,而又不能采用生成子类的方法进行扩充时。例如,该类被隐藏或者该类是终极类或者采用继承方式会产生大量的子类。

    当需要通过对现有的一组基本功能进行排列组合而产生非常多的功能时,采用继承关系很难实现,而采用装饰模式却很好实现。

    当对象的功能要求可以动态地添加,也可以再动态地撤销时。

    装饰模式在 Java语言中的最著名的应用莫过于 Java I/O 标准库的设计了。

    例如,InputStream 的子类 FilterInputStreamOutputStream 的子类 FilterOutputStreamReader 的子类 BufferedReader 以及 FilterReader,还有 Writer 的子类 BufferedWriter、FilterWriter 以及 PrintWriter 等,它们都是抽象装饰类

    例如:为 FileReader 增加缓冲区而采用的装饰类 BufferedReader

    BufferedReader in= new BufferedReader(new FileReader("filename.txt"));
    String s=in.readLine();
    

    🚜9、适配器模式

    🏎9.1、适配器模式的定义与特点

    适配器模式(Adapter)的定义如下:将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的那些类能一起工作。适配器模式分为类结构型模式和对象结构型模式两种。

    适配器模式的主要优点如下:

    • 客户端通过适配器可以透明地调用目标接口。

    • 复用了现存的类,程序员不需要修改原有代码而重用现有的适配者类。

    • 将目标类和适配者类解耦,解决了目标类和适配者类接口不一致的问题。

    🏍9.2、适配器模式的结构与实现

    1、模式的结构

    适配器模式(Adapter)包含以下主要角色。

    • 目标(Target)接口:当前系统业务所期待的接口,它可以是抽象类或接口。

    • 适配者(Adaptee)类:它是被访问和适配的现存组件库中的组件接口。

    • 适配器(Adapter)类:它是一个转换器,通过继承或引用适配者的对象,把适配者接口转换成目标接口,让客户按目标接口的格式访问适配者。

    类适配器模式的结构图如图所示:

    在这里插入图片描述

    对象适配器模式的结构图如图所示在这里插入图片描述
    2、模式的实现

    (1) 、类适配器模式的代码

    //目标接口
    interface Target
    {
        public void request();
    }
    //适配者接口
    class Adaptee
    {
        public void specificRequest()
        {       
            System.out.println("适配者中的业务代码被调用!");
        }
    }
    //类适配器类
    class ClassAdapter extends Adaptee implements Target
    {
        public void request()
        {
            specificRequest();
        }
    }
    //客户端代码
    public class ClassAdapterTest
    {
        public static void main(String[] args)
        {
            System.out.println("类适配器模式测试:");
            Target target = new ClassAdapter();
            target.request();
        }
    }
    

    运行结果

    类适配器模式测试:
    适配者中的业务代码被调用!
    

    (2)、对象适配器模式的代码

    //目标接口
    interface Target
    {
        public void request();
    }
    //适配者接口
    class Adaptee
    {
        public void specificRequest()
        {       
            System.out.println("适配者中的业务代码被调用!");
        }
    }
    //对象适配器类
    class ObjectAdapter implements Target
    {
        private Adaptee adaptee;
        public ObjectAdapter(Adaptee adaptee)
        {
            this.adaptee=adaptee;
        }
        public void request()
        {
            adaptee.specificRequest();
        }
    }
    //客户端代码
    
        public static void main(String[] args)
        {
            System.out.println("对象适配器模式测试:");
            Adaptee adaptee = new Adaptee();
            Target target = new ObjectAdapter(adaptee);
            target.request();
        }
    

    模式的应用实例

    public interface Restaurant {
        public void haveFood();
        public void haveDrink();
    }
    
    public class RestaurantImpl implements Restaurant{
    
        @Override
        public void haveFood() {
            System.out.println("提供各种美食");
    
        }
    
        @Override
        public void haveDrink() {
            System.out.println("提供各种饮料");
    
        }
    
    }
    
    public interface Bar {
        public void haveSong();
    }
    
    public class MyRestaurantAdapter extends RestaurantImpl implements Bar{
    
        @Override
        public void haveSong() {
            System.out.println("在餐厅同样提供酒吧的驻唱服务");
        }
    
    }
    
       public static void main(String[] args) {
            MyRestaurantAdapter adapter = new MyRestaurantAdapter();
            adapter.haveFood();
            adapter.haveDrink();
            adapter.haveSong();
        }
    

    运行结果

    提供各种美食
    提供各种饮料
    在餐厅同样提供酒吧的驻唱服务
    

    🚧9.3、适配器模式的应用场景

    适配器模式(Adapter)通常适用于以下场景。

    以前开发的系统存在满足新系统功能需求的类,但其接口同新系统的接口不一致。

    使用第三方提供的组件,但组件接口定义和自己要求的接口定义不同。

    🛑10、观察者模式

    🚦10.1、观察者模式的定义与特点

    观察者(Observer)模式的定义:指多个对象间存在一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式,它是对象行为型模式。

    观察者模式是一种对象行为型模式,其主要优点如下:

    • 降低了目标与观察者之间的耦合关系,两者之间是抽象耦合关系。

    • 目标与观察者之间建立了一套触发机制。

    🚥10.2、观察者模式的结构与实现

    1、模式的结构

    观察者模式的主要角色如下:

    • 抽象主题(Subject)角色:也叫抽象目标类,它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法,以及通知所有观察者的抽象方法。

    • 具体主题(Concrete Subject)角色:也叫具体目标类,它实现抽象目标中的通知方法,当具体主题的内部状态发生改变时,通知所有注册过的观察者对象。

    • 抽象观察者(Observer)角色:它是一个抽象类或接口,它包含了一个更新自己的抽象方法,当接到具体主题的更改通知时被调用。

    • 具体观察者(Concrete Observer)角色:实现抽象观察者中定义的抽象方法,以便在得到目标的更改通知时更新自身的状态。

    2、模式的实现

    观察者模式的实现代码

    //抽象目标
    abstract class Subject
    {
        protected List<Observer> observers=new ArrayList<Observer>();   
        //增加观察者方法
        public void add(Observer observer)
        {
            observers.add(observer);
        }    
        //删除观察者方法
        public void remove(Observer observer)
        {
            observers.remove(observer);
        }   
        public abstract void notifyObserver(); //通知观察者方法
    }
    //具体目标
    class ConcreteSubject extends Subject
    {
        public void notifyObserver()
        {
            System.out.println("具体目标发生改变...");
            System.out.println("--------------");       
    
            for(Object obs:observers)
            {
                ((Observer)obs).response();
            }
    
        }          
    }
    //抽象观察者
    interface Observer
    {
        void response(); //反应
    }
    //具体观察者1
    class ConcreteObserver1 implements Observer
    {
        public void response()
        {
            System.out.println("具体观察者1作出反应!");
        }
    }
    //具体观察者1
    class ConcreteObserver2 implements Observer
    {
        public void response()
        {
            System.out.println("具体观察者2作出反应!");
        }
    }
        public static void main(String[] args)
        {
            Subject subject=new ConcreteSubject();
            Observer obs1=new ConcreteObserver1();
            Observer obs2=new ConcreteObserver2();
            subject.add(obs1);
            subject.add(obs2);
            subject.notifyObserver();
        }
        
    

    运行结果

    具体目标发生改变...
    --------------
    具体观察者1作出反应!
    具体观察者2作出反应!
    

    🚨10.3、观察者模式的应用实例

    利用观察者模式设计一个程序,分析“人民币汇率”的升值或贬值对进口公司的进口产品成本或出口公司的出口产品收入以及公司的利润率的影响。

    //抽象目标:汇率
    abstract class Rate
    {
        protected List<Company> companys=new ArrayList<Company>();   
        //增加观察者方法
        public void add(Company company)
        {
            companys.add(company);
        }    
        //删除观察者方法
        public void remove(Company company)
        {
            companys.remove(company);
        }   
        public abstract void change(int number);
    }
    
    //具体目标:人民币汇率
    class RMBrate extends Rate 
    {
        public void change(int number)
        {       
            for(Company obs:companys)
            {
                ((Company)obs).response(number);
            }       
        }
    }
    
    //抽象观察者:公司
    interface Company
    {
        void response(int number);
    }
    
    //具体观察者1:进口公司 
    class ImportCompany implements Company 
    {
        public void response(int number) 
        {
            if(number>0)
            {
                System.out.println("人民币汇率升值"+number+"个基点,降低了进口产品成本,提升了进口公司利润率。"); 
            }
            else if(number<0)
            {
                  System.out.println("人民币汇率贬值"+(-number)+"个基点,提升了进口产品成本,降低了进口公司利润率。"); 
            }
        } 
    } 
    //具体观察者2:出口公司
    class ExportCompany implements Company 
    {
        public void response(int number) 
        {
            if(number>0)
            {
                System.out.println("人民币汇率升值"+number+"个基点,降低了出口产品收入,降低了出口公司的销售利润率。"); 
            }
            else if(number<0)
            {
                  System.out.println("人民币汇率贬值"+(-number)+"个基点,提升了出口产品收入,提升了出口公司的销售利润率。"); 
            }
        } 
    }
    
      public static void main(String[] args)
        {
            Rate rate=new RMBrate();         
            Company watcher1=new ImportCompany(); 
            Company watcher2=new ExportCompany();           
            rate.add(watcher1); 
            rate.add(watcher2);           
            rate.change(10);
            rate.change(-9);
        }
    

    运行结果

    人民币汇率升值10个基点,降低了进口产品成本,提升了进口公司利润率。
    人民币汇率升值10个基点,降低了出口产品收入,降低了出口公司的销售利润率。
    人民币汇率贬值9个基点,提升了进口产品成本,降低了进口公司利润率。
    人民币汇率贬值9个基点,提升了出口产品收入,提升了出口公司的销售利润率。
    

    ⛽️10.4、观察者模式的应用场景

    通过前面的分析与应用实例可知观察者模式适合以下几种情形。

    对象间存在一对多关系,一个对象的状态发生改变会影响其他对象。

    当一个抽象模型有两个方面,其中一个方面依赖于另一方面时,可将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。

    在这里插入图片描述

    🏳️‍🌈关注苏州程序大白,持续更新技术分享。谢谢大家支持🏳️‍🌈

    在这里插入图片描述

    展开全文
  • 思维导图又叫做心智图,是利用图形化的方式进行发散性思维的一种工具,它把复杂性的知识体系转化为形象化的图形表示,更加形象具体。思维导图利用图形化的方式充分调动左右脑的能力,开启我们大脑的潜能。 ...

    思维导图又叫做心智图,是利用图形化的方式进行发散性思维的一种工具,它把复杂性的知识体系转化为形象化的图形表示,更加形象具体。思维导图利用图形化的方式充分调动左右脑的能力,开启我们大脑的潜能。

     
    2374770-c0b1a720453416e8.PNG!thumbnail
     

     

    思维导图的发明者是英国的心理学家东尼博赞,它是世界记忆力协会的创始人,因创造思维导图而闻名于世的"头脑大师"。思维导图模拟了人类大脑的思维方式,利用利用放射性线条的方式,通过关键词逐渐延伸,深度思考!目前很多大型的商业机构都把思维导图作为员工必须掌握的一种技能,用来帮助提高员工的创新能力和学习能力!

    思维导图作为一个强大的辅助学习工具,可以用于以下几个方面:

    会议记录

    规划制定

    项目管理

    学习笔记

    展示解说

    读书笔记

    头脑风暴

    决策制定

     
    2374770-9054c9f322e7e134.JPG!thumbnail
     

     

     

    以前思维导图是在纸张上绘制出来,通常我们会使用一张大型的白纸,先绘制一个中心关机键词,然后从这个中心节点逐渐向外绘制,在绘制的过程中结合不同颜色的线条,并且可以对一些节点绘制一些图形进行美化。虽然手绘的思维导图可以充分体现绘制的过程,制作思维导图的过程中,也可以更形象的对绘制的内容进行理解。但是手绘的思维导图也存在很大的劣势,比如如果在绘制的过中出现了错误,不方便进行修改,对思维导图保存的话,容易出现损坏和丢失的情况。不过随着计算机和智能设备的不断普及,思维导图的绘制也变得更加的简单,我们不需要太多的手绘基础,只需要懂得一些简单的电脑操作,就可以轻松的绘制思维导图。目前,有很多制作思维导图的软件,甚至很多的软件都附加了利用思维导图进行思维整理的功能,比如印象笔记和有道云笔记都增加了思维导图的制作功能。我们常见的思维导图制作工具主要有 以下几种:

    1.Xmind

    国内最常用的思维导图之一,可以很方便的制作各种形式的思维导图。并且xmind还有一个"弟弟"——xmind zen。xmind zen制作的思维导图更加的漂亮,美观,并且界面设计的非常的精简,很适合对思维导图格式要求不是那么高的人使用!

     
    2374770-2a457ed85c3b7035.PNG!thumbnail
     

     

    2.mindmaneger

    也是一款非常优秀的思维导图应用,在商业中的应用非常的广泛,功能也很强大。但是这个软件的正版价格不菲,不想xmind即使免费版也可以使用软件的大部分功能,而mindmaneger在不付费的情况下是无法使用的,另外,笔者感觉这个软件在绘制的思维导图的美观程度上不如xmind。

    3.mindmaster

    相信不少职场上的人士,都听过亿图图示这款软件,绘制功能非常的强大。亿图本身就支持思维导图的绘制,而mindmaster则是亿图开发的专业绘制思维导图的工具,在第一次使用这款思维导图工具的时候真是惊艳到了我,真美想到国人自己开发的软件可以把界面做的如此精美,功能做的如此强大。

    4.幕布

    幕布不能完全称得上一款思维导图工具,他是把大纲笔记和思维导图结合在一起的一款效率工具,我们可以使用大纲笔记轻松的整理知识点,之后利用幕布的一键生成思维导图功能快速生成思维导图,大纲笔记可以帮助我们快速记录,而思维导图可以帮助我们进行高效的复习和回顾!

     
    2374770-4ea2a3d629acb02b.PNG!thumbnail
     

     

    5.freemind

    一款开源的思维导图工具,可以下载免费使用,但是需要在java运行环境下运行,需要的安装freemind之前安装java运行环境。不过我想吐槽的是,虽然软件是完全免费的,但是软件画出来的思维导图是真的丑!

    展开全文
  • 人类常见的十大思维谬误

    千次阅读 2015-08-27 14:15:48
    人类的思维是个非常奇妙的东西。知觉(cognition),思考的过程和表现,让我们能快速处理大量的外界信息。例如,每天一睁开双眼,大脑就不断承受着外界刺激的冲击。你可以意识的专注想一件特定的事情,但是你的潜...
    人类的思维是个非常奇妙的东西。知觉(cognition),思考的过程和表现,让我们能快速处理大量的外界信息。例如,每天一睁开双眼,大脑就不断承受着外界刺激的冲击。你可以有意识的专注想一件特定的事情,但是你的潜意识却在处理着成千上万的想法。不幸的是,我们的知觉并不完美,时常做出一些错误的判断,心理学中把这种现象称为认知偏差(cognitivebiases)。认知偏差在每个人的身上都会出现,不论年龄、性别、教育、智力或者任何其他因素。它们中的一些广为人知,另一些则鲜为人知。这些现象在每个人的身上或许都发生过。为避免将来重犯错,下面就来做个简要的介绍!
      
      十、赌徒谬论(Gambler’sFallacy)
      
      赌徒谬论认为未来的可能性会因为过去的事情而改变,然而事实并非这样。确定的概率,就像抛掷一枚硬币结果是国徽,是不会变的,国徽朝上的概率永远是50%,和你在前十次抛出的是反面没有关系。认为概率会有变化是常见的偏见,尤其在赌博的时候。比方说玩轮盘赌,过去的四盘都在黑色一边停下,接下来这盘就会在红色的一边停下吗?显然错了!在红色处停留的概率还是47.37%。这听起来似乎很理所当然,但是就是这个偏见让许多赌徒输了大把的钱,天真的认为概率会改变。
      
      九、反应性(Reactivity)
      
      反应性是人们在发现自己被关注时呈现不同外在表现的趋势。上世纪20年代即1924年11月至1927年4月,哈佛大学心理学教授梅奥在霍桑工厂做了一项研究(即著名的霍桑实验),观察不同的灯光是否会对工人的产出造成影响。他们的发现令人难以置信,调节灯光会引起产量的飙升。不幸的是,研究结束后,产量又降到平常的水平。这是因为产量的改变并不是由于灯光的不同,而是因为工人们被关注着。这就阐述了反应性的一种形式,当个体察觉到自身被关注时就会有意识的改变自己的行为方式,让自己看起来更优秀。这种反应在研究中是个很严重的问题,必须在“双盲实验”中得到控制。(“盲”指的是接受研究的人员被隐瞒了实验的相关信息,从而避免影响实验结果)
      
      八、幻想性视错觉(Pareidolia)
      
      幻想性视错觉是指将模糊、随机的图像赋予实际意义。比如看到像动物的云朵、像中国地图的石头、像人脸的树干纹理,或是在磁带倒播时听出了别样的信息,这些都是幻想性视错觉的明显例子。幻想性视错觉的基本因素是外界的刺激是中性的,没有任何象征性意义,所有的额外含义都是感受者臆想出来的。
      
      有趣的例子:罗夏墨迹测验(译者:Rorschachinkblottest,就是让被试者通过一些对称的不规则墨迹建立起自己的想象世界,在无拘束的情景中,显露出其个性特征的一种个性测试)就是利用幻想性视错觉来接近人们的精神状态。参与测验的人被要求看一组模糊的图片,并要描述出他们所看到的内容。通过分析他们的回答可以发掘出一些潜在的想法。
      
      七、自验预言(Self-fulfillingProphecy)
      
      自验预言是指自我用行为来应验自认为会出现的结果。自验预言是让预言自身变成真实的一个预测。比如说:我认为我将在学校里表现非常糟糕,于是我就不那么努力去面对我的作业与学习,结果真的表现糟糕,不出我所料。还有一个常见的例子就是人际关系,我认为我和朋友的关系就要搞砸了,于是开始有了不同以往的作为,有意地脱身离开。正因为我的反差,我确确实实的把关系搞砸了。这正是巫师使用的一个强力工具,他们把一个想法植入你的脑海里,结果你就真的让它发生了,因为你认为它会发生。
      
      有趣的例子:经济衰退是一种自我暗示。因为国内生产总值(GDP)连续两季度下降才叫做经济衰退,也就是说至少要有六个月的时间你才会觉察出正处于衰退中。不幸的是,在GDP刚刚出现了一点下滑趋势的时候,媒体就开始大篇幅的报导,这些报道引起人们的恐慌,造成一一系列的连锁反应,最终结果是经济真的衰退了。
      
      (附注:感觉有点像是心理暗示。)
      
      六、晕轮效应(TheHaloEffect)
      
      晕轮效应又称“光环效应”,是指指人们对他人的认知判断首先根据个人的好恶得出的,然后再从这个判断推论出认知对象的其他品质的现象。这种思考偏差在雇员的表现评估中常有发生。比如说:我有一个员工Biff,过去三天中都迟到了,我注意到这个现象,并推断Biff这个家伙有点懒惰并且对他的工作不太关心。Biff迟到可能有很多的原因,可能他的车坏了,可能是他的保姆当天没来,可能是碰上大堵车,或是天气实在糟糕。问题是,正是由于这个Biff不能控制的消极因素,我就推断Biff是个坏员工。从上面这个例子可以看出,晕轮效应其实是一种“以偏盖全”的心理弊病。
      
      有趣的例子:体态吸引力模板(PhysicalAttractivenessStereotype)就是指人们认为有吸引力的个体拥有一些社会生活想要寻求的特质,比如幸福、成功、智慧。于是乎,当一个有吸引力的人被赋予了优先的待遇,比如好工作、好收入时,这种想法就成了一个自验预言。晕轮效应在爱情和偶像崇拜中最明显。
      
      五、羊群效应(HerdMentality)
      
      羊群效应是指人们趋向于采纳多数人的选择,跟随多数人的行动,可以感觉更加安稳,避免冲突。这种心态也称为暴徒心态,也就是它最常见的一种形式--压力均分。群集心态揭示了为什么时尚会如此流行。服饰、汽车、爱好、风格,所有这些都有一伙人认为这些事很潇洒,并且身体力行。
      
      有趣的例子:过去一些极不吸引人也没人会认为它会流行的一些事,现在却大行其道,因为群集心态。像跳伞裤、宠物石、鲻鱼、锥形胸罩、扎染、海猴还有80年代(顺便指出,就是上面那张图片里的年轻人)。
      
      (从众心理)
      
      四、对抗(reactance)
      
      对抗是指人们趋向于做出别人所要求的反面,为了抵抗一种内心察觉出的,要限制你的选择自由的尝试。这在叛逆的青少年中最为常见,任何出于担心自由和选择权受到威胁而抵制权威的尝试都可以称作对抗。事实上,个体没有必要做出特定的举动,即便有时“他们无法完成”这个事实在潜意识里催促着他们。
      
      有趣的例子:“抵抗心理”是人们试图通过抵抗来影响人们的一个尝试。试着让一些人(特别是小孩)去做你要求所做的反方向,这样他们就会出于抵触做出你真正要求的事情!
      
      三、双曲贴现(HyperbolicDiscounting)
      
      双曲贴现是指人们宁愿要金额较小的眼前酬劳也不要金额较大的日后报酬。有很多的研究是有关决策的,一个决策的过程会受到很多因素的影响。有趣的是,这个延迟时间的长短在选择时是个很大的因素。简单的说,绝大多数的人都愿意今天拿20美元,而不愿意在明年的今天收到100美元。正常情况应该是在当下选择更大的一笔钱,因为美元每天都在贬值。可以假设利率是9%,在这种利率条件下,一个理性的人会很淡定地选择现在的91.74美元,或者一年后的100美元。然而,有趣的是在现在就可以到手和等待明天收获之间,我们究竟愿意少拿多少?你是想现在得到50美元,还是一年后的今天获得100美元而现在只能拿40美元呢?你的底限是多少呢?
      
      二、承诺升级(EscalationofCommitment)
      
      承诺升级是指是一种在过去决策的基础上不断增加承诺的现象,尽管有证据表明,已经做出的决策是错误的。很明显,在这种情况下,明智的做法是立即寻求新的代替方案,尝试逆转这一切。但是,很多时候有些人总是强迫自己不仅要恪守最初的决定,还要继续在这个错误的决定上做更大的投资。比如说,你用了半生的积蓄做一门生意。6个月后,这桩生意明显已经很不成功了,理智的做法就是长痛不如短痛,放弃这桩生意。但是,这时由于已经损失了的积蓄,你决定放手一搏为你的项目投入更多的钱,期望这些富余的资金能扭转颓势。
      
      一、安慰剂效应(PlaceboEffect)
      
      又名伪药效应、假药效应、代设剂效应。是指病人虽然获得无效的治疗,但却“预料”或“相信”治疗有效,而让病患症状得到舒缓的现象。在医疗领域中最为常见。让患小疾的人服用糖片,在疗效报告中我们就可以观察到安慰剂效应。安慰剂到现在仍然是个科学谜题。有个理论化的说法指出安慰剂会引起“期望效应”(在充满不确定性的情况中,所期望的就是最有可能发生的),患者希望这些小“药片”能治愈他们的毛病,于是他们就痊愈了!但是,这还是无法解释为什么毫无药效的糖片就能缓解症状。
      
      有人认为这是一个值得注意的人类生理反应,但也有人认为这是医学实验设计所产生的错觉。这个现象无论是否真的存在,科学家至令仍未能完全理解。
      

      有趣的例子:“安慰剂”这个术语是在当结果让人满意的时候才使用的,当结局不尽如人意时,有个术语叫:反安慰剂(Nocebo)。


    展开全文
  • 职场中典型的学生思维有哪些

    万次阅读 2020-12-03 23:15:41
    在咨询工作中一个经典的案例就是,一个公司现在发展两种模式可以走,一种是模式A,好处123,一种是模式B,好处456. 让你怎么选。 如果学生思维的话,你会马上开始权衡A和B。而一个职场人才,会明确这是一个...
  • 常见的研究方法有哪些

    千次阅读 2019-10-04 10:46:51
    研究方法,哲学术语,是指在研究中发现新现象、新事物,或提出新理论、新观点...这是运用智慧进行科学思维的技巧,一般包括文献调查法、观察法、思辨法、行为研究法、历史研究法、概念分析法、比较研究法等。 ...
  • 企业项目管理常见的组织形式有哪些?”给大家讲讲项目管理的常见知识,便于帮助大家打开思维,发现更多有利于项目管理的方法。 一、企业项目管理的常见组织形式主要三种类型: 1、职能式 当今世界上最普遍的组织...
  • 每一种艺术形式它共同的规则和原理,契合这些原理才干达到根本的美学,对于从事艺术创作的人,只有在艺术规则把握熟练的时分,才干打破规则,随心所欲! 对角式构图:把主体安排在对角线上,达到突出主体的效果...
  • 常见的数字高程模型结构有哪些

    千次阅读 2020-04-06 16:02:50
    常见的数字高程模型DEM结构有哪些? 数字高程模型结构包括:规则格网DEM数据结构、不规则三角网DEM数据结构、格网与不规则三角网结构混合结构。 规则格网DEM数据结构 (1)简单矩阵结构:数据在水平和垂直方向的...
  • Redis 面试题 1、什么是 Redis?. 2、Redis 的数据类型?...3、使用 Redis 有哪些好处? 4、Redis 相比 Memcached 有哪些优势? 5、Memcache 与 Redis 的区别都有哪些? 6、Redis 是单进程单线程...
  • 如何理解这6种常见设计模式

    千次阅读 2020-09-10 14:06:17
    有哪些常见的设计模式?如何合理运用?本文分享作者对工厂模式、单例模式、装饰模式、策略模式、代理模式和观察者模式的理解,介绍每种模式模式结构、优缺点、适用场景、注意实现及代码实现。一 前言最近在改造...
  • 从 JDK 源码,到主流开源框架,设计模式的应用俯拾皆是,“设计模式为我所用”或多或少已经成为程序员编码思维的本能了。 本文就来理一理开发中常见的设计模式: Spring 框架中的单例模式; ...
  • 思维

    2016-05-10 12:00:54
    思维对事物的间接反映,是指它通过其他媒介作用认识客观事物,及借助于已的知识和经验,已知的条件推测未知的事物。思维的概括性表现在它对一类事物非本质属性的摒弃和对其共同本质特征的反映 。 随着研究的深入...
  • 在职场或者生活中,我们经常会遇到这样的情况:在面对和解决一些问题的时候,有些人忙作一团,找不到解决问题的路径。而有些人却可以通过清晰的分析框架一步步解决问题。这样的思维差异,会带来完全不...
  • 转入OO思维模式

    2003-09-11 11:10:00
    从以前ASP或者VB转来的程序员,肯定对于OO思维不太熟悉,做起项目来OO思想也是雷声大雨点小,心里上没有真正的适应过程。现在我就借花献佛,希望能对你有所帮助。 采用OO软体开发方法的过程中﹐许多人自然而然偏重...
  • 思维导图

    千次阅读 2019-05-17 16:00:24
    思维导图又叫心智导图,是表达发散性思维的有效图形思维工具 ,它简单却又很有效,是一种实用性的思维工具。 思维导图充分运用左右脑的机能,利用记忆、阅读、思维的规律,协助人们在科学与艺术、逻辑与想象之间...
  • 二维码的营销模式有哪些

    千次阅读 2017-06-15 13:43:14
    互联网的发展,智能手机的普及,出去吃个饭都是用二维码扫一扫。二维码加强了商家和消费者之间的互动和信息的传播。二维码营销也是商家的主要营销手段。那么二维码营销模式有哪些呢?
  • 绝对值不等式的常见形式及解法

    万次阅读 2017-12-19 17:39:00
    常见形式有以下几种。  1. 形如不等式: 利用绝对值的定义得不等式的解集为: 。在数轴上的表示如图1。  2. 形如不等式: 它的解集为:。在数轴上的表示如图2。  3. 形如不等式 它的解法是:先...
  • Go语言四十二章经》,纯粹是因为开发过程中碰到过的一些问题,踩到过的一些坑,感觉在Go语言学习使用过程中,必要深刻理解这门语言的核心思维,清晰掌握语言的细节规范以及反复琢磨标准包代码设计模式,于是才了...
  • SEM 数据分析思维 相信很多人在做...用今天就一起来捋一捋在竞价推广中常见思维模式 数据分析是什么? 大家经常说:我通过数据分析找到了问题, 但是却不知道怎么解决?咱们就通过良好的 思维模式来解决这个问题 这个问题
  • 几种常见密码形式

    万次阅读 2012-09-25 20:59:05
    被滴哒的形式所困,我们实际出密码的时候,可能转换为很多种形式,例如用0和1表示,迷惑你向二进制方向考虑,等等。摩尔斯 是我们生活中非常常见的一种密码形式,例如电报就用的是这个哦。下次再看战争片,里面...
  • 我想测试人员学习一些系统思维助于改进解决问题。 什么是系统?我们可以认为世上万事万物的本质都是系统,系统是由两个或两个以上的元素结合而成的有机整体,并且系统的整体并不等于其局部的相加。即我们不仅...
  • 常见几种编码模式

    千次阅读 2018-03-14 21:24:53
    转载自:阮一峰的网络日志:...每一个二进制位(bit)0和1两种状态,因此八个二进制位就可以组合出256种状态,这被称为一个字节(byte)。也就是说,一个字节一共可以用来表示256种不同的状态,每...
  • 3、使用 Redis 有哪些好处? 4、Redis 相比 Memcached 有哪些优势? 5、Memcache 与 Redis 的区别都有哪些? 6、Redis 是单进程单线程的? 7、一个字符串类型的值能存储最大容量是多少? 8、Redis 的持久化机制...
  • 设计模式的意义与23种常见模式介绍

    千次阅读 2016-12-03 16:08:06
    面向对象分析(OOA)是更加贴近人类思维模式的编程语言,以Java C++ 为代表的面向对象语言(OOP)一直是现代软件开发的主流语言,由于相关历史原因(主要是获得开源社区的支持),由此延伸出的相关技术与工具也蓬勃...
  • 木偶演示 此回购包含有关伪造者的概念,思想和实验的各种演示,这些演示是我的演讲的一部分。 您还可以找到谈话中显示的链接的参考。 :movie_camera: 演讲视频: : 木偶可以做到这一点!... 木偶可以做到这一点!...
  • 超越守则 关于开发人员可以面对的常见消极思想模式的演示,并恳请自己和彼此坦诚相待。 在年5月25日在上进行了演示。演示是使用创建的。
  • imindmap常见问题解答

    2017-08-02 14:10:41
    Hello,各位小伙伴们,看到经常人问关于imindmap思维导图的问题,所以我就把一些常见的问题汇总下,大家可以看看喽~~   1.imindmap的核心要素是什么? 答:关键词,颜色,中心主题,图标,线条(曲线),发散结构,...
  • 有感于最近的技术分享,觉得思维训练越来越重要了,思维训练到位后,就可以用最高效的方式在最短的时间内取得最大的成果(符合自我高效获取高性价比价值的价值观定位),所以开启本系列。就以超哥分享的《系统思维》...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 73,248
精华内容 29,299
关键字:

常见思维模式有哪些