精华内容
下载资源
问答
  • 作为一系列相关论文的开始,本文提供了设计和实现网络服务的基本原理,并且对面向服务的体系结构(SOA)的相关概念做了一简要的回顾,以及关于模式和反模式的详细讨论,当构建网络服务时,开发者可以利用它们...
  • [b]几个模式的简单理解,作为炮灰大家轰一轰,看没有理解错的地方,帮补充补充![/b] 1、代理模式:要求委托第三方来做,要求代理类被代理类同样的功能,代理类必须知道代理类什么功能,他做些什么事,...
    [b]几个模式的简单理解,作为炮灰大家轰一轰,看有没有理解错的地方,帮补充补充![/b]

    1、代理模式:要求委托第三方来做,要求代理类和被代理类有同样的功能,代理类必须知道代理类有什么功能,他能做些什么事,这就要求统一接口。
    2、策略模式:定义三个策略,如果策略相似,请注意统一接口,之后要定义场景,场景提供设置策略方法,执行策略方法。
    3、单例模式:方法大部分是private的(只有内部访问),getInstance是static,为了避免多线程,使用synchronized。
    4、多例模式:创建多个实例,类似于某个java包下的所有类,都创建实例(for example:一个朝代多个皇帝)。
    5、适配器模式:个人认为目的是对一个事物的不同的两个类(A、B)的描述(因为可能是不同系统),为了使用两个类统一,首先使用统一接口,定义个类(适配器,将类重新改造、整合重组)继承B,将原有的信息重组为接口的统一信息。
    ***接口为了方便可以就把A抽象成接口,当然也可根据具体需求情况自己定义。
    6、门面模式:对client端不透明,高内聚松耦合,定义接口,具体动作实现类,门户类,对于门户类可以设置实现类的动作执行顺序等,对client端提供执行的接口。
    7、建造者模式:定义建造模式类,建造实现类(设置模式类是如何实现的,例如顺序用List设置等)。可以实现更多级别的实现。
    8、原型模式:个人认为,利用原来的原型,创建和原来关系密切,没有太大变化的新类,经常利用Object的cloneable(),复制原型,注意这是浅复制,理解浅复制和深复制[size=medium][/size]。
    展开全文
  •  对于单例设计模式之静态内部类的实现方式存在以下疑点:①为什么内部类中如果有静态的变量,那么这内部类就必须是静态内部类(换一句话问:普通的内部类为什么不能有静态的成员变量)?②外部类加载的时候,静态...

    前言快速到底

      对于单例设计模式之静态内部类的实现方式存在以下疑点:①为什么内部类中如果有静态的变量,那么这个内部类就必须是静态内部类(换一句话问:普通的内部类为什么不能有静态的成员变量)?②外部类加载的时候,静态内部类是不是随着外部类一起加载。如果不是,为什么?③由第二个问题引出,如果静态内部类不是随着外部类的加载而加载(内部类也是不随着外部类的加载而加载),那么静态内部类和内部类有什么区别?④静态内部类和内部类的设计初衷是什么?

    首先给出单例模式的静态内部类的实现方式

    public class SingletonTest
    {
        
        static class Singleton      
        {
            private static Singleton INSTANCE = new Singleton();  
            static                                                         
            {                                                             
                System.out.println("Singleton 被初始化了!");
            }
        }
        
        public static Singleton getInstance()
        {
            Singleton instance = Singleton.INSTANCE;
            return instance;
        }
        
    }

     首先回答第一个问题:假设现在 Singleton 不是静态的内部类,就是一个普通的内部类,那就是这样的形式

    public class SingletonTest
    {
        
        class Singleton      
        {
            private static Singleton INSTANCE = new Singleton();  
            static                                                         
            {                                                             
                System.out.println("Singleton 被初始化了!");
            }
        }
        
        public static Singleton getInstance()
        {
            Singleton instance = Singleton.INSTANCE; 
            return instance;
        }
        
    }

    看这一行代码   Singleton instance = Singleton.INSTANCE; 由于里面的 INSTANCE 还是 static 的,所以我们还是可以这种方式访问 INSTANCE 的;然后通过 SingletonTest.getIntance() 就是可以创建一个 Singleton 对象;但是整个过程你会发现你都没有创建 SingletonTest 对象,也就是说你连外部类对象都没有创建,结果创建了一个内部类对象。这显然违背了内部类的访问规则。所以,普通的内部来中肯定不能有静态的成员变量。但是并不是说只要是静态的都不可以,看看下面的几种静态的情况

    public class OuterClass {
    
        class InnerClass{
            // 这样是可以的,基本数据类型使用 static final 修饰编译器会在编译的时候就将这个 i 放入 class 文件的常量池中
            static final int i = 50;
    // 这样不可以,虽然也为 static final 但是说到底还是个变量对象,所以不可以这样 static final String str = new String("");
    // 这个和第二个一样,也不行 static final InnerClass innerClass = new InnerClass(); } }

     摘取自 RUNOOB.COM 对于这种方式实现单例模式的描述:

    描述:这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程,它跟饿汉式方式不同的是:饿汉式方式只要 Singleton 类被装载了,那么 instance 就会被实例化(没有达到 lazy loading 效果),而这种方式是 SingletonTest类被装载了,instance 不一定被初始化。因为 Singleton 类没有被使用,所以它不会进行初始化。只有通过显式调用 getInstance() 方法时,才会显式装载 Singleton 类,从而实例化 instance。

    对于上面的这段描述中的 “这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程” 这一句我有些不太理解。下面这段话摘自周志明老师的《深入理解 JVM 第二版》

    准备阶段是正式为类变量分配内存并设置类变量值的阶段,这些变量所使用的内存都将在方法区中进行分配。这个阶段中有两个容易产生混淆的概念需要强调一下,首先,这时候进行内存分配的仅只有类变量(被 static 修饰的变量),而不包括实例变量,实例变量将会在对象实例化后随着对象一起分配在 Java 堆中。其次,这里所说的初始值“通常情况”下是数据类型的零值,假设一个类变量的定义为: public static int value = 3; 那变量 value 在准备阶段过后的初始值是 0 而不是 3,因为这时候尚未执行任何 Java 方法,而把 value 赋值为 123 的 putstatic 指令是在程序被编译后,存放类构造器 <clinit>() 方法之中,所以把 value 值赋为 123 的动作在初始化阶段才会执行。上面提到的,在“通常情况”下初始值是零值,那相对会有一些“特殊情况”:如果类字段的属性表中存在 ConstantValue 属性,那么在准备阶段变量 value 就会被初始化为 ConstantValue 属性所指定的值,假设上面类变量 value 的定义变为: public static final int value = 3; 编译时 Javac 将会为 value 生成 ConstantValue 属性,在准备阶段虚拟机就会根据 ConstantValue 属性的设置将 value 赋值为 123。

    看完之后我们就知道 INSTANCE 在准备阶段会被赋零值:null,在类的初始化阶段会进行 new Singleton();由于类加载机制保证的在类加载的整个过程中(加载、验证、准备、解析、初始化(其中初始化阶段是类加载过程的最后一步)),都是单线程的。所以在初始化阶段执行 new Singleton();也是单线程的。

    验证上述描述的代码:

    package com.tkz;
    
    public class OuterClass
    {
        static
        {
            System.out.println("OuterClass static load.");
        }
    
        static class InnerStaticClass
        {
            static
            {
                System.out.println("InnerStaticClass static load.");
            }
        }
        
        class InnerClass
        {
    //        普通内部类内部中不允许定义 static 代码块;使用下面的构造方法加上创建对象来代替验证一个类是否被初始化
    //        static
    //        {
    //            System.out.println("InnerClass static load.");
    //        }
            public InnerClass()
            {
                System.err.println("InnerClass load");
            }
            private InnerClass innerClass = new InnerClass();
        }
    
        public static void main(String[] args)
        {
            OuterClass outerClass = new OuterClass();
        }
    }

    运行结果

    OuterClass static load.

    以上的运行结果回答了第二个问题,接下来第解答第三个问题

    以上代码的确验证了静态内部类和内部类都不是随着外部类的加载而加载;那么静态内部类和内部类有什么区别?

    摘取自 ORACLE 官网这两个类的描述:

    Terminology: Nested classes are divided into two categories: static and non-static. Nested classes that are declared static are called static nested classes. Non-static nested classes are called inner classes.A nested class is a member of its enclosing class. Non-static nested classes (inner classes) have access to other members of the enclosing class, even if they are declared private. Static nested classes do not have access to other members of the enclosing class. As a member of the OuterClass, a nested class can be declared private, public, protected, orpackage private. (Recall that outer classes can only be declared public or package private.)

    以上 ORACLE 的描述,静态内部类本质是一个嵌套类,本质上,它并不能被称为“内部类”静态内部类就是个独立的类。之所以这么设计,只是起到一个注释的效果,而且这个注释可静态检查。比如有 A,B 两个类,B 有点特殊,虽然可以独立存在,但只被 A 使用。(这就是静态内部类的设计初衷)这时候怎么办?如果把 B 中的成员并入A里,复杂度提高,搞得 A 违反单一职责。如果 B 独立,又可能被其他类(比如同一个包下的 C)引用,不符合只被 A 使用的本意。所以不如将其变成 A.B,等于添加个注释,告诉其他类别使用 B 了,它只允许 A 使用。非静态的内部类才是真正的内部类,所以内部类对象是以外部类对象存在为前提(通过对象调用内部类的东西)。而在众多的 JDK 源码中可以看出内部类的使用并不多,反而嵌套类的使用很多。

     

    转载于:https://www.cnblogs.com/tkzL/p/8610387.html

    展开全文
  • 所谓单例就是在系统中只有一该类的实例。单例模式的核心分以下三步骤: ...单例模式的实现方式两种:饿汉模式和懒汉模式。 饿汉模式 不管现在需不需要,先创建实例。关键在于“饿”,饿了就要立即吃。 静态...

    所谓单例就是在系统中只有一个该类的实例。
    单例模式的核心分以下三个步骤:

    1. 构造方法私有化。即不能在类外实例化,只能在类内实例化。
    2. 在本类中创建本类的实例。
    3. 在本类中提供给外部获取实例的方式。

    单例模式的实现方式有两种:饿汉模式和懒汉模式。

    饿汉模式

    不管现在需不需要,先创建实例。关键在于“饿”,饿了就要立即吃。

    静态常量

    这里将类的构造器私有化,就不能在外部通过new关键字创建该类的实例,然后定义了一个该类的常量,用static修饰,以便外部能够获得该类实例(通过HungryStaticConstantSingleton.INSTANCE 获得)。也可以不加final关键字,具体看自己的需求。或者将INSTANCE私有化,并提供静态方法getInstance返回INSTANCE实例。

     1 /**
     2  * 恶汉模式-静态常量,简洁直观
     3  */
     4 public class HungryStaticConstantSingleton{
     5     //构造器私有化
     6     private HungryStaticConstantSingleton() {
     7     }
     8     //静态变量保存实例变量 并提供给外部实例
     9     public final static HungryStaticConstantSingleton INSTANCE = new HungryStaticConstantSingleton();
    10 }

     

    优点
    • 由于使用了static关键字,保证了在引用这个变量时,关于这个变量的所以写入操作都完成,所以保证了JVM层面的线程安全。
    缺点
    • 不能实现懒加载,造成空间浪费。如果一个类比较大,我们在初始化的时就加载了这个类,但是我们长时间没有使用这个类,这就导致了内存空间的浪费。

    枚举

    这种方式是最简洁的,不需要考虑构造方法私有化。值得注意的是枚举类不允许被继承,因为枚举类编译后默认为final class,可防止被子类修改。常量类可被继承修改、增加字段等,容易导致父类的不兼容。枚举类型是线程安全的,并且只会装载一次,设计者充分的利用了枚举的这个特性来实现单例模式,枚举的写法非常简单,而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式

    /**
     * 恶汉-枚举形式,最简洁
     */
    public enum HungryEnumSingleton{
        INSTANCE;
        
        public void print(){
            System.out.println("这是通过枚举获得的实例");
            System.out.println("HungryEnumSingleton.pring()");
        }
    }

     

    Test,打印实例直接输出了【INSTANCE】,是因为枚举帮我们实现了toString,默认打印名称。

    public class EnumSingleton2Test{
        public static void main(String[] args) {
            HungryEnumSingleton singleton2 = HungryEnumSingleton.INSTANCE;
            System.out.println(singleton2);
            singleton2.print();
        }
    }

     输出结果

     

    静态代码块

    这种方式和上面的静态常量/变量类似,只不过把new放到了静态代码块里,从简洁程度上比不过第一种。但是把new放在static代码块有别的好处,那就是可以做一些别的操作,如初始化一些变量,从配置文件读一些数据等。

    /**
     * 恶汉模式-静态代码块
     */
    public class HungryStaticBlockSingleton{
    
        //构造器私有化
        private HungryStaticBlockSingleton() {
        }
    
        //静态变量保存实例变量
        public static final HungryStaticBlockSingleton INSTANCE;
    
        static {
            INSTANCE = new HungryStaticBlockSingleton();
        }
    }

     

    如下,在static代码块里读取 info.properties 配置文件动态配置的属性,赋值给 info 字段。

    /**
     * 恶汉模式-静态代码块
     * 这种用于可以在静态代码块进行一些初始化
     */
    public class HungryStaticBlockSingleton{
    
        private String info;
    
        private HungryStaticBlockSingleton(String info) {
            this.info = info;
        }
    
        //构造器私有化
        private HungryStaticBlockSingleton() {
        }
    
        //静态变量保存实例变量
        public static final HungryStaticBlockSingleton INSTANCE;
    
        static {
            Properties properties = new Properties();
            try {
                properties.load(HungryStaticBlockSingleton.class.getClassLoader().getResourceAsStream("info.properties"));
            } catch (IOException e) {
                e.printStackTrace();
            }
            INSTANCE = new HungryStaticBlockSingleton(properties.getProperty("info"));
        }
        public String getInfo() {
            return info;
        }
    
        public void setInfo(String info) {
            this.info = info;
        }
    }

     

    Test,

    public class HungrySingletonTest{
        public static void main(String[] args) {
            HungryStaticBlockSingleton hun = HungryStaticBlockSingleton.INSTANCE;
            System.out.println(hun.getInfo());
        }
    }

     

    输出

     

    懒汉模式

    需要时再创建,关键在于“懒”,类似懒加载。

    非线程安全

    同样是构造方法私有化,提供给外部获得实例的方法,getInstance()方法被调用时创建实例。该方式适用于单线程,因为在多线程的情况下可能会发生线程安全问题,导致创建不同实例的情况发生。可以看下面的演示。

     1 /**
     2  * 懒汉模式-线程不安全的,适用于单线程
     3  */
     4 public class LazyUnsafeSingleton{
     5     private LazyUnsafeSingleton(){
     6     }
     7     private static LazyUnsafeSingleton instance;
     8     public static LazyUnsafeSingleton getInstance(){
     9         if(instance==null){
    10             instance = new LazyUnsafeSingleton();
    11         }
    12         return instance;
    13     }
    14 }

    非线程安全演示

     1 public class LazyUnsafeSingletionTest{
     2     public static void main(String[] args) throws ExecutionException, InterruptedException {
     3         ExecutorService es = Executors.newFixedThreadPool(2);
     4         Callable<LazyUnsafeSingleton> c1 = new Callable<LazyUnsafeSingleton>(){
     5             @Override
     6             public LazyUnsafeSingleton call() throws Exception {
     7                 return LazyUnsafeSingleton.getInstance();
     8             }
     9         };
    10         Callable<LazyUnsafeSingleton> c2 = new Callable<LazyUnsafeSingleton>(){
    11             @Override
    12             public LazyUnsafeSingleton call() throws Exception {
    13                 return LazyUnsafeSingleton.getInstance();
    14             }
    15         };
    16         Future<LazyUnsafeSingleton> submit = es.submit(c1);
    17         Future<LazyUnsafeSingleton> submit1 = es.submit(c2);
    18         LazyUnsafeSingleton lazyUnsafeSingleton = submit.get();
    19         LazyUnsafeSingleton lazyUnsafeSingleton1 = submit1.get();
    20         es.shutdown();
    21 
    22         System.out.println(lazyUnsafeSingleton);
    23         System.out.println(lazyUnsafeSingleton);
    24         System.out.println(lazyUnsafeSingleton1==lazyUnsafeSingleton);
    25     }
    26 }

     

    输出 大概运行三次就会出现一次,我们可以在 LazyUnsafeSingleton 中判断 if(instance==null) 之后增加线程休眠以获得更好的效果。

    线程安全的双重检查锁模式

    该方式是懒汉模式中线程安全的创建方式。通过同步代码块控制并发创建实例。并且采用双重检验,当两个线程同时执行第一个判空时,都满足的情况下,都会进来,然后去争锁,假设线程1拿到了锁,执行同步代码块的内容,创建了实例并返回,此时线程2又获得锁,执行同步代码块内的代码,因为此时线程1已经创建了,所以线程2虽然拿到锁了,如果内部不加判空的话,线程2会再new一次,导致两个线程获得的不是同一个实例。线程安全的控制其实是内部判空在起作用,至于为什么要加外面的判空下面会说。

    /**
     * 懒汉模式-线程安全,适用于多线程
     */
    public class LazySafeSingleton{
        private static volatile LazySafeSingleton safeSingleton;//防止指令重排
        private LazySafeSingleton() {
        }
        public static LazySafeSingleton getInstance(){
            if(safeSingleton==null){
                synchronized (LazySafeSingleton.class){
                    if(safeSingleton==null){//双重检测
                        safeSingleton = new LazySafeSingleton();
                    }
                }
    
            }
            return safeSingleton;
        }
    }

     当不加内层判空时,会出现不是单例的情况,只不过出现的概率更低了点。

    可不可以只加内层判空呢?答案是可以。

    那为什么还要加外层判空的呢?内层判空已经可以满足线程安全了,加外层判空的目的是为了提高效率。因为可能存在这样的情况:线程1拿到锁后执行同步代码块,在new之后,还没有释放锁的时候,线程2过来了,它在等待锁(此时线程1已经创建了实例,只不过还没释放锁,线程2就来了),然后线程1释放锁后,线程2拿到锁,进入同步代码块汇总,判空,返回。这种情况线程2是不是不用去等待锁了?所以在外层又加了一个判空就是为了防止这种情况,线程2过来后先判空,不为空就不用去等待锁了,这样提高了效率。

    双重检查锁模式是一种非常好的单例实现模式,解决了单例、性能、线程安全问题,上面的双重检测锁模式看上去完美无缺,其实是存在问题,在多线程的情况下,可能会出现空指针问题,出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。什么是指令重排?

    上面的safeSingleton = new LazySafeSingleton();操作并不是一个原子指令,会被分割成多个指令:

    1 memory = allocate(); //1:分配对象的内存空间
    2 ctorInstance(memory); //2:初始化对象
    3 instance = memory; //3:设置instance指向刚分配的内存地址

    经过指令重排

    1 memory = allocate(); //1:分配对象的内存空间
    2 instance = memory; //3:设置instance指向刚分配的内存地址,此时对象还没被初始化
    3 ctorInstance(memory); //2:初始化对象

    若有A线程进行完重排后的第二步,且未执行初始化对象。此时B线程来取singletonTest时,发现singletonTest不为空,于是便返回该值,但由于没有初始化完该对象,此时返回的对象是有问题的。这也就是为什么说看似稳的一逼的代码,实则不堪一击。 

    上述代码的改进方法:将safeSingleton声明为volatile类型即可(volatile有内存屏障的功能)。

    private static volatile LazySafeSingleton safeSingleton;

     

    内部类创建外部类实例

    该方式天然线程安全,是否final根据自己需要。

     1 /**
     2  * 懒汉模式-线程安全,适用于多线程
     3  * 在内部类被加载和初始化时 才创建实例
     4  * 静态内部类不会自动随着外部类的加载和初始化而初始化,它是要单独加载和初始化的。
     5  * 因为是在内部类加载和初始化时创建的 因此它是线程安全的
     6  */
     7 public class LazyInnerSingleton{
     8     private LazyInnerSingleton() {
     9     }
    10     private static class Inner{
    11         private static final LazyInnerSingleton INSTANCE = new LazyInnerSingleton();
    12     }
    13     public static LazyInnerSingleton getInstance(){
    14         return Inner.INSTANCE;
    15     }
    16 }

     

    破坏单例模式的方法及解决办法

    1、除枚举方式外, 其他方法都会通过反射的方式破坏单例,反射是通过调用构造方法生成新的对象,所以如果我们想要阻止单例破坏,可以在构造方法中进行判断,若已有实例, 则阻止生成新的实例,解决办法如下:

    1 private SingletonObject(){
    2     if (instance != null){
    3         throw new RuntimeException("实例已经存在,请通过 getInstance()方法获取");
    4     }
    5 }

    2、如果单例类实现了序列化接口Serializable, 就可以通过反序列化破坏单例,所以我们可以不实现序列化接口,如果非得实现序列化接口,可以重写反序列化方法readResolve(), 反序列化时直接返回相关单例对象。

    1   public Object readResolve() throws ObjectStreamException {
    2         return instance;
    3    }

    总结

    饿汉模式

    • 静态常量 简洁直观容易理解
    • 枚举 最简洁
    • 静态代码块 可以在静态块里做一些初始化的工作

    懒汉模式

    • 单线程形式 该形式下不适用多线程,存在线程安全问题
    • 多线程形式 适用于多线程
    • 内部类形式 最简洁

     
    如果你觉得文章不错,欢迎点赞转发

    转载于:https://www.cnblogs.com/ibigboy/p/11423613.html

    展开全文
  • 相信大家对单例模式应该不陌生,每人都写出好多种单例模式的实现,总结来说就五种:懒汉、饿汉、静态内部类、枚举双重检查锁定。针对这种方式的代码,可以在网上搜索到,这里就不再细说。   最近又看了...

    相信大家对单例模式应该不陌生,每个人都能写出好多种单例模式的实现,总结来说就有五种:懒汉、饿汉、静态内部类、枚举和双重检查锁定。针对这几种方式的代码,可以在网上搜索到,这里就不再细说。
     
    最近又看了一遍单例的几种实现方式,发现了一些其他东西。先看以下单例模式的实现代码
    public class Singleton2 {

        private Singleton2(){}

        private static Singleton2 instance;

        public static synchronized Singleton2 getInstance() {
            if (instance == null) {
                instance new Singleton2();
            }
            return instance;
        }

    }
    这种实现方式利用了同步的方式保证线程安全,但是效率特别低下,同步锁要善用。
     
    为了提高效率,可以把同步锁放到方法里,先判断instance是否为空,若不为空加锁进行初始化,若为空就可以直接获取对象,这样可以减少一大部分的线程等待,代码如下:
    public class Singleton7 {

        private Singleton7(){}
     
        private static Singleton7 instance;

        public static Singleton7 getInstance() {
            if (instance == null) {
                synchronized (Singleton7.class) {
                    if (instance == null) {
                        instance new Singleton7();
                    }
                }
            }
            return instance;
        }

    }
     
    现在提个问题,以上代码真的正确吗?觉得代码没问题的人,可以继续往下看,能看出问题的,估计下面的东西也知道。
     
    这里先把问题点明,以上代码中这一行private static Singleton7 instance;是有问题的,缺少了修饰符volatile,这个可是很重要的。
     
    这里先说明类初始化大概的流程:
    1、分配内存空间
    2、初始化对象
    3、设置instance指向分配的内存地址
    但是在这三步中,第二步和第三步是可以调换顺序的,也即
    1、分配内存空间
    3、设置instance指向分配的内存地址
    2、初始化对象
     
    基于上面的理论,以上代码在缺少volatile的情况下,会有以下问题


     
    从图中大致能看出B线程虽然获取到了instance对象,但这个对象其实没有真正初始化。
     
    知道这个问题之后,volatitle在这里就能起到至关重要的作用了,使用了volatitle之后,在JDK1.5之后,类初始化流程中第二步和第三步在多线程的情况会被禁止,从而保证代码的正常执行。 
    展开全文
  • 下面举几个常用设计模式:单例模式;工厂模式(抽象工厂模式);观察者模式;建造者模式;代理模式 20多种设计模式,最基础的是上面这几种,很多其实使他们的变形扩展。 综述:我认为,设计模式就是在代码骨架...
  • 设计模式之状态模式

    2019-10-23 13:46:58
    这篇文章分成几个部分,我会列出状态模式适用于哪些情况,它的优缺点都是什么,还有一些使用的例子。 的时候当一个对象的内部状态发生改变的时候,你需要改变这个对象的行为。状态模式就是用来干这个的。你也可以...
  • 以后配置文件都要放到项目中的一个或者几个单独的文件夹中,为了好管理。 该文件夹类型是source folder类型,源文件夹,eclipse工具会自动编译 --------------------------------------------------------------...
  • 模式两映射

    2021-03-08 10:00:44
    某个用户所看到或者操作的模式,举个例子,MySQL里个user1用户,他看到可操作好几个数据库db1、db2、db3,这部分就叫做外模式 概念模式 只有一个 概念模式也叫模式、逻辑模式 数据库中全体数据的逻辑结构...
  • 设计模式--单例模式

    2018-02-26 14:06:56
    单例模式特点: 一类只能实例,并且这自己创建出自己的实例供别人使用。类图:很简单,只有一类。单例模式种实现方式:饿汉式,懒汉式,DCL双重检查锁式,静态内部类式,枚举式,登记式单例模式...
  • 但是今天我先不搞其他设计模式,先把单例模式搞得明明白白的,再扯其他的模式,希望大家看完我写的这篇单例模式对单例模式有非常清楚的了解,所以希望大家耐心的看下去。所以这篇文章我会讲以下点 单例...
  • 但是这样算是基本实现了享元模式的共享对象的目的,不管建几个网站,只要购物网站都是一样的,只要是游戏网站也是完全相同的,但是这样也成为了一个问题,你给用户建造的网站不是一模一样的,他们的数据是不可能一样...
  • 三大模式与两大映射

    2019-11-03 13:46:37
    某个用户所看到或者操作的模式,举个例子,MySQL里个user1用户,他看到可操作好几个数据库db1、db2、db3,这部分就叫做外模式 概念模式 只有一个 概念模式也叫模式、逻辑模式 数据库中全体数据的逻辑结构...
  • 享元模式能做到共享的关键是区分内蕴状态外蕴状态。内蕴状态存储在享元内部,不会随环境的改变而有所不同。外蕴状态是随环境的改变而改变的。外蕴状态不能影响内蕴状态,它们是相互独立的。将可以共享的状态不...
  • 这里有几个特点: 域单机模式下应用服务器的安装升级, 支持 JBoss AS、EAP WildFly, 支持 Red Hat Debian 操作系统系列, 安装内部 JBoss 模块并从一组库中生成它们, 以域配置模式(包括创建虚拟服务器...
  • 单例模式

    2017-01-17 21:13:00
    优点:1、在内存里只有一实例,减少了内存的开销,尤其是频繁的创建销毁实例(比如管理学院首页页面缓存)。 2、避免对资源的多重占用(比如写文件操作)。 缺点:没有接口,不继承,与单一职责原则冲突,一...
  • 糟糕的程序框架,对于接下来的Debug程序的更新换代来讲,是灾难性的(我在本学期的数字电路实验课上学期的程序设计实验课中都深体会…)。 一优秀的程序,不仅体现在实际功能上性能上的优秀,更要体现...
  • 因此,在系统组件模块以及其内部工作机制不明确实,也就不确 定这工程的架构属性;然后最基本的部署维护问题都没有答案:这架构可扩 展吗?这工程性能如何?重构难度如何?部署策略如何?灵敏性如何?...
  • 一、概述 迭代器模式提供一种方法顺序访问一...1、Iterator抽象迭代器,定义访问遍历元素的接口,而且基本上固定的几个方法: (1)first获取第一个元素 (2)next访问下一个元素 (3)isDone是否已经访问到...
  • C#23种设计模式

    2013-06-02 16:49:43
    享元模式能做到共享的关键是区分内蕴状态外蕴状态。内蕴状态存储在享元内部,不会随环境的改变而有所不同。外蕴状态是随环境的改变而改变的。外蕴状态不能影响内蕴状态,它们是相互独立的。将可以共享的状态不...
  • 单例设计模式学习

    2017-04-07 14:23:00
    单例模式有很多种:这里学习一下常见的种:懒汉、饿汉、双重校验锁、枚举静态内部类。 单例模式的特点: 1. 单例类必须只能实例。 2. 单例类必须自己创建自己的唯一实例,不把创建的权利交给别人。...
  • 单例模式的一些总结

    2021-01-19 21:45:08
    1.什么是单例模式? 保证一类仅实例,并提供一访问它的全局访问点。 2.单例模式分为种? 饿汉式单例(立即加载):在单例类被加载时候,就...没有接口,不继承,与单一职责原则冲突,一类应该只关心

空空如也

空空如也

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

模式和内模式能有几个