黑马程序员--初识设计模式

------- android培训 、 java培训 、期待与您交流！ ----------

/*单例设计模式
	1.什么是单例设计模式
		如果希望一个类在整个程序中只能有一个对象, 就可以使用单例设计模式
	2.单例设计模式的写法
		私有化构造函数, 阻止类外创建对象
		类内部创建一个对象, 使用成员变量引用. 为了只创建一次用static修饰, 在类加载后初始化. 加上private防止类外修改.
		提供一个get方法获取对象, 为了让类外直接使用加上static
*/

//单例设计模式代码展示：

class SingletonDemo {
	
	public static void main(String[] args) {
		Sun sun1 = Sun.getSun();
		Sun sun2 = Sun.getSun();
		
		System.out.println(sun1);
		System.out.println(sun2);
	}	
	
}

// 如果希望一个类在程序中只能有一个对象时, 就可以使用单例设计模式
class Sun {	
	private static Sun sun = new Sun();		// 2.类内部创建一个对象, 使用成员变量引用. 用static修饰在类加载后初始化. 防止类外修改加上private
	
	private Sun() {							// 1.私有化构造函数, 阻止类外创建对象
	}
	
	public static Sun getSun() {			// 3.提供一个get方法获取对象, 为了让类外直接使用加上static
		return sun;	
	}
	
	// ... 
	
	// ... 
}







/*组合设计模式
	1.什么是组合设计模式
		当定义一个类需要另一个类的方法时, 就可以使用组合设计模式.
	2.组合设计模式的写法
		定义成员变量, 用来引用被组合的对象     
		构造函数接收一个被组合的对象, 用成员变量引用		
		在需要使用被组合类的方法时, 通过成员变量调用被组合对象的方法
	3.组合设计模式和继承的区别
		有时两个类没有逻辑上的父子关系, 不适合用继承. 
		Java只支持单继承, 组合不占用继承的位置.
		如果使用继承, 子类可以当作父类使用, 支持了多态.
	4.什么时候用组合, 什么时候用继承
		在定义类需要使用另一个类的方法时, 这两种方式都可以实现
		如果定义的类要当作另一类使用, 那么必须用继承
		如果不需要当作父类使用, 建议使用组合
*/

//组合设计模式代码展示：

class CompositeDemo {
	
	public static void main(String[] args) {
		Card c = new Card();
		c.save(6000);
		
		Person p = new Person(c);
		p.shopping();
		p.eat();
		
		System.out.println("卡里还剩: " + c.getBalance());
	}	
	
}

class Person {
	private Card card;			// 1.定义成员变量, 用来引用被组合的对象
	
	public Person(Card card) {	// 2.构造函数接收一个被组合的对象, 用成员变量引用
		this.card = card;
	}
	
	public void shopping() {
		card.spend(5000);		// 3.通过成员变量调用被组合对象的方法
		System.out.println("买了一台iPhone5");
	}	
	
	public void eat() {
		card.spend(500);
		System.out.println("吃了一顿全聚德");	
	}
}

class Card {
	private int balance;				// 卡的余额
	
	public void spend(int amount) {		// 刷卡消费, amount为金额
		System.out.println("刷卡消费, 花了" + amount + "元");
		balance -= amount;
	}
	
	public void save(int amount) {
		balance += amount;
	}
	
	public int getBalance() {
		return balance;	
	}
}

class CreditCard extends Card {	
}







/*模板设计模式
	1.什么时候使用模板设计模式
		在编程的过程中, 如果经常做一些重复的操作, 就可以使用模板设计模式, 将重复的代码定义在模板中
	2.怎么使用模板设计模式
		定义抽象类, 其中定义一个抽象方法, 用来代表每次不同的代码
		定义模板方法, 将每次不变的代码写在方法中, 不同的代码通过调用抽象方法实现. 模板方法为了防止子类修改, 声明为final.
		使用的时候, 继承抽象类, 重写抽象方法, 写入每次不同的代码
*/

//模板设计模式代码展示：

class TemplateDemo {
	
	public static void main(String[] args) {
		new Test1().test();
	}	
	
}

abstract class Template {		
	
	public final void test() {								// 2.定义模板方法, 将每次不变的代码写在方法中, 不同的代码通过调用抽象方法实现
		long start = System.currentTimeMillis();
		dosomething();										
		long stop = System.currentTimeMillis();
		System.out.println("使用了: " + (stop - start) + "毫秒");
	}
	
	public abstract void dosomething();						// 1.定义一个抽象方法, 用来代表每次不同的代码
	
}

class Test1 extends Template {								// 3.使用的时候, 继承抽象类, 重写抽象方法, 写入每次不同的代码
	public void dosomething() {
		for (int i = 0; i < 1000; i++)	
			System.out.println(i);
	}
}

class Test2 extends Template {
	public void dosomething() {
		for (int i = 0; i < 100000000; i++)	
			;
	}
}



/*包装设计模式
	1.通过构造函数接收一个被包装的对象, 用成员变量引用被包装的对象
	2.声明和被包装类相同的方法
	3.在方法中调用被包装对象的方法, 对其增强
	4.和被包装类实现相同的接口, 或者继承相同的父类. 包装类就可以和被包装类一样使用了
	
*/
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class DecoratorDemo {

	public static void main(String[] args) throws IOException {
		Coder c = new ItcastStudent(new Student());
		c.code();
		
		FileInputStream fis = new FileInputStream("file.txt");		// 被包装的对象, 读文件的功能就在这个类中
		fis.read();
		
		BufferedInputStream bis = new BufferedInputStream(fis);		// 包装类, 使用FileInputStream读文件的功能, 添加了缓冲的功能
		bis.read();
		
		InputStreamReader isr = new InputStreamReader(fis);			// 包装类, 使用FileInputStream读文件的功能, 添加了转为字符的功能
		isr.read();
		
		BufferedReader br = new BufferedReader(isr);				// 包装类, 使用InputStreamReader读字符的功能, 添加了缓冲和读一行的功能
		br.read();
	}

}

interface Coder {	// 程序员, 必须会编程
	void code();
}

class Student implements Coder {		// 普通的计算机系学生
	public void code() {
		System.out.println("JavaSE");
		System.out.println("JavaWeb");
	}
}

class ItcastStudent implements Coder {			// 4.和被包装类实现相同的接口, 或者继承相同的父类. 包装类就可以和被包装类一样使用了
	private Student student;

	public ItcastStudent(Student student) {		// 1.通过构造函数接收一个被包装的对象, 用成员变量引用被包装的对象
		this.student = student;					
	}	
	
	public void code() {						// 2.声明和被包装类相同的方法
		student.code();							// 3.在方法中调用被包装对象的方法, 对其增强
		System.out.println("JBPM");
		System.out.println("Hibernate");
		System.out.println("Sprint");
		System.out.println("Struts");
		System.out.println("Hadoop");
		System.out.println("JNI");
		System.out.println("OpenGL");
		System.out.println("Android");
	}
}

　------- android培训、 java培训、期待与您交流！ ---------- 　　详细请查看： http://edu.csdn.net/heima/