JavaSe——设计模式

A.模块设计模式

l模版设计模式概述

•模版方法模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现

l优点

•使用模版方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求

l缺点

•如果算法骨架有修改的话，则需要修改抽象类

GetTime类：

package com.core.module;

public abstract class GetTime {
	public long getTime() {
		long begin = System.currentTimeMillis();
		code();
		long end = System.currentTimeMillis();
		return end - begin;
	}

	abstract void code();
}

输出的类：

package com.core.module;

public class OutDemo extends GetTime {

	@Override
	void code() {
			for (int i = 0; i < 10000; i++) {
				System.out.println(i);
			}
	}

}

复制的类：

package com.core.module;

public class IODemo extends GetTime {

	@Override
	void code() {
		try {
			Thread.sleep(3000);//假设是在复制...
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

测试类：

package com.core.module;

public class TestDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//输出的耗时
		OutDemo outDemo = new OutDemo();
		long time = outDemo.getTime();
		System.out.println("输出耗时："+time);
		//拷贝的耗时
		IODemo ioDemo = new IODemo();
		long time2 = ioDemo.getTime();
		System.out.println("拷贝耗时："+time2);
		
	}

}

B.装饰设计模式

l装饰设计模式概述

•装饰模式就是使用被装饰类的一个子类的实例，在客户端将这个子类的实例交给装饰类。是继承的替代方案

l优点

•使用装饰模式，可以提供比继承更灵活的扩展对象的功能，它可以动态的添加对象的功能，并且可以随意的组合这些功能

l缺点

•正因为可以随意组合，所以就可能出现一些不合理的逻辑

手机添加新功能

1:继承版

2:装饰模式版

最后说说IO中的装饰模式应用

Phone类：

package com.core.decorate;

public interface Phone {
	public abstract void call();
}

Iphone类：

package com.core.decorate;

public class IPhone implements Phone {

	@Override
	public void call() {
		System.out.println("手机可以打电话");
	}

}

Phone装饰类：

package com.core.decorate;

public abstract class PhoneDecorate implements Phone {
	private Phone p;
	public PhoneDecorate(Phone p){
		this.p = p;
	}

	@Override
	public void call() {
		this.p.call();
	}

}

彩铃类：

package com.core.decorate;

public class RingPhoneDecorate extends PhoneDecorate {

	public RingPhoneDecorate(Phone p) {
		super(p);
	}
	@Override
	public void call() {
		System.out.println("手机可以听彩铃");
		super.call();
	}
}

音乐类：

package com.core.decorate;

public class MusicPhoneDecorate extends PhoneDecorate {

	public MusicPhoneDecorate(Phone p) {
		super(p);
	}

	@Override
	public void call() {
		super.call();
		System.out.println("手机可以听音乐了");
	}
}

测试类：

package com.core.decorate;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class TestDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		IPhone phone = new IPhone();
		phone.call();
		System.out.println("---");
		//给手机添加彩铃功能,接电话前
		RingPhoneDecorate rp = new RingPhoneDecorate(phone);
		rp.call();
		System.out.println("---");
		//接电话之后，可以听音乐
		MusicPhoneDecorate mp = new MusicPhoneDecorate(phone);
		mp.call();
		System.out.println("---");
		//新需求：在接电话前，听彩铃，电话后，听音乐
		MusicPhoneDecorate newPhone = new MusicPhoneDecorate(new RingPhoneDecorate(phone));
		newPhone.call();
		System.out.println("---");
		RingPhoneDecorate newPhone2 = new RingPhoneDecorate(new MusicPhoneDecorate(phone));
		newPhone2.call();
		//IO流的应用
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	}

}

更详细的参看这里： http://jiangnanlove.iteye.com/blog/914120

刚好看了个视频 关于装饰设计模式 觉得挺精辟的就保留了下来

什么是装饰设计模式:

当想要对已有的对象进行功能增强时，
可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
那么自定义的该类称为装饰类。

装饰类通常会通过构造方法接收被装饰的对象。
并基于被装饰的对象的功能，提供更强的功能。

 

如一个简单的demo 人吃饭，刚开始人穷只是普通的吃饭后来人生活好了吃饭就不一样了增强了吃饭的功能  虽然例子不是恰当 能说明问题就行

看代码：

//穷的时候吃饭简简单单的吃饭
class Person
{
	public void chiFan(){
	
		System.out.println("吃饭");
	}
}

//富裕后吃饭 吃饭前来杯酒吃饭后来根烟 但是这中间的过程还是有吃饭
class SuperPerson
{
	private Person p;
	public SuperPerson(Person p){
	
		this.p=p;
	}

	public void superChiFan(){
		//吃饭前来杯开胃酒增加食量
		System.out.println("开胃酒");
		p.chiFan();
		//吃完饭后来根烟
		System.out.println("来根烟");
	}

}
public class PersonDemo
{	public static void main(String args[]){
	Person p=new Person();

	SuperPerson sp= new SuperPerson(p);

	sp.superChiFan();
	}
}

以上只是简单说明一下，在JAVA IO中用了很多增强 如：FileRead中read()方法 只是一个一个字节去读，为了读得更快在BufferedReader就增强了read()方法而产生了reandLine()一行一行的去读

有人说没必要那么麻烦：你只要拿superPerson继承person 在覆写person的chiFan()方法不就行了？

装饰是构造函数参数传递进行增强

如果为了某个功能而产生子类（继承）那么那个体系是非常臃肿的

 

例如：你有个对象有个功能 是在N年前建立的，如今你觉得功能不够用了 写个类把对象传进来就可以解决问题了 如果这个功能写错了 我就把自己写的功能去掉又不影响以前的功能灵活性相当强的。

 

装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。

C.简单工厂设计模式

l  简单工厂模式概述

•    又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例

l  优点

•    客户端不需要在负责对象的创建，从而明确了各个类的职责

l  缺点

•    这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护

Animal抽象类：

package com.core.module.demo;

public abstract class Animal {
	abstract void eat();
}

Cat类：

package com.core.module.demo;

public class Cat extends Animal {

	@Override
	void eat() {
		System.out.println("猫吃鱼");
	}

}

Dog类：

package com.core.module.demo;

public class Dog extends Animal {

	@Override
	void eat() {
		System.out.println("狗吃骨头");
	}

}

工厂类：

package com.core.module.demo;

public class AnimalFactory {
	//私有化构造方法
	private AnimalFactory() {
	}
	
	public static Animal createDog(){
		return new Dog();
	}
	public static Animal createCat(){
		return new Cat();
	}
	
//	工厂改进
	public static Animal createAnimal(String type){
		if("dog".equals(type)){
			return new Dog();
		}else if("cat".equals(type)){
			return new Cat();
		}else{
			return null;
		}
	}
}

测试类：

package com.core.module.demo;

public class Test {

	public static void main(String[] args) {
		// 基本的方式
		Dog dog = new Dog();
		Cat cat = new Cat();
		dog.eat();
		cat.eat();

		// 使用工厂类
		System.out.println("--------");
		
		Animal dog2 = AnimalFactory.createDog();
		Animal cat2 = AnimalFactory.createCat();
		dog2.eat();
		cat2.eat();
		
		//工厂改进之后
		System.out.println("--------");
		Animal dog3 = AnimalFactory.createAnimal("dog");
		Animal cat3 = AnimalFactory.createAnimal("cat");
		dog3.eat();
		cat3.eat();
	}

}

D.工厂方法设计模式

l工厂方法模式概述

•工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。

l优点

•客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性

l缺点

•需要额外的编写代码，增加了工作量

l

动物抽象类：publicabstract Animal { public abstract void eat(); }

工厂接口：publicinterface Factory {public abstract AnimalcreateAnimal();}

具体狗类：publicclass Dog extends Animal {}

具体猫类：publicclass Cat extends Animal {}

开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。发现每次修改代码太麻烦，用工厂方法改进，针对每一个具体的实现提供一个具体工厂。

狗工厂：publicclassDogFactoryimplements Factory {

  public Animal createAnimal(){…}

        }

猫工厂：publicclassCatFactoryimplements Factory {

  public Animal createAnimal(){…}

        }

工厂类：

package com.core.module.demo2;

public interface Factory {
	public abstract Animal createAnimal();
}

狗工厂：

package com.core.module.demo2;

public class DogFactory implements Factory {

	@Override
	public Animal createAnimal() {
		return new Dog();
	}

}

猫工厂：

package com.core.module.demo2;

public class CatFactory implements Factory {

	@Override
	public Animal createAnimal() {
		return new Cat();
	}

}

测试类：

package com.core.module.demo2;

public class Test {

	public static void main(String[] args) {
		CatFactory catFactory = new CatFactory();
		Animal cat = catFactory.createAnimal();
		cat.eat();
		
		DogFactory dogFactory = new DogFactory();
		Animal dog = dogFactory.createAnimal();
		dog.eat();
	}

}

E.单例设计模式

单例模式就是要确保类在内存中只有一个对象，该实例必须自动创建，并且对外提供。

优点：

在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。

缺点：

没有抽象层，因此扩展很难。

职责过重，在一定程度上违背了单一职责。

1.饿汉式

package com.core.module.demo3;

//饿汉式
public class Student {
	// 私有化构造函数
	private Student() {
	}
	//创建一个Student对象
	private static Student s = new Student();
	//对外提供一个获取对象方法
	public static Student getStudent(){
		return s;
	}
}

测试类：

package com.core.module.demo3;

public class Test {

	public static void main(String[] args) {
		Student s1 = Student.getStudent();
		Student s2= Student.getStudent();
		System.out.println(s1==s2);//true
	}

}

2.懒汉式

package com.core.module.demo4;

//懒汉式
public class Student {
	// 私有化构造函数
	private Student() {
	}

	// 创建一个Student对象
	private static Student s = null;

	// 对外提供一个获取对象方法
	public static Student getStudent() {
		if(s==null){
			s = new Student();
		}
		return s;
	}
}

注意：懒汉式存在线程安全问题,

package com.core.module.demo4;

//懒汉式
public class Student {
	// 私有化构造函数
	private Student() {
	}

	// 创建一个Student对象
	private static Student s = null;

	// 对外提供一个获取对象方法
	//解决线程安全问题，同步方法
	public synchronized static Student getStudent() {
		if(s==null){
			s = new Student();
		}
		return s;
	}
}

F.单例模式的Java代码体现Runtime类

package com.core.module.demo5;

import java.io.IOException;

/*
 * Runtime：每个Java应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接。
 * exec(String command)
 */
public class RunTimeDemo {

	public static void main(String[] args) throws IOException {
		Runtime r = Runtime.getRuntime();
		r.exec("calc");
		r.exec("notepad");
	}

}

/*public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    public static Runtime getRuntime() {
        return currentRuntime;
    }

    private Runtime() {}
}*/

2.懒汉式