精华内容
下载资源
问答
  • Java设置模式

    2018-08-06 15:59:00
    单例模式 装饰者模式 代理模式 转载于:https://www.cnblogs.com/liang-io/p/9430742.html

    单例模式

    装饰者模式

    代理模式

    转载于:https://www.cnblogs.com/liang-io/p/9430742.html

    展开全文
  • java设置模式

    2019-03-01 11:23:09
    java中抽象指的是接口或者抽象类,具体就是具体的实现类 开放原则 对扩展开放,对修改关闭,保证稳定性和延续性 里氏替换原则 所有引用基类的地方必须能透明地使用其子类对象 子类...

    一、对象设计六大原则

    1. 组合复用原则

      多用组合少用继承,找到变化的部分,抽象封装变化的部分,然后把抽象的具体实现带进去。

      has A------组合 is A------继承

    2. 依赖导致原则

      依赖:成员变量,方法参数,返回值,依赖抽象不要依赖具体

      高层模块不应该依赖低层模块,两者都应该依赖其抽象,抽象不应该依赖具体,具体应该依赖抽象。

      针对接口编程,不要针对实现编程

      以抽象为基础搭建的结构比就提类搭建的结构要稳定的多。

      在java中抽象指的是接口或者抽象类,具体就是具体的实现类

    3. 开放原则

      对扩展开放,对修改关闭,保证稳定性和延续性

    4. 里氏替换原则

      所有引用基类的地方必须能透明地使用其子类对象

      子类扩展父类功能时。不能破坏父类原有的功能,使用继承时遵循里氏替换原则,子类可以实现父类的抽象方法,但是不能覆盖父类的非抽象方法,当子类重载父类方法时,方法的形参要比父类的方法参数要宽松。

      当子类实现父类的抽象方法时,方法的返回值要比父类更严格。

      里氏替换原则是设计整个集成体系的原则

    5. 迪米特原则(最小知识原则)

      一个对象应该与其他对象保持更少的了解,至于直接朋友交谈

      成员变量,方法参数,方法返回值中需要的类为直接朋友,类与类之间的关系越密切,了解越多,耦合度就越大,尽量降低类与类之间的耦合。

      接口隔离原则:一个类对另一个类的依赖应该建立在最小的接口上

    6. 单一职责原则

      类应该只有一个导致类变更的理由,即一个类只负责一项职责。

      降低类的复杂度,提高系统的可维护性,修改时降低风险溢出。

    二、设计模式的分类

    1. 设计模式介绍 模式:在某些场景下,针对某类问题的某种通用解决方案。

    2. 创建型模式 对象实例化的模式,创建型模式解耦了对象的实例化过程

      • 简单工厂:一个工厂类根据传入的参量决定创建出哪一个产品类的实例

      • 工厂方法:定义一个创建对象的接口,让子类决定实例化哪一个类

      • 抽象工厂:创建相关依赖对象的家族,而无需明确指定具体的类

      • 单例模式:某个类只能有一个实例,提高一个全局访问点

      • 生成器模式:封装一个复杂对象的构建过程,并可以按步骤构造。

      • 原型模式:通过复制现有的实例来创建新的实例

    3. 结构型模式 把类和对象结合到一起形成更大的结构

      • 适配器模式:将一个类的方法接口转换成客户希望的另一个接口

      • 组合模式:将对象组合成树形结构,以表示部分-----整体的层次结构。

      • 装饰者模式:动态地给对象添加新的功能。

      • 代理模式:为其他对象提供一个代理以控制对这个对象的访问

      • 蝇量模式:通过共享技术有效地支持大量细粒度的对象

      • 外观模式:提供统一的方法来访问子系统的一群接口

      • 桥接模式:将抽象部分与其他的实现部分分离,使他们都可以独立的变化

    4. 行为型模式 类和对象如何交互,及划分责任和算法

      • 模板模式:定义一个算法结构,而将一些步骤延迟到子类中实现。

      • 解释器模式:给定一个语言,定义它的文法的一种表示,并定义一个解释器。

      • 策略模式:定义一系列的算法,把他们封装起来,并且使它们可以相互替换

      • 状态模式:允许一个对象在其内部状态改变时,改变他的行为

      • 观察者模式:对象间的一对多的依赖关系

      • 备忘录模式:在不破坏封装性的前提下,保存对象的内部状态

      • 中介者模式:同一个中介对象封装一系列的对象交互。

      • 命令模式:将命令请求封装为一个对象,使得可用不同的请求来进行参数化。

      • 访问者模式:在不改变数据结构的前提下,增加作用于一组对象元素新的功能

      • 责任链模式:请求的发送者和接收者之间解耦,使得多个对象都有机会处理这个请求

      • 迭代器模式:一种遍历访问聚合对象中各个元素的方法,不暴露该对象的内部结构

    三、用模式思考

    1. 保持简单 尽量用最简单的方式解决问题,简单而弹性的设计,一般使用模式是最好的方法。

    2. 设计模式非万能 模式是通用问题的经验总结,使用模式的时候要考虑他对其他部分的影响,不需要预留任何弹性的时候,删除掉模式。

    3. 何时需要模式 找出设计中会变化的部分,通常就是需要考虑模式的地方

    4. 代码重构 重构就是改变代码来改进组织方式的过程,重构的时间就是模式的时间。

    展开全文
  • 状态模式的定义:状态模式也叫作状态机模式,运行对象在内部状态发生改变时改变它的行为,对象看起来好像修改了它的类,属于行为型设计模式。状态模式中类的行为是由状态决定的,在不同的状态下有不同的行为。其意图...

    状态模式的定义:

    状态模式也叫作状态机模式,运行对象在内部状态发生改变时改变它的行为,对象看起来好像修改了它的类,属于行为型设计模式。

    状态模式中类的行为是由状态决定的,在不同的状态下有不同的行为。其意图是让一个对象在其内部改变的时候,行为也随之改变。

    状态模式的核心是装态与行为绑定,不同的状态对应不同的行为。

    状态模式的应用场景:

    行为随状态改变而改变的场景。

    一个操作中含有庞大的多分支结构,并且这些分支取决于对象的状态。

    状态模式的UML类图:

    状态模式的UML类图就不画了,因为它和策略模式的UML类图基本一致,它们都包含三个角色,

    其中环境类角色(Context)分别是负责切换策略和状态,抽象角色分别是定义不同策略和不同状态

    的行为,具体角色分别是策略的具体实现和状态的具体实现,唯一的区别是状态模式在完成某个状态

    的行为之后还有可能会切换到其他状态。

    使用状态模式实现登录状态自由切换:

    当我们浏览博客园的文章时,如果我们觉得文章很好,忍不住想评论、收藏。但是如果我们处于未登录的状态,就会自动跳转到登录页面

    这里涉及到的状态有两种登录和未登录,行为有评论和收藏。下面使用状态模式来实现这个逻辑,代码如下。

    首先创建抽象状态角色类,定义评论和收藏两个行为

    public abstract classUserState {protectedAppContext context;public voidsetContext(AppContext context) {this.context =context;

    }public abstract voidfavorite();public abstract voidcomment(String comment);

    }

    然后创建未登录状态类,定义在未登录状态下,两种行为的具体实现

    public class UnLoginState extendsUserState {

    @Overridepublic voidfavorite() {this.switch2login();this.context.getState().favorite();

    }

    @Overridepublic voidcomment(String comment) {this.switch2login();this.context.getState().comment(comment);

    }private voidswitch2login(){

    System.out.println("跳转到登录页!");this.context.setState(this.context.STATE_LOGIN);

    }

    }

    创建登录状态类,定义在登录状态下,两种行为的具体实现

    public class LoginState extendsUserState {

    @Overridepublic voidfavorite() {

    System.out.println("收藏成功!");

    }

    @Overridepublic voidcomment(String comment) {

    System.out.println(comment);

    }

    }

    创建上下文角色类,根据登录状态切换具体的行为

    public classAppContext {public static final UserState STATE_LOGIN = newLoginState();public static final UserState STATE_UNLOGIN = newUnLoginState();private UserState currentState =STATE_UNLOGIN;

    {

    STATE_LOGIN.setContext(this);

    STATE_UNLOGIN.setContext(this);

    }public voidsetState(UserState state){this.currentState =state;

    }publicUserState getState(){return this.currentState;

    }public voidfavorite(){this.currentState.favorite();

    }public voidcomment(String comment){this.currentState.comment(comment);

    }

    }

    最后编写客户端测试代码。

    public classTest {public static voidmain(String[] args) {

    AppContext context= newAppContext();

    context.favorite();

    context.comment("评论:好文章,360个赞");

    }

    }

    状态模式和责任链模式的区别:

    状态模式和责任链模式都能消除if...else分支过多的问题。但是在某些情况下,状态模式中的状态可以理解为责任,那么这种情况下,两种模式都可以使用。

    从定义上来看,状态模式强调的是一个对象内在状态的改变,而责任链模式强调的是外部节点对象间的改变。

    从代码实现上来看,两者最大的区别就是状态模式的各个状态对象知道自己要进入的下一个状态对象,而责任链模式并不清楚其下一个节点处理对象,因为链式组装由客户端负责。

    状态模式和策略模式的区别:

    状态模式和策略模式的UML类图架构几乎完全一样,但两者的应用场景是不一样的。策略模式的多种算法行为则其一都能满足,彼此之间是独立的,用户可自行更换策略算法;而

    状态模式的各个状态之间存在相互关系,彼此之间一定的条件下存在自动切换的效果,并且用户无法指定状态,只能设置初始状态,因为状态是根据行为而改变的。

    状态模式的优点:

    结构清晰:将状态独立为类,清楚了冗余的if...else或switch...case语句,使代码更加间接,提高了系统的可维护性。

    将状态转换现实化:通常对象内部都是使用数值类型来定义状态的,状态的切换通过赋值进行表现,不够直观;而使用状态类,当切换状态时,是以不同的类进行表示的,转换目的更加明确。

    状态类职责明确且具备扩展性。

    状态模式的缺点:

    类膨胀,如果一个类的状态过多,则会造成状态类过多。

    状态模式的结构和实现都较为复杂,如果使用不当,将导致程序结构和代码的混乱。

    状态模式对开闭原则的支持不太友好,如果新增了状态类,则需要修改负责切换到该类的状态类。而且修改某个状态的行为也要修改源码。

    展开全文
  • 所谓的代理模式就是指由一个代理主题来操作真实主题,真实主题执行具体的业务操作,而代理主题负责其他相关业务的处理。就好像一个公司的老板需要开会一样,老板(真实主题)来主持会议,老板的秘书(代理主题)负责...

    所谓的代理模式就是指由一个代理主题来操作真实主题,真实主题执行具体的业务操作,而代理主题负责其他相关业务的处理。就好像一个公司的老板需要开会一样,老板(真实主题)来主持会议,老板的秘书(代理主题)负责开会前的准备性工作以及会后的相关事宜的处理。无论是老板的会议主持,还是秘书为会议的准备或会后事宜处理,共同的目的都是为了开会。

    静态代理实现

    package com.qwy;
    
    /**
     * @author qwy
     * @create 2021-03-30 22:06
     **/
    interface  Meeting{
        public void meet();
    }
    class  Boss implements Meeting{
    
        @Override
        public void meet() {
            System.out.println("老板主持开会");
        }
    }
    class Secretary implements  Meeting{
        private Meeting meeting;
    
        public Secretary(Meeting meeting) {
            this.meeting = meeting;
        }
    
        @Override
        public void meet() {
            this.ready();
            this.meeting.meet();
            this.end();
        }
        public void ready(){
            System.out.println("秘书负责会议之前的准备工作");
        }
        public void end(){
            System.out.println("秘书整理会后事宜");
        }
    }
    public class TestProxy {
        public static void main(String[] args) {
            Meeting boos= new Boss();
            Secretary proxy=new Secretary(boos);
            proxy.meet();
        }
    }
    
    

    运行结果:
    秘书负责会议之前的准备工作
    老板主持开会
    秘书整理会后事宜

    动态代理实现

    上例的静态代理,每一个代理类只能为一个接口服务,最好的方式就是可以通过一个类完成全部的代理工作,JDK为我们提供动态代理。在java中实现动态代理需要以下接口和类的支持:
    1.java.lang.reflect.InvocationHandler接口

    
    package java.lang.reflect;
    public interface InvocationHandler {
        public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable;
    }
    
    

    参数:
    Object proxy:被代理的对象
    Method method:要调用的方法
    Object[] args:方法调用时需要的参数
    2.java.lang.reflect.Proxy类
    Proxy类是专门完成代理的操作类,可以通过此类为一个或多个接口动态生成实现类。提供的操作方法:

    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
                                   throws IllegalArgumentException  
    

    通过该方法可以动态生成实现类,参数:
    ClassLoader loader:目标类加载器
    Class<?>[] interfaces:得到全部的接口
    InvocationHandler h:得到InvocationHandler接口子类实例。

    实例:

    package com.qwy2;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /**
     * @author qwy
     * @create 2021-03-30 22:21
     **/
    interface  Meeting{
        public void meet();
    }
    class Boos implements Meeting{
    
        @Override
        public void meet() {
            System.out.println("老板主持开会");
        }
    
    }
    class Secretary implements InvocationHandler {
        //真实业务类对象
        private Object target;
    
        /**
         * 进行真实业务对象与代理业务对象之间的绑定处理
         * @param target
         * @return
         */
        public Object bind(Object target){
            this.target=target;//保存真实业务对象
            /**
             * Proxy.newProxyInstance(loader,interfaces,h)的参数
             * loader - 定义代理类的类加载器
             * interfaces - 代理类要实现的接口列表
             * h - 指派方法调用的调用处理程序
             */
            return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
        }
        public void ready(){
            System.out.println("秘书负责会议之前的准备工作");
        }
        public void end(){
            System.out.println("秘书整理会后事宜");
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           this.ready();
            /**
             * method:为代理类对象调用的方法,此方法也就作为了被代理类对象要调用的方法
             * this.target:被代理类的对象
             * args:传入代理实例上方法调用的参数值的对象数组,如果接口方法不使用参数,则为 null
             */
            Object resultData= method.invoke(this.target, args);
            this.end();
            return resultData;
        }
    }
    public class TestProxy {
        public static void main(String[] args) {
            Meeting meeting= (Meeting) new Secretary().bind(new Boos());
            meeting.meet();
    
        }
    }
    
    

    运行结果:
    秘书负责会议之前的准备工作
    老板主持开会
    秘书整理会后事宜

    展开全文
  • 中介者模式是指用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式的相互引用,从而使其耦合松散,而且可以独立的改变他们之间的交互。 适合中介者模式的情景如下:许多对象以复杂的方式交互,所导致...
  • 单例模式算的上是一种最简单的设计模式了,甚至有些爸爸认为它都算不上是一种模式,顶多算的上算是一种设计技巧。 所谓单例模式,就是一个类有且只能有一个实例,他需要自行创建一个实例并且开放给系统。这种设计...
  • 3,定义另一个实现类,作为树形结构的最顶端,作为组合模式中的实现者,里面包含组合的增删改查等操作方法,接口实现的方法作为两个实现类的互通方法 package com.org.composite; import java.util.ArrayList; ...
  • 单例模式
  • 工厂模式 使用Java设置工厂模式的示例
  • 电灯开关一般有两个状态:开和关,通过...1.状态模式状态模式的定义如下:状态模式(State Pattern), 当一个对象的内在状态改变时,允许改变其行为,这个对象看起来像是改变了其类。当你遇到如下问题时,可以考虑状态...
  • 日志宝-在线日志分析平台主要区别:client模式启动快,运行速度慢(启动快可能是由于数据共享),HotSpot VM的client模式实现了...client模式适用于GUI的开发,Server模式适用于Java Server下面是51CTO的一篇文章这里...
  • 一、什么是工厂方法模式工厂方法模式同样属于类的创建型模式又被称为多态工厂模式 。工厂方法模式的意义是定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建,这样核心...
  • FTP的主动模式与被动模式FTP服务器使用20和21两个网络端口与FTP客户端进行通信。FTP服务器的21端口用于传输FTP的控制命令,20端口用于传输文件数据。FTP主动模式:FTP客户端向服务器的FTP控制端口(默认是21)发送连接...
  • 这里向大家描述一下JVM client模式和Server模式两者的区别和联系,JVM如果不显式指定是-Server模式还是-client模式,JVM能够根据下列原则进行自动判断(适用于Java5版本或者Java以上版本)。JVM client模式和Server...
  • 我们把jdk安装完成后,在命名行输入java -version不仅可以看到jdk版本相关信息,还会看到类似与Java HotSpot(TM) 64-Bit Server VM (build 25.31-b07, mixed mode)这样的信息。其中有个Server VM (build 25.31-b07, ...
  • FTP的主动模式与被动模式FTP服务器使用20和21两个网络端口与FTP客户端进行通信。FTP服务器的21端口用于传输FTP的控制命令,20端口用于传输文件数据。FTP主动模式:FTP客户端向服务器的FTP控制端口(默认是21)发送连接...
  • 这里向大家描述一下JVM client模式和Server模式两者的区别和联系,JVM如果不显式指定是-Server模式还是-client模式,JVM能够根据下列原则进行自动判断(适用于Java5版本或者Java以上版本)。JVM client模式和Server...
  • package com.zshh.designpattern.factorymeth;public class Jmain {public static void main(String[] args) {Client sc = new ConcreteClient();sc.AnOperation();}}package ...pu...
  • 对于一个表格,我们可以设置其选择模式设置每次选择一行或者连续多行,或者任意连续多行。我们也可以设置其列的选择模型。 先创建表格 JTable table=new JTable(); 对于行选择方式,应该调用 getSelectionModel()...
  • 概述JVM有两种运行模式Server与Client。两种模式的区别在于,Client模式启动速度较快,Server模式启动较慢;但是启动进入稳定期长期运行之后Server模式的程序运行速度比Client要快很多。这是因为Server模式启动的JVM...
  • Java Web开发模式如何在jsp页面中引用JavaBean正确理解JavaBeanJSP开发模式1JSP开发模式2使用过滤器作为MVC中的控制器Web开发模式变迁servlet使web应用程序开发变得非常繁琐并且不利于分工合作使用JSP来开发Web应用...
  • java与模式-清晰书签版,电子书各种java设置模式

空空如也

空空如也

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

java设置模式

java 订阅