设计模式，记得时刻记得解耦的重要性，要考虑以后系统的可扩展性，便于满足往后增加或删改的需求。
1.creational patterns对象的创建
2.structral patterns 类与对象的关系
3.behavioral patterns 对象之间的通信
4.j2ee特别关注表示层
一、工厂模式Factory Pattern
1.将创建实例的能力交给factory类，而不再用new();
不对客户端暴露创建对象的逻辑
2.例子：生产某种手机，先定义手机类接口，再对手机进行分类，如苹果，
三星。创建手机工厂类，在主函数中调用手机工厂类来创建对象。
//通用手机类接口
public interface phone(){}
//苹果手机类
public class Ipone implements phone{
public success(){
System.out.println("succesIphone");
}
}
//三星手机类
public clss samsung implements phone{
public success(){
System.out.println("succesSamsung");
}
}
//工厂类
public class FactoryPhone{
//static方法
public static Phone makePhone(string phoneType){
if(phoneType.equals(Iphone){
return new Iphone();
}
if(phoneType.equals(samsung){
return new samsung();
}
}
}
}
//使用工厂类对象来创建手机类的对象，不再需要直接new()
public class usePhoneFactory{
public void main(){
FactoryPhone factoryPhone = new FactoryPhone();
Phone iphone = factoryphone.makePhone(Iphone);
iphone.success();
Phone samsung = factoryphone.makePhone(samsung);
samsung.success();
}
}
//当然工厂模式也可以把工厂类抽象化，创建多个不同的具体工厂类再在主函数中调用。
public interface AbstractPhone(){//Phone,Iphone,samsung不变。
Phone makePhone();
}
二、抽象工厂模式Abstract Factory Pattern
1.和工厂模式类似，但是工厂模式只能生产手机这种产品，那么如果我们要生产另一种产品，比如电脑。多个产品簇就可以使用抽象工厂模式。
2.使用abstractFactory，因此需要有n个实体化ConcreteabstractFactory的类，我们可以在主函数调用前创建一个FactoryProducer类来封装这些实体化ConcreteAbstractFactory。
//创建一个pc类
public interface Pc(){
void makePc();
}
//创建一个mac类
public class Mac() implements Pc{
void successpc(){
System.out.println("succesMac");
}
}
创建一个notepad类
public class Notepad() implements Pc{
void successpc(){
System.out.println("succesNotepad");
}
}
//创建一个抽象工厂类
public interface AbstractFactory{
//创建手机类
Phone makePhone(String phone);
//创建pc类
Pc makePc(String pc);
}
//创建抽象工厂类的实例化,but这么写是不对的。。也不是不对，只是没有解耦，耦合度太高，我们应该分别创建具体工厂类的实体类，如：创建一个phone的工厂实体类，再创建一个pc的工厂实体类
public class Concetefactory implements AbstractFactory{
public makePhone(String phone){
if(phone.equals(iphone){
return new Iphone()
}
}
public makePc(String pc){
if(pc.equals(mac){
return new mac()
}
}
}
//创建一个pc的工厂实体类
public class ConcreteFactory implements AbstractFactory{
Phone makePhone(){
return null;
}
//实现pc对象的创建
public Pc makePc(string pc){
if(pc.equals(mac){
return new Mac();
}else if(pc.equals(notepad){
return new NotePad();
}else{
return null;
}
}
//创建一个pc的工厂实体类
public class ConcretePhone implements AbstractFactory{
//实现phone对象的创建
public Phone makePhone(String phone){
if(){
// ...懒得写了，跟ConcretePc差不多
}
}
public Pc makePc(String pc){
return null;
}
}
//创建一个FactoryProducer
public class FactoryProducer {
public static AbstractFactory chooseFactory(string factory){
if(factory.equals("pc")){
return new ConcretePc();
}
//if....手机类懒得写了
}
}
//主函数调用Concrete后的抽象工厂
public void main(){
psvm(){
FactoryProducer fp = new FactoryProducer();
AbstractFactory pcFactory = fp.chooseFactory("pc");
Pc mac = pcFactory .makePc("mac");
mac.success();
AbstractFactory phonefactory = fp.chooseFactory("phone");
Phone samsung = phoneFactory .makephone();
samsung.success();
}
}
三、单例模式Singleton Pattern
1.懒汉、饿汉、classLoader、枚举
2.枚举好简单。
public User{
//私有化User的构造方法
private user(){};
//枚举类
static emum SingleToEnum{
//创建枚举类对象Instance
Instance;
//枚举类里可以有变量，有构造方法，有getter/setter方法
private User use;
private User(){};
public void setUser(){
this.user = user;
};
public User getUser(){
return user;
}
//一个对外的getUser()的接口方法
public static User getUser(){
return SingleToEnum.Instance.getUser();
}
}
//创建一个测试类
public class Test{
psvm{
//??你在干啥，User构造函数是private的 User user = new User();
sout(User.getUser());
sout(User.getUser());//跟上边的打印结果的地址一致
sout(User.getUser()==User.getUser());//返回true
}
}
四、建造者模式Builder Pattern
https://blog.csdn.net/leikang111/article/details/123927888?spm=1001.2014.3001.5502
https://blog.csdn.net/leikang111/article/details/124107203?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165294607116781685392220%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=165294607116781685392220&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allfirst_rank_ecpm_v1~times_rank-1-124107203-null-null.142v10pc_search_result_control_group,157v4control&utm_term=%E5%BB%BA%E9%80%A0%E8%80%85%E6%A8%A1%E5%BC%8F&spm=1018.2226.3001.4187
1.首先要明白静态内部类
2.如果某个对象有多个构造参数，类的构造器或工厂中有多个参数，可以考虑使用Builder Pattern
3.如果在设计对象的时候不确定是否有多个参数，也可以考虑Builder Pattern
4.Builder Pattern和Factory Pattern的区别在于Builder会关心对象的初始化顺序和参数之间的组合关系，而Factory只关心能拿到对象。
5.构成
1）Builder(抽象建造者)
它为创建一个产品Product对象的各个部件指定抽象接口，在该接口中一般声明两个方法，一个是BuilderPartX(),如BuilderPartA、BuilderPartB等，他们用于创建对象的各个部件；另一个方法是GetResult(),他们用于返回复杂对象
2）ConcreteBuilder(具体建造者)
它实现Builder接口，实现各个部件的具体构造和装配方法，定义并明确所创建的复杂对象，还可以提供一个方法返回创建好的复杂产品对象
3）Product(产品)
它是被构建的复杂对象，包含多个组件，具体建造者创建该产品的内部表示并定义它的装配过程
4）Director(指挥者)
它负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联，可以在其Constuct()建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的构建。
6.可以如上述成员构造整个builder pattern，也可以用静态内部类省略builder和director，即直接把builder类当作buildTest静态内部类，director和product省略类
- 7.钩子方法的引入（？）
创建者模式除了逐步构建一个复杂产品对象外，还可以通过Director类来更加精细地控制产品地创建过程，例如增加一个类称为钩子方法(Hook Method)的特殊方法来控制是否调用某个BuildPartX()方法
钩子方法的返回类型通常为bool类型，方法名一般为IsXXX()，钩子方法定义在抽象建造者类中。例如可以在游戏角色的抽象建造者类ActorBuilder中定义一个方法IsBareheaded()，用于判断某个角色是否为“光头”，在ActorBuilder中为之提供一个默认实现，返回值为false。代码如下：
- 8.写一下代码
四、适配器模式Adapter Pattern
例如在windows和linux转化中，在windows文件中增加对linux系统的适配
（？）我觉得其实是增加了类
五、装饰器模式Decorator Pattern
向现有对象增加一些功能
（？）我觉得是增加了方法
六、代理模式Proxy Pattern
某对象的访问比较麻烦或比较昂贵，我们提供一个代理对象来访问这个对象
例如windows里的快捷方式
其实就是增加一个中间层，在访问实际对象的时候可以做一些控制
七、观察者模式
耦合的对象之间相互调用，当一个对象状态改变时，将会通知他的依赖对象们。
subject和observe
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
