• java pattern


    http://blog.163.com/ren_bozhou/blog/static/51689589200802475141861/

    http://sunnylocus.iteye.com/blog/232915

    http://anysky131.iteye.com/blog/234714

    访问模式

    http://cy729215495.iteye.com/blog/246900

    http://news.csdn.net/n/20080805/117902.html

    http://8366.iteye.com/blog/234718

    OBServer 观察者模式 java.util.*            

    Decorator 装饰器模式 java.io*       

           

    Protetype  原型模式    java.lang.Cloneable    

    问题:object.clone() 方法:深拷贝和浅拷贝(默认)的区别?

    解决:

    浅拷贝:拷贝对象

    深拷贝:拷贝对象及其引用对象。深拷贝须实现java.lang.Cloneable接口,重写clone()方法,

    因为Object的Clone()方法是protected签名的,而Cloneable接口的作用:把protected权限放大到public,这样才可重写Clone()发法。

    问题:若引用的对象又引用了其他对象,是否一直判断并复制,过程繁琐?

    解决:

    重写Clone()方法时直接把对象序列化到磁盘 然后再反序列化回来,这样不用判断就得到反序列化结果,参照ObjectOutPutStream和ObjectInputStream。

    工厂模式为什么会引入, 方便管理这个类.


    理解抽象,abstract :1、抽象类内可以无抽象方法。2、抽象类不能创建实例。只能被继承。
    当子类覆盖父类时 子类的修饰符不能比父类更严格。

    模板模式:父类有时并不能确定,推迟到子类来实现。
             当多态发生时,将会调用子类的方法。
             自己写一个模板模式: 父类规范了一些原则性的东西,具体的实现推迟到子类来实现、

    接口:接口是一个total abstract。


    工厂模式:实体类,必须都实现同一个接口; 工厂返回一个接口类。

    代理模式: 老板判断员工是否加薪,(没有代理时)工作繁琐.这时可以添加一个代理(秘书),为老板省去大量的繁琐工作,再在提交给老板.

    适配器模式: 有俩个类,一个可以打方砖,一个可以打圆状.现在需要一个即能打方的又能打圆的类.
                需要适配器模式, 继承一个,合成一个.

    策略模式:  一个接口,引入一系列实现类.当我加一个实现类时,我的程序会很容易切换.不用改变程序的结构   .
               打个比方我们画画是借助于笔的笔芯来画的,笔芯是可以换的.(可换笔芯的笔.)
     
    命令模式: 你是命令你就能执行.

    最难的是喝咖啡:杯子和咖啡 .  这是个结构和行为交织到一起的类.桥模式

    1995年5月23号  叫java语言的 诞生了.

    治书先治史.

    java23种设计模式:

    单态模式

    http://kang.iteye.com/blog/228735

    http://8366.iteye.com/blog/238200

    package com.javaeye.lindows.design23;
    
    public class FileOpen {
    	/**
    	 * @author Lindows
    	 */
    	public FileOpen() {
    		System.out.println("默认构造函数,可以让外界直接new对象");
    	}
    
    	public void createFile() {
    		System.out.println("创建文件");
    	}
    }
    
    package com.javaeye.lindows.design23;
    
    public class FileOpen2 {
    	private FileOpen2(){
    		System.out.println("定义私有构造函数,不让外界直接new");
    	}
           //方式一:饿汉式单例模式:指全局的单例实例在类装载时构建。(一般认为这种方式要更加安全些)	
    	public void createFile2(){
    		System.out.println("创建文件");
    	}
           //在自己内部定义自己的一个private实例,只供内部调用	
    	private static final FileOpen2 fileOpen2 = new FileOpen2();
    
    	// 使用我对外界提供本类自己的new的对象,供外部访问本class的静态方法
    	public static FileOpen2 getInstance() {
    		return fileOpen2;
    	}
    	
    }
    
    package com.javaeye.lindows.design23;
    
    public class FileOpen3 {
    	/*
    	 * 使用单态模式,对于多线程不太安全,通过加载同步方法来保证线程安全
    	 */
    	private FileOpen3(){
    		System.out.println("定义私有构造函数,不让外界直接new");
    	}
    	public void createFile() {
    		System.out.println("创建文件");
    	}
           //方式二:懒汉式单例模式,指全局的单例实例在第一次被使用时构建。
    	private static FileOpen3 fileOpen3 = null;
          //syschronized,互斥锁,同步机制,虽然这样会减低效率
           public static synchronized FileOpen3 getInstance() {
    		if (fileOpen3 == null) {
    			fileOpen3 = new FileOpen3();
    		}
    		System.out.println("使用单态模式,对于多线程不太安全,通过加载同步方法来保证线程安全");
    		return fileOpen3;
    		
    	}
    }
    
    package com.javaeye.lindows.design23;
    
    /**
     * @author Lindows
     * 
     */
    public class FileOpen4 {
    	private FileOpen4() {
    		System.out.println("定义私有构造函数,不让外界直接new");
    	}
    
    	// 内部类
    	private static class MyFileOpen4 {
    		private static FileOpen4 fileOpen4 = new FileOpen4();
    	}
    
    	public void createFile() {
    		System.out.println("创建文件");
    	}
    
    	public static FileOpen4 getInstance() {
    		return MyFileOpen4.fileOpen4;
    	}
    	/*
    	 * 加载FileOpen4时并不加载它的内部类MyFileOpen4,调用getInstance()后调用
    	 * MyFileOpen4时才加载MyFileOpen4,从而调用FileOpen4的构造函数,实例化FileOpen4,从而达到 lazy
    	 * loading
    	 */
    }
    
     
    package com.javaeye.lindows.design23;
    
    public class SingletonTest {
    
    	/**
    	 * @author Lindows
    	 * 场景:
    	 * 在一个系统中,需要经常对文件系统进行操作,如传建文件、拷贝文件等等,假如这些功能用FileOpen类封装,你如何调用这个类?
    	 * FileOpen fo = new FileOpen();
    	 * fo.createFile();
    	 * 但是我们发现:
    	 * 这个类的工作与具体的业务逻辑似乎关系不大,他做的是一些共性工作,每次调用时都实例化,似乎太消耗内存。
    	 * 怎样保证在调用的时候,系统只有一个对象?
    	 * 1.利用静态变量可以做到
    	 * 2.第二种方法
    	 * 举例:
    	 * Hibernate中,SessionFactory的生成;注意有时候看文档,有些类的构造函数是被保护的,或者没有构造函数,十有八九用的就是单例模式。
    	 * 如果:
    	 * 模块做的工作比较公共化,或者模块比较消耗内存.
    	 * 例如:
    	 * 字典的载人,application实际上就是实现了单例模式
    	 * Logger logger = Logger.getLogger();
    	 * 练习:
    	 * 完成DirCreator,要求里面包含创建目录的代码,使用单例模式,测试。 
    	 */
    	public static void main(String[] args) {
    		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    		/*
    		 * 没有使用单例模式两次new FileOpen();调用了两次构造函数
    		 * 假如使用 FileOpen fileOpen1 = fileOpen
    		 * 就会强求程序员使用1000行代码前定义的 fileOpen
    		 */
    		FileOpen fileOpen = new FileOpen();
    		fileOpen.createFile();
    		// 1000行代码
    		FileOpen fileOpen1 = new FileOpen();
    		fileOpen1.createFile();
    		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    		/*
    		 * 直接提供FileOpen2类本身对外提供的对象,不再人为的new对象
    		 */
    		FileOpen2 fo = FileOpen2.getInstance();
    		fo.createFile2();
    		//1000行代码
    		FileOpen2 fo2 = FileOpen2.getInstance();
    		fo2.createFile2();
    		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    		/*
    		 * 直接提供FileOpen2类本身对外提供的对象,不再人为的new对象
    		 */
    		FileOpen3 fOpen3 = FileOpen3.getInstance();
    		fOpen3.createFile();
    		//1000行代码
    		FileOpen3 fOpen32 = FileOpen3.getInstance();
    		fOpen32.createFile();
    		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    
    		/*
    		 * 加载FileOpen4时并不加载它的内部类MyFileOpen4,调用getInstance()后调用
    		 * MyFileOpen4时才加载MyFileOpen4,从而调用FileOpen4的构造函数,实例化singleton,从而达到 lazy
    		 * loading
    		 */
    		FileOpen4 fOpen4 = FileOpen4.getInstance();
    		fOpen4.createFile();
    		// 1000行代码
    		FileOpen4 fOpen4a = FileOpen4.getInstance();
    		fOpen4a.createFile();
    		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    
    
    	}
    	/**
    	 * Singleton模式小结:
    	 * Singleton模式主要作用是保证在java应用程序中,一个类Class只有一个实例存在.
    	 * 在很多操作中,比如建立目录数据库连接,都需要这样的操作。
    	 * 适合做公共工作,Singleton模式就为我们提供了这样的实现的可能。
    	 * 使用Singleton的好处在于可以节省内存,因为它限制了实例的个数,有利于java的垃圾回收(garbage collection)。
    	 */
    
    }
    

     dsafasfaf

    sadfsafsfsf

    asdfasfasd

  • 相关阅读:
    shell编程
    redis不重启,切换RDB备份到AOF备份
    java中接口和抽象类的区别
    java中的泛型
    java中有关初始化的问题
    java中的多态
    java中的Iterator和ListIterator的区别
    Collection集合的三种初始化方法
    java正则表达式appendReplacement和appendTail方法
    java中main函数的String[] args
  • 原文地址:https://www.cnblogs.com/lindows/p/14390638.html
Copyright © 2020-2023  润新知