设计模式

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

设计模式

设计模式：解决某一类问题最行之有效的方法,JAVA中有23种设计模式

 

单例设计模式

单例设计模式：解决一个类在内存中只存在一个对象。

思路：

1，为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。

2，为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。

3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

步骤：

1，将构造函数私有化

2，在类中创建一个本类对象

3，提供一个方法可以获取到该对象

饿汉式(实际开发)

这个是先初始化对象。

single类一进内存，就已经存在对象。

class Single {
	private static final Single s = new Single();
	
	private Single() {
	}
	public static Single getInstance() {
		return s;
	}
}
class SingleTest {
	public static void main(String[] args) {
		Single s = Single.getInstance();
	}
}

定义单例，建议使用饿汉式

 

单例设计模式示意图

懒汉式(面试)

对象是方法被调用时，才初始化也叫做对象的延时加载。

Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。

class Single {
	private static Single s = null;

	private Single() {
	}
	public static Single getInstance() {
		if (s == null) {
			synchronized (Single.class) {
				if (s == null)
					s = new Single();
			}
		}
		return s;
	}
}

懒汉式和恶汉式的区别：

懒汉式特点在于实例的延时加载

懒汉式的延时加载有没有问题，怎么解决：

有，当有多个线程访问时，会有安全隐患，可以用同步函数或同步代码块来解决，同步函数效率较低，建议使用同步代码块加双重判断解决问题。

加同步时使用的锁是哪个：

该类所属的字节码文件。

写一个延时加载的单例设计模式示例：代码示例如上。

 

模版方法模式

在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分。那么这时就将不确定的部分暴露出去，由该类的子类去完成。

示例代码：

abstract class GetTime {
	public final void getTime()//确定的方法
	{
		long start = System.currentTimeMillis();
		runcode();
		long end = System.currentTimeMillis();
		System.out.print("毫秒：" + (end - start));
	}
	public abstract void runcode();//不确定的方法
}
class SubTime extends GetTime {
	public void runcode()
	{
		for (int x = 0; x < 4000; x++) {
			System.out.print(x);
		}
	}
}

 

装饰设计模式

当想要对已有的对象进行功能增强时，可以自定义一个类，将已有的对象传入，基于已有的功能，提供加强的功能，那么这个自定义的类称为装饰类，这种设计模式，就是装饰设计模式。

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

MyReader (专门用于读取数据的类)

     |——MyTextReader

                |——MyBufferTextReader

     |——MyMediaReader

                |——MyBufferMediaReader

     |——MyDataReader

                |——MyBufferDataReader

class MyBufferReader

{    

        MyBufferReader(MyTextReader text)

        {}

        MyBufferReader(MyMediaReader media)

        {}

}

上面这个类扩展性很差。

找到其参数的共同类型，通过多态的形式，可以提高扩展性。

class MyBufferReader extends MyReader

{

        private MyReader  r;

        MyBufferReader(MyReader r)

        {}

}

通过装饰设计模式进行优化后产生的新体系：

MyReader (专门用于读取数据的类)

     |——MyTextReader

     |——MyMediaReader

     |——MyDataReader

     |——MyBufferReader

装饰类与继承的区别：

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

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

装饰类示例：

class MyBufferReader extends Reader {
	private Reader r;
	MyBufferReader(Reader r) {
		this.r = r;
	}
	public String myReadLine() throws IOException {
		StringBuilder sb = new StringBuilder();
		int ch = 0;
		while ((ch = r.read()) != -1) {
			if (ch == '\r')
				continue;
			if (ch == '\n')
				return sb.toString();
			else
				sb.append((char) ch);
		}
		if (sb.length() != 0)
			return sb.toString();
		return null;
	}
	public int read(char[] cbuf, int off, int len) throws IOException {
		return r.read(cbuf, off, len);
	}
	public void close() throws IOException {
		r.close();
	}
}
class MyLineNumberReader extends MyBufferReader {
	private int LineNumber;

	MyLineNumberReader(Reader r) {
		super(r);
	}
	public int getLineNumber() {
		return LineNumber;
	}
	public void setLineNumber(int LineNumber) {
		this.LineNumber = LineNumber;
	}
	public String MyReadLine() throws IOException {
		LineNumber++;
		return super.myReadLine();
	}
}
class MyBufferReaderDemo {
	public static void main(String[] args) throws IOException {
		FileReader fr = new FileReader("111.java");
		MyLineNumberReader mlnr = new MyLineNumberReader(fr);

		String line = null;
		while ((line = mlnr.MyReadLine()) != null) {
			System.out.println(mlnr.getLineNumber() + ":  " + line);
		}
		mlnr.close();
	}
}

MVC设计模式

 

MVC模式示意图

 

 

MVC三层开发结构图