设计模式
设计模式:解决某一类问题最行之有效的方法,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三层开发结构图