设计模式（一）创建模式（工厂模式、建造模式、单例模式）

创建模式是创建对象
结构模式是组合对象
行为模式是模块和模块之间发生行为


工厂模式（面向接口编程）Spring
class Action{
public void callDao(){
ICustomerDao cdao = DaoFactory.getDao("Customer");
cdao.login();
}
}
class DaoFactory{
public static ICustomerDao getDao(String daoName){
if(daoName.equals("Customer")){
//准备工作
return new CustmoerDao();
}else if(/*...*/){}
return null;
}
}
interface ICustomerDao{
public abstract void login();
}
class CustomerDao implements ICustomerDao{
public void login(){
System.out.println("");
}
}


改进：
class Action{
public void callDao(){
ICustomerDao cdao = (ICustomerDao)DaoFactory.getDao("Customer");
cdao.login();
}
}
class DaoFactory{
public static Object getDao(String daoName){
String className;//根据配置文件配置
return Class.forName(className).newInstance();
}
}------------------------配置文件
interface ICustomerDao{
public abstract void login();
}
class CustomerDao implements ICustomerDao{
public void login(){
System.out.println("");
}
}
================================================================================
建造模式
class Builder implements IBuilder{
public Panel getPanel1(){
Panel p1 = null;
return p1;
}
public Panel getPanel2(){
Panel p2 = null;
return p2;
}
}
interface IBuilder{
public abstract Panel getPanel1();
public abstract Panel getPanel2();
}
class Director{
private IBuilder builder;
public Director(IBuilder builder){
this.builder = builder;
}
public void contruct(){
Panel p1 = builder.getPanel1();
Panel p2 = builder.getPanel2();
}
}
==================================================================================
单例模式
适合重复公共，减少内存（Spring Hibernate）
原始模式
class FileOpen{
public FileOpen(){
System.out.println("");
}
//如果用静态函数，直接写FileOpen.createFile那么下面的调用就不会自动调用构造函数
public void createFile(){
System.out.println("");
}
}
public class Singleton1{
public static void main(String[] args){
FileOpen fo1 = new FileOpen();
io1.createFile();
//1000行,后需要记住fo1
FileOpen fo2 = fo1;
fo2.createFile();
}
}
所以改成单例模式(一)
class FileOpen{
public static FileOpen fo = new FileOpen();
public static FileOpen getInstance(){
return fo;
}
private FileOpen(){
System.out.println("");
}
//如果用静态函数，直接写FileOpen.createFile那么下面的调用就不会自动调用构造函数
public void createFile(){
System.out.println("");
}
}


public class Singleton1{
public static void main(String[] args){
FileOpen fo1 = FileOpen.getInstance();
fo1.createFile();
//1000行,后需要记住fo1
FileOpen fo2 = FileOpen.getInstance();
fo2.createFile();
}
}
所以改成单例模式(二)
class FileOpen{
public static FileOpen fo = null;
//增加线程同步防止线程安全问题
public static synchronized FileOpen syn getInstance(){
if(fo=null){
fo = new FileOpen();
}
return fo;
}
private FileOpen(){
System.out.println("");
}
//如果用静态函数，直接写FileOpen.createFile那么下面的调用就不会自动调用构造函数
public void createFile(){
System.out.println("");
}
}


public class Singleton1{
public static void main(String[] args){
FileOpen fo1 = FileOpen.getInstance();
fo1.createFile();
//1000行,后需要记住fo1
FileOpen fo2 = FileOpen.getInstance();
fo2.createFile();
}
}