精华内容
下载资源
问答
  • A Ability: 应用重要组成部分,是应用所具备能力抽象。Ability分为两种类型,Feature Ability和Particle Ability。AbilityForm:表单,是...一Feature Ability可以包含一组业务关系密切可视化界面,每一...

    华为鸿蒙系统HarmonyOS学习之六:鸿蒙OpenHarmony常用术语说明

     

    A

    Ability: 应用的重要组成部分,是应用所具备能力的抽象。Ability分为两种类型,Feature Ability和Particle Ability。
    AbilityForm:表单,是Feature Ability的一种界面展示形式,用于嵌入到其他应用中并作为其界面的一部分显示,并支持基础的交互功能。
    AbilitySlice:切片,是单个可视化界面及其交互逻辑的总和,是Feature Ability的组成单元。一个Feature Ability可以包含一组业务关系密切的可视化界面,每一个可视化界面对应一个AbilitySlice。
    ANS: Ability Notification Service,是HarmonyOS中负责处理通知的订阅、发布和更新等操作的系统服务。

    C

    CES: Common Event Service,是HarmonyOS中负责处理公共事件的订阅、发布和退订的系统服务。

    D

    DV: Device Virtualization,设备虚拟化,通过虚拟化技术可以实现不同设备的能力和资源融合。

    F

    FA: Feature Ability,元程序,代表有界面的Ability,用于与用户进行交互。

    H

     HAP:HarmonyOS Ability Package,一个HAP文件包含应用的所有内容,由代码、资源、三方库及应用配置文件组成,其文件后缀名为.hap。
    HDF:HarmonyOS Driver Foundation,HarmonyOS驱动框架,提供统一外设访问能力和驱动开发、管理框架。

    I

    IDN: Intelligent Distributed Networking,是HarmonyOS特有的分布式组网能力单元。开发者可以通过IDN获取分布式网络内的设备列表以及注册分布式网络内设备在网状态变化信息。

    M

    MSDP: Mobile Sensing Development Platform,移动感知平台。MSDP子系统提供两类核心能力:分布式融合感知和分布式设备虚拟化两大部分。

    • 分布式融合感知:借助HarmonyOS分布式能力,将各设备感知源进行汇总融合,对用户的空间状态、移动状态、手势、健康状态等进行精准感知,构建全场景泛在基础感知能力,支撑智慧生活新体验。
    • 分布式器件虚拟化:借助HarmonyOS分布式能力,构筑器件虚拟化平台,将外部设备的各类器件(如Camera、显示器、SPK/MIC等)虚拟化为本地设备的器件延伸使用。同时具备将自身器件共享给其他设备使用的能力。

    P

    PA: Particle Ability,元服务,代表无界面的Ability,主要为Feature Ability提供支持,例如作为后台服务提供计算能力,或作为数据仓库提供数据访问能力。

    S

    SA: System Ability,即系统能力,是由OS提供的基础软件服务和硬件服务。
    Super virtual device,超级虚拟终端: 亦称超级终端,通过分布式技术将多个终端的能力进行整合,存放在一个虚拟的硬件资源池里,根据业务需要统一管理和调度终端能力,来对外提供服务。

    展开全文
  • 装饰模式——又名包装模式,以对客户端透明方式扩展对象的功能,是继承关系的替代方案 代理模式——开闭原则直接支持 桥接模式 组合模式 外观模式 一、代理与代理模式 1.1、代理 所谓静态代理就是自己...
    • 适配器模式——把一个类的接口变成客户端所期待的另一种接口
    • 装饰模式——又名包装模式,以对客户端透明的方式扩展对象的功能,是继承关系的替代方案
    • 代理模式——开闭原则的直接支持
    • 桥接模式
    • 组合模式
    • 外观模式

    一、代理与代理模式

    1.1、代理

    所谓静态代理就是自己手写(或者用工具生成)代理类,程序运行前就已经存在的编译好的代理类;如果需要很多代理,每个都这样去创建浪费时间也可能有很多重复代码,采用动态代理可以在程序运行期间根据需要动态的创建代理类及其实例来完成具体的功能。总的来说,根据代理的创建时机和创建方式不同,可以将代理分为静态代理和动态代理。

    代理的作用:

    • 用于拦截对真实业务对象的访问(比如不需要直接买演唱会门票,把这个任务交给黄牛);
    • 代理对象应具有和目标对象相同的方法(实现相同的接口或者继承于同一个类);
    • 代理对象应该是目标对象的增强(否则就没必要代理了)。

    事实上,真正的业务功能还是由目标类来实现,代理类只是用于扩展、增强目标类的行为。例如,在项目开发中我们没有加入缓冲、日志这些功能而后期需要加入,我们就可以使用代理来实现,而没有必要去直接修改已经封装好的目标类。

    1.2、代理模式

    在Spring AOP 与MyBatis缓存机制等都使用了代理模式。代理模式使得客户端在使用目标对象的时候 间接通过操作代理对象进行,代理对象是对目标对象的增强。本质是对 开闭原则(软件实体应该通过扩展来实现变化,而不是通过修改已有的代码来实现变化 的直接支持。

    代理模式包含如下角色:

    • 客户端:客户端面向接口编程,使用代理角色完成某项功能
    • 抽象主题:一般实现为接口,是对被代理对象行为的抽象
    • 被代理角色(目标类):直接实现上述接口,是抽象主题的具体实现
    • 代理角色(代理类):实现上述接口,是对被代理对象角色的增强

    代理模式应用场景:

    SpringAOP、事务原理、日志打印、权限控制、远程调用

    二、静态代理

    2.1、静态代理的实现模式

    首先创建一个接口——>创建具体实现类实现该接口——>创建一个代理类也实现该接口。

    不同之处在于具体实现类的方法要把业务逻辑功能实现起来,而代理类的方法只需要调用具体类中对应方法即可,这样在需要使用过接口中某个方法功能时直接调用代理类的方法即可,将具体的实现类隐藏在底层

    2.2、代码实例

    电影的例子。电影是电影公司委托给影院进行播放的,但是影院可以在播放电影的时候,产生一些自己的经济收益,比如卖爆米花、可乐等,然后在影片开始结束时播放一些广告(最大缺点:静态代理需要生成代理对象,对象多很麻烦)

    //1.抽象主题(接口)
    //先得有一个接口,通用的接口是代理模式实现的基础(该接口 代表电影这个主题)
    public interface Movie {
        void play();
    }
    //2.被代理角色(目标类)与代理角色(代理类)
    //要有一个真正的实现这个 Movie 接口的类和一个只是实现接口的代理类
    public class RealMovie implements Movie {
        @Override
        public void play() {
            System.out.println("您正在观看电影 《肖申克的救赎》");
        }
    }
    
    /**
    这个表示真正的影片。它实现了 Movie 接口。Cinema 就是代理对象,它有一个 play() 方法。不过调用 play() 方法时,它进行了一些相关利益的处理,那就是广告;也就是说,Cinema(代理类) 与 RealMovie(目标类) 都可以播放电影,但是除此之外,Cinema(代理类)还对“播放电影”这个行为进行进一步增强,即增加了额外的处理,同时不影响RealMovie(目标类)的实现。
    **/
    public class Cinema implements Movie {
        RealMovie movie;
        public Cinema(RealMovie movie) {
            super();
            this.movie = movie;
        }
        @Override
        public void play() {
            guanggao(true);    // 代理类的增强处理
            movie.play();     // 代理类把具体业务委托给目标类,并没有直接实现
            guanggao(false);    // 代理类的增强处理
        }
        public void guanggao(boolean isStart){
            if ( isStart ) {
                System.out.println("电影马上开始了,爆米花、可乐、口香糖9.8折,快来买啊!");
            } else {
                System.out.println("电影马上结束了,爆米花、可乐、口香糖9.8折,买回家吃吧!");
            }
        }
    }
    //3.客户端
    /**
    如前所述,代理模式可以在不修改被代理对象的基础上(符合开闭原则),通过扩展代理类,进行一些功能的附加与增强。由于Cinema(代理类)是事先编写、编译好的,而不是在程序运行过程中动态生成的,因此这个例子是一个静态代理的应用
    **/
    public class ProxyTest {
        public static void main(String[] args) {
            RealMovie realmovie = new RealMovie();
            Movie movie = new Cinema(realmovie);
            movie.play();
        }
    }/** Output
            电影马上开始了,爆米花、可乐、口香糖9.8折,快来买啊!
            您正在观看电影 《肖申克的救赎》
            电影马上结束了,爆米花、可乐、口香糖9.8折,买回家吃吧!
     **/

    三、动态代理

    3.1、什么是动态代理

    动态代理可以在程序运行期间根据需要 动态地创建代理类及其实例 来完成具体的功能费(不需要代理对象)

    3.2代码示例(JDK动态代理)

    (1)抽象主题(接口)

    首先得有一个接口,通用的接口是代理模式实现的基础

    public interface Subject {
        public void doSomething();
    }

    (2)被代理角色(目标类)

    要有一个真正的实现这个 Subject 接口的类,以便代理

    public class RealSubject implements Subject {
        public void doSomething() {
            System.out.println("call doSomething()");
        }
    }

    (3)代理角色(代理类)与客户端

    在动态代理中,代理类及其实例都是程序自动生成的,因此不需要手动去创建代理类。

    在JDK动态代理中,InvocationHandler(Interface)接口和Proxy(Class)类是实现动态代理必须用到的,Proxy通过使用InvocationHandler对象生成具体的代理代理对象,下面是InvocationHandler接口的实现:

    /**
     * Title: InvocationHandler 的实现 
     * Description: 每个代理的实例都有一个与之关联的 InvocationHandler
     * 实现类,如果代理的方法被调用,那么代理便会通知和转发给内部的 InvocationHandler 实现类,由它调用invoke()去处理。
     */
    public class ProxyHandler implements InvocationHandler {
        private Object proxied;   // 被代理对象
        public ProxyHandler(Object proxied) {
            this.proxied = proxied;
        }
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            // 在转调具体目标对象之前,可以执行一些功能处理
            System.out.println("前置增强处理: yoyoyo...");
            // 转调具体目标对象的方法(三要素:实例对象 + 实例方法 + 实例方法的参数)
            Object obj = method.invoke(proxied, args);
            // 在转调具体目标对象之后,可以执行一些功能处理
            System.out.println("后置增强处理:hahaha...");
            return obj;
        }
    }

    在实现了InvocationHandler接口后,我们就可以创建代理对象了。在Java的JDK动态代理机制中,我们使用Proxy类的静态方法newProxyInstance创建代理对象,如下:

    public class Test {
        public static void main(String args[]) {
            // 真实对象real
            Subject real = new RealSubject();
            // 生成real的代理对象
            Subject proxySubject = (Subject) Proxy.newProxyInstance(
                    Subject.class.getClassLoader(), new Class[] { Subject.class },
                    new ProxyHandler(real));
            proxySubject.doSomething();
            System.out.println("代理对象的类型 : " + proxySubject.getClass().getName());
            System.out.println("代理对象所在类的父类型 : " + proxySubject.getClass().getGenericSuperclass());
        }
    }/** Output
            前置增强处理: yoyoyo...
            call doSomething()
            后置增强处理:hahaha...
            代理对象的类型 : com.sun.proxy.$Proxy0
            代理对象所在类的父类型 : class java.lang.reflect.Proxy
     **/

    代理对象proxySubject所对应的类继承自java.lang.reflect.Proxy类,这也正是JDK动态代理机制无法实现对class的动态代理的原因:Java只允许单继承。

    (4)JDK中InvocationHandler接口与Proxy类

    InvocationHandler接口:

    InvocationHandler 是一个接口,每个代理的实例都有一个与之关联的 InvocationHandler 实现类,如果代理的方法被调用,那么代理便会通知和转发给内部的 InvocationHandler 实现类,由它决定处理。的invoke() 方法决定了怎么样处理代理传递过来的方法调用

    public interface InvocationHandler {
        public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable;
    }

    Proxy类:

    DK通过 Proxy 的静态方法 newProxyInstance 动态地创建代理,Proxy 动态产生的代理对象调用目标方法时,代理对象会调用 InvocationHandler 实现类,所以 InvocationHandler 是实际执行者。

        /**  
         * @param loader 类加载器
         * @param interfaces 目标类所实现的接口
         * @param h  InvocationHandler 实例
         */
        public static Object newProxyInstance(ClassLoader loader,
                Class<?>[] interfaces,
                InvocationHandler h)

    3.3、CGLIB动态代理

    (1)CGLIB动态代理原理

    利用asm开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理

    (2)什么是CGLIB

    使用cglib实现动态代理,并且不要求委托类必须实现接口,底层采用asm字节码生成框架 生成代理类的字节码

    public class CglibProxy implements MethodInterceptor {
    	private Object targetObject;
    	// 这里的目标类型为Object,则可以接受任意一种参数作为被代理类,实现了动态代理
    	public Object getInstance(Object target) {
    		// 设置需要创建子类的类
    		this.targetObject = target;
    		Enhancer enhancer = new Enhancer();
    		enhancer.setSuperclass(target.getClass());
    		enhancer.setCallback(this);
    		return enhancer.create();
    	}
    
    	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
    		System.out.println("开启事物");
    		Object result = proxy.invoke(targetObject, args);
    		System.out.println("关闭事物");
    		// 返回代理对象
    		return result;
    	}
    	public static void main(String[] args) {
    		CglibProxy cglibProxy = new CglibProxy();
    		UserDao userDao = (UserDao) cglibProxy.getInstance(new UserDao());
    		userDao.save();
    	}
    }
    

    3.4、CGLIB动态代理与JDK动态代理的区别

    (1)jdk动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前 调用InvokeHandler来处理;

    而cglib动态代理是利用asm开源包,对代理类的class文件加载进来,通过修改其字节码生成子类来处理。

    (2)jdk动态代理只能对 实现了接口的类 生成代理,而不能针对类;cglib是针对 实现代理,主要是对指定的类生成一个子类,覆盖其中的方法

    3.5、在Spring中什么时候用CGLIB或者JDK动态代理

    如果目标对象实现了接口,默认采用JDK动态代理实现AOP;如果没实现接口,必须使用CGLIB库,Spring会自动切换。

     

    四、Spring AOP 与动态代理

    AOP专门用于处理系统中分布于各个模块中交叉关注点问题,使用动态代理机制实现的。Spring AOP 默认使用动态代理来创建AOP代理,具体通过以下几步完成:

    • Spring IOC容器创建Bean(目标类对象);
    • Bean创建完后,根据具体的切面逻辑及Bean本身使用Java动态代理技术生成 代理对象;
    • 应用程序使用上述生成的代理对象替代原对象来完成业务逻辑,从而达到增强处理的目的。
    展开全文
  • 软件大设计原则(代码充实ing) ...5、接口隔离原则:为用户提供小接口,使用多专门接口比使用单一多接口好 6、迪米特原则:尽量与非朋友少发生关系 #设计模式分为三大类: 创建型模式,共五...

    软件六大设计原则(代码充实ing)

    1、开--闭原则:对拓展开放,对修改关闭

    2、里氏代换原则:任何积累出现的地方,子类一定出现

    3、单一职责原则:功能职责单一, 只能拥抱一种变化

    4、依赖倒置原则:依赖于抽象,不依赖于实现

    5、接口隔离原则:为用户提供小的接口,使用多个专门的接口比使用单一的多接口好

    6、迪米特原则:尽量与非朋友少发生关系

    #设计模式分为三大类:

    创建型模式,共五种: 工厂方法模式、抽象工厂模式、单例模式、构建者模式、原型模式。

    结构型模式,共七种: 适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

    行为型模式,共十一种: 策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

    其实还有两类:并发型模式和线程池模式。

    关于各种设计模式的详细介绍


    #设计模式的六大原则:

    总原则-开闭原则

    对扩展开放,对修改封闭。 在程序需要进行拓展的时候,不能去修改原有的代码,而是要扩展原有代码,实现一个热插拔的效果。所以一句话概括就是:为了使程序的扩展性好,易于维护和升级。 想要达到这样的效果,我们需要使用接口和抽象类等。

    1、单一职责原则 不要存在多于一个导致类变更的原因,也就是说每个类应该实现单一的职责,否则就应该把类拆分。

    2、里氏替换原则(Liskov Substitution Principle) 任何基类可以出现的地方,子类一定可以出现。里氏替换原则是继承复用的基石,只有当衍生类可以替换基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。 里氏代换原则是对“开-闭”原则的补充。实现“开闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。里氏替换原则中,子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构,通过这个规范的接口与外界交互,子类不应该随便破坏它。

    3、依赖倒转原则(Dependence Inversion Principle) 面向接口编程,依赖于抽象而不依赖于具体。写代码时用到具体类时,不与具体类交互,而与具体类的上层接口交互。

    4、接口隔离原则(Interface Segregation Principle) 每个接口中不存在子类用不到却必须实现的方法,如果不然,就要将接口拆分。使用多个隔离的接口,比使用单个接口(多个接口方法集合到一个的接口)要好。

    5、迪米特法则(最少知道原则)(Demeter Principle) 一个类对自己依赖的类知道的越少越好。无论被依赖的类多么复杂,都应该将逻辑封装在方法的内部,通过public方法提供给外部。这样当被依赖的类变化时,才能最小的影响该类。 最少知道原则的另一个表达方式是:只与直接的朋友通信。类之间只要有耦合关系,就叫朋友关系。耦合分为依赖、关联、聚合、组合等。我们称出现为成员变量、方法参数、方法返回值中的类为直接朋友。局部变量、临时变量则不是直接的朋友。我们要求陌生的类不要作为局部变量出现在类中。

    6、合成复用原则(Composite Reuse Principle) 尽量首先使用合成/聚合的方式,而不是使用继承。

    展开全文
  • 常用设计模式

    2020-09-04 23:05:53
    设计模式一共有23种,今天只介绍几种常见常用的设计模式。 在此之前,首先介绍下设计模式的六大设计原则。 1.单一职责:一类他的职责要单一。这职责的划分视情况而定 2开闭原则:软件实体应该对扩展开发,对修改...

    设计模式
    1.1设计模式简介
    设计模式:每一个模式都描述了在我们的环境中不断出现的问题的解决方案的核心。通过这种方式,可以无数次地使用那些已有的解决方案,无需做重复相同的工作。
    模式的组成:特点的环境+产生的一个问题+解决方案
    模式的核心思想:进行设计的复用

    1.2设计模式与体系结构模式:
    设计模式:描述了定制化的相互通信的对象与类,已解决特定环境中的通用设计问题。
    体系结构模式:是对系统的高层设计,是从一个较高的层次来考虑组成系统的构件,构件之间的连接关系,以及系统需要满足的约束,用以实现体系结构级的设计复用。通常被称为架构模式,体系结构风格。
    二者关系:多个设计模式组件相组合形成了体系结构模式
    1.3设计原则
    1单一职责原则:类的职责要单一,高内聚,低耦合
    2开闭原则:对实体拓展开放,对修改关闭
    3里氏代换原则:在软件系统中,可以接受基类对象的地方,必然能使用子类对象
    4依赖倒转原则:针对抽象层编程而不是具体的类
    5合成复用原则:系统中尽量多的使用组合和聚合关联关系,尽量少使用甚至不使用继承关系。
    6接口隔离原则:使用多个接口而不是一个统一的接口
    7迪米特法则:两个类之间不应当发生直接的相互作用,相互通信,而是通过引入一个第三者发生间接交互。

    2.1 单例模式
    确保一个类仅有一个唯一的实例,并且提供一个全局的访问接口。
    应用场景:全局有且只有一个实例产生,比如,任务管理器,无论怎么打开有且只有一个。
    解决的问题:只有一个唯一的实例(独生子女)

    解决方案:
    首先将构造函数声明为私有类型,屏蔽通过直接实例化的形式来访问
    其次控制全局只有一个实例的类------Static
    第三,提供一个可以获得实例的方法,用于返回类的实例,并保证得到的是同一个对象

    3.1观察者模式:发布-订阅模式

    两个角色:观察者和被观察对象。当被观察者发生改变时,观察者就会收到来自被观察者的消息变化,做出响应。
    比较直观的一种形式是使用“注册----通知----撤销注册”

    实现步骤:观察者将自己注册到被观察者对象的容器中,被观察对象发生了某种变化,从容器中得到所有的注册对象,逐一通知变化,撤销的时候,观察者通知被观察者,将观察者从容器中清除
    减少观察者和被观察者对象之间的耦合

    观察者实现类

    简单使用加测试结果

    4.1适配器模式
    使用环境:同一种东西,在不同的环境展现方式不同
    例如:游戏中的坐骑-----五彩神鹿,在第一世界它的行走方式是喷跑,在第二世界,行走方式为飞

    问题:想使用一个已经存在的类,但他的接口不符合需求
    适配器模式:将一个类的接口转换为客户希望的另外一个接口,是的原本接口不兼容而不能一起工作哦的那类类可以一起工作。
    适配器模式有四个角色:
    目标(target):定义客户端使用的与特定领域相关的接口
    被适配者(adaptee)定义了一个已经存在的接口,这个接口需要匹配
    适配者(adapter):对Adaptee的接口与target的接口进行适配
    客户端(Client):与符合target接口的对象协同。

    4.2适配器模式分类
    4.2.1类的适配器模式(采用继承实现)
    实现步骤(确定目标接口,确定被适配者,创建适配器,继承自被试配者,实现目标接口)
    4.2.2对象适配器(采用对象组合方式实现)
    实现步骤(确定目标接口,确定被试配者,创建适配器:拥有被试配者的对象,实现目标接口)
    1.被确定目标接口

    2.确定被试配者:

    3.创建适配器(类适配器)将飞的方式给被适配者

    /类适配器/
    public class ClassAdapter extends Deer implements ITarget {
    @Override
    public void fly() {
    System.out.println(“进入第二世界,我可以带你飞哦”);
    }
    }

    3.2对象适配器
    public class ObjectAdapter implements ITarget {
    private Deer deer;
    public ObjectAdapter(Deer d){
    this.deer=d;
    }
    @Override
    public void run() {
    deer.run();
    }
    @Override
    public void fly() {
    System.out.println(“起飞”);
    }
    }
    使用:

    二者比较:
    类适配器采用多继承的实现方式,带来了不良的高耦合
    对象适配器采用对象组合的方式,更符合松耦合精神
    类适配器无法面对多个被适配对象

    5.1策略模式
    环境:游戏中,游戏人物可以有多种组合的武器,比如AK47+98K
    或者m416+m24,在团队竞技可以随意切换组合,或者在打人的时候可以随意在两种武器之间进行切换。
    策略模式:让算法独立于使用它的客户而独立变化。并将每一个算法封装起来,使他们可以相互替换。

    三个角色:
    抽象策略类:定义所有支持的算法的公告接口
    具体策略类:以抽象策略类接口实现某种具体算法
    环境类:维护一个对抽象策略类对象的引用。可定义一个接口来让抽象策略类访问他的数据。

    抽象策略类:
    //定义了抽象策略类,战斗方式
    public interface IStrategy {
    public void fighting();
    }

    具体策略类:
    public class Ak47 implements IStrategy {
    @Override
    public void fighting() {
    System.out.println(“使用AK47,dadada!”);
    }
    }

    public class M24 implements IStrategy {
    @Override
    public void fighting() {
    System.out.println(“使用m24,dewu~”);
    }
    }

    public class M416 implements IStrategy {
    @Override
    public void fighting() {
    System.out.println(“使用M416,dedede!”);
    }
    }

    3.环境类:
    public class Context {
    private IStrategy iStrategy;//里氏代换原则
    public Context(IStrategy strategy){
    this.iStrategy=strategy;
    }
    public void fighting(){
    this.iStrategy.fighting();
    }
    }

    使用:
    //策略模式
    Context context;
    context=new Context(new Ak47());
    context.fighting();
    context=new Context(new M24());
    context.fighting();
    context=new Context(new M416());
    context.fighting();
    输出结果:
    I/System.out: 使用AK47,dadada!
    I/System.out: 使用m24,dewu~
    使用M416,dedede!
    思考:适配器模式和策略模式的区别:
    适配器模式是在于同一东西在不同环境有不同的表现,类似于,武器的升级
    策略模式是同一种环境同一种行为不同的表现形式,比如,射击时武器的更换
    比如人选择旅游出行方式

    策略模式优点:提供了对开闭原则的完美支持,用户可以在不修改原有系统的基础上选择算法或行为,也可以灵活的增加新的算法或行为。
    策略模式提供了管理相关的算法族的办法
    策略模式提供了可以替换继承关系的办法
    使用策略模式可以避免使用多重条件转移语句
    缺点:客户端必须知道所有的策略类,并自行决定使用哪一个策略类,策略模式将造成产生很多策略类
    策略模式适用环境
    如果在一个系统里面有许多类,它们之间的区别仅
    在于它们的行为,那么使用策略模式可以动态地让
    一个对象在许多行为中选择一种行为。
    一个系统需要动态地在几种算法中选择一种。
    不希望客户端知道复杂的、与算法相关的数据结构
    ,在具体策略类中封装算法和相关的数据结构,提
    高算法的保密性与安全性。

    6.1组合模式
    环境:用户想表示对象的部分与整体的层次结构,并希望忽略组合对象与单个对象的不同,统一地使用组合结构中的所有对象。描述了如何将容器对象和叶子对象进行递归组合,使得用户在使用时无需对他们进行区分,可以一致的对待容器对象和叶子对象。解决树形结构的问题。
    组合模式三个角色:
    抽象组件类:组合中的对象声明接口,实现所有类共有接口的行为。声明用于访问和管理抽象组件类的子部件的接口。
    叶子节点:叶节点对象,叶节点没有子节点。由于叶子节点不能添加分支和树叶,所以叶节点的add和remove没有实际意义。
    组件集合类:实现抽象组件类的相关操作,比如add和remove操作。其中包含抽象组件类的容器,用来存储叶子节点集合,有叶节点行为,用来存储叶节点集合

    组合模式实现步骤:

    定义抽象组件接口
    实现叶子节点类,实现抽象组件类的接口
    实现组件集合类,实现抽象组件类的接口
    定义环境类,将叶子节点和组件集合加入根组件集合
    7.1 装饰模式
    环境:汽车4s店汽车销售店,用户可以挑选汽车的型号奥迪A1,A4,A6。可装饰的组件倒车雷达,真皮座椅,gps定位。用户可以挑选汽车的型号,加任意的组件。

    不必改变原类文件和使用继承的情况下,动态的扩展一个对象的功能,应用程序的可维护性,可扩展性差。

    装饰模式中的角色:
    油漆工:用来刷油漆,给被装饰着进行装饰的
    被修饰者:实现装饰模式有很多形式,最常见的一种就是 “实现被装饰者类----定义被装饰者对象----使用被装饰者对象产生装饰者对象”

    装饰模式的实现:
    首先定义被装饰者类
    通过被装饰者对象产生装饰者对象

    解决的问题:如何动态的给一个对象添加功能。
    解决方案是利用子对象,委派

    8.1状态模式
    环境:实现一个旅馆的住宿管理系统,房间有三种状态:空闲,预定,已住
    状态模式:允许对象在其内部状态改变的时候改变它的行为。
    角色:
    环境类:客户使用他的对象类。维护一个抽象状态子类的实例,这个实例定义当前状态。
    抽象状态类:定义一个接口来封装与环境类的一个特定状态相关的行为
    具体状态类:每一个子类实现与环境类的一个状态相关的行为

    实现步骤:定义状态类接口,实现当前系统的真实状态实现此接口
    定义环境类,具有状态的类,包含状态类接口的对象
    当环境类执行某个接口的方法时,去调用真实状态类的实现方法
    当环境类修改状态时,修改环境类的真实状态对象

    展开全文
  • 企业管控模式常见种,其中最常用的是三种:客户导向的组织结构模式,前后端型组织结构模式以及产品导向的组织结构模式,同时还认为,不同的组织结构模式适应企业在不同的发展阶段来使用,不可从以一而终,组织结构...
  • C语言常用算法

    2012-03-28 10:48:37
    第一部分 基础篇 001 第一C程序 002 运行多源文件 003 求整数之积 ...218 功能强大文本编辑器 219 图书管理系统 220 进销存管理系统 //========= End of the file. 文件内容结束 ===============\\
  • MYSQL常用命令大全

    2011-05-30 13:31:24
    MySql的用户管理是通过 User表来实现的,添加新用户常用的方法有两,一是在User表插入相应的数据行,同时设置相应的权限;二是通过GRANT命令创建具有某种权限的用户。其中GRANT的常用用法如下: grant all on mydb...
  • alias(别名)在 shell 中是非常常用的,它主要用于给命令起别名,简化输入。但主要用于交互场景,在脚本中基本用不到。eval 是一非常强大的命令,它的功能是将字符串解析成代码再执行,但也会额外增加很多复杂性...
  • 默认登录工号:admin ...   凡诺客户关系管理系统CRM更新说明: 2013年12月30日 一、客户恢复到和收费版相同项目字段 ...二、日志功能 ...三、跟进提供修改功能 ...、多功能编辑器,可以上传图片附件等。
  • 北风客户关系管理源码 CRM

    千次下载 热门讨论 2013-01-16 14:16:11
    项目所涉及的知识点包括SSH三大框架,同时也介绍了其他常用的框架,如Jquery、Jfreechart等,在介绍了新技术点的同时重点让大家了解了CRM的业务知识,TBC(技术+业务+沟通)是优秀程序员必不可少三要素。...
  • 系分 | 第周作业

    2019-05-25 02:13:10
    简答题 用例的概念 用例是一系列相关的成功和失败场景的集合,这些场景描述了一参与者使用一系统来支持一目标。用例是功能或行为需求,指示系统将做什么。就FURPS+需求类型而言,它们强调...是最常用的,直...
  • 简答题 用例的概念 用例是一系列相关的成功和失败场景的集合,这些场景描述了一参与者使用一系统来支持一目标。用例是功能或行为需求,指示系统将做什么。就FURPS+需求类型而言,它们强调...是最常用的,直...
  • 使用LitePal操作数据库使用LitePal操作数据库 ...LitePal是一款开源的Android数据库框架,它采用对象关系映射(ORM)的模式,并将我们平时开发的最常用的一些数据库功能进行了封装.GitHub:Click me 他在re
  • 用1、2、2、3、4、5这六个数字,用java或你熟悉语言,打印出所有不同排列,如:512234、412345等,要求:“4”不能再第三位,“3”与“5”不能相连。并将这些数据按从小到大输出。 我答案 我不好 没...
  • “确认”: 该键完成对其他功能确认,防止误按键,在键盘中除“复位”键外,其他功能键都必须加“确认”键才能完成所定义的功能。 “复位”: 该键为重启系统按键。在任何时候或者系统出现不正常状态时都可按下...
  • 快速基础入门

    2020-06-17 10:11:49
    大家先来想一想咱们常用的互联网产品。 举栗子,大家一定都用过微信,假设你的微信朋友圈中有若干好友:张三、李四、王五、赵、七大姑、八大姨。 而你七大姑的微信号里,又有若干好友:你、八大姨、Jack、Rose...
  • 大家先来想一想咱们常用的互联网产品。举栗子,大家一定都用过微信,假设你的微信朋友圈中有若干好友:张三、李四、王五、赵、七大姑、八大姨。而你七大姑的微信号里,又有若干好友:你、八大姨、Jack、Rose。...
  • 目录 一、redis是什么? 二、redis应用的场景有哪些? 三、为什么要使用redis ...、redis的三种集群方式 ...Redis是一速度非常快的基于内存的支持Key-Value非关系...缓存可以说是Redis最常用的功能之一了,合理...
  • 提炼函数比较简单但又很常用的手法,目的是把一段逻辑上紧密联系构成相对独立功能块的代码封装起来,通过函数名字清晰的表达其用途,这样潜在的提供了其他模块复用该函数的概率,同时也更加易于维护,因为原来嵌在一...
  • 媒体查询 CSS媒体查询允许开发者基于浏览网站的设备的特性来应用不同的样式申明,最常用的特性是视口宽度。 GCF 谷歌内嵌浏览器框架, 使用此插件,用户可以通过Internet Explorer的用户界面,以Chrome内核的渲染方式...
  • JDialog窗体常用功能是从一窗体中弹出另一窗体。 二、重点内容 1.super(超级) 主要用于打开了子窗体时,阻塞对父窗体修改。也就是说打开了窗体便不能对父窗体有任何动作,关闭子窗体才可以对父窗体开始操作...
  • 本文设计并实现了一个功能较为完善计算机竞赛在线测评系统。 在国内,普遍地看,绝大多数远程教育考试还停留在传统考试方式。在此方式下,组织一次考试至少要经过5个步骤,即人工出卷、考生考试、人工阅卷、试卷...
  • assertion(断言)在软件开发中是一种常用的调试方式,很多开发语言中都支持这种机制。在实现中,assertion就是在程序中的一条语句,它对一boolean表达式进行检查,一正确程序必须保证这boolean表达式的值为...
  • MySQL是一种开放源代码的关系型数据库管理系统(RDBMS),MySQL数据库系统使用最常用的数据库管理语言--结构化查询语言(SQL)进行数据库管理。 由于MySQL是开放源代码的,因此任何人都可以在General Public License...
  • excel使用

    2012-11-25 17:06:01
    个常用的例子,就是教师在统计学生成绩时,希望输入60以下的分数时,能显示为“不及格”;输入60以上的分数时,显示为“及格"。这样的效果,利用IF函数可以很方便地实现。 假设成绩在A2单元格中,判断结果在A3...
  • 从Java基础、JavaWeb基础到常用的框架再到面试题都有完整的教程,几乎涵盖了Java后端必备的知识点。该开源仓库的文章都是我个人原创,公众号发过的技术文章(干货)也会有相关的目录整理,很多知识点我还在不停的...
  • 表结构元数据API也向用户开放,同时支持在使用过程中,灵活调整映射关系,因此用户可以用API动态创建表结构模型,从而实现各种动态类型和表映射(例如POJO中包含一Map,用于映射各种动态扩展字段)企业...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 166
精华内容 66
关键字:

常用的六个功能关系