/**
* type: 上等人、中等人、下等人.....
*/
static User getUser(String type){
User resultUser = null;
if(type==null&&"".equal(type)){
throw new NullException("type is not null");
}
switch(type){
case '上等人':
resultUser = new User("上等人");
break;
case '中等人':
resultUser = new User("中等人");
break;
default:
resultUser = new User("普通人");
}
return resultUser;
}
抽象工厂模式
将简单方法模式中的 switch case 分开，同时只需要在使用的地方修改类的类型即可
将 switch case 放到调用方。
class A{
void method(){
sout("买A数据")
}
void method2(){
sout("卖A数据")
}
}
class B{
void method(){
sout("买B数据")
}
void method2(){
sout("卖B数据")
}
}
class AB{
A a;
B b;
public AB(A a,B b){
this.a = a;
this.b = b;
}
void methodBuy(){
a.method();
b.method();
}
void methodSell(){
a.method2();
b.method2();
}
}
/**
*如果不这样写的情况下 需要分别去调用a和b的买卖接口
*更简化了A B 类的使用
*/
建造者模式
如果需要生成的类很复杂，需要多个组件进行配合以防遗漏。
class Builder{
//客户端需要调用此方法来获取建造者最终创建出来的对象
public Product Builder(BuilerTemplete p){
p.methodMain();//构建
p.getResult();//获取结果
}
}
abstract class BuilerTemplete{
public Project DEFA
//持有构建类
public Product p ;
public BuilerTemplete(Product p){
this.p=p;
}
public void methodMain(){
//构建基本需要执行的统一方法
method1();
method2();
method3()
}
//构建需要的内容 方法
public abstrct void method1();
public abstrct void method2();
public abstrct void method3();
public Product getResult(){
retrun p;
}
}
class BuilderTempleteA extends BuilerTemplete{
//这些方法都是抽象方法必须时间。为以防忘记实现
public abstrct void method1(){对 p做操作}
public abstrct void method2(){对 p做操作}
public abstrct void method3(){对 p做操作}
}
观察者模式
使用场景 1 如果 A 类中的变化需要通知，或者需要修改一系列类的内容时。则可用此模式
2 在不同的通知过程中可以在 notify 中添加一个 Eventhandler 类似于 call back 的方式将需要
通知观察者的方式换成接口。
interface EventHandler{
void excutor();
}
/**通过接口来定义观察者的执行行为的好处是，在 add *的时候将每个不同的实体类想执行的方法自己去定义，通提供统一接口。 如
*/
class Subject{
List<EventHandler> list = new ArrayList<EventHandler>();
public void add(EventHandler e){
list.add(e);
}
public void notify(){
list.foreach(EventHandler::excutor);
}
}
class Client{
public static void main(String[] args){
see = new see
//这样就可以让观察者自己定义自己想执行的方法
subject.add(()->{see.call});
look = new look
subject.add(()->{look.look});
}
}
状态模式
状态模式 是将繁琐的if eles 以一个 state 状态类来获取if else 的结果。只需要获取state 的状态就可以了。 且 state
类相当月一个抽象接口类，在 state 中的实现类发生变化后，客户段这边是无感的，同时解决了
复杂的判断结构体
适配器模式
其实说白了就是将类封装在接口中，向外暴露出接口，让当前类有两个的接口功能，
使用范围
在 A B 两个类设计完好之后在不改动原有类的基础上,抽象出来一个借口，来将两个类
需要使用的接口进行抽象化
/**当前需要调用的类，却没有 B 类的方法的功能。
* 1 简单的方法，将 B 类中的方法实现一遍
* 2 将 A 类中的持有 B 类的引用同时在 A 类中定义 B 类的同名方法
* 3 将 A B 类中需要调用的方法进行抽象出接口，同时实现接口类
* C 这样就可以在调用的时候就能将 C 类进行方法的扩充或修改，
* 符合扩展开放，修改封闭原则，
* 好处是将 A 类和 B 类之间没有代码耦合，同时在一定成度上将 A B 联系在了一起
*/
class A {
public void method(){
}
}
class B {
public void method(){
}
}
abstract class C{
public void methodA(){
}
public void methodA(){
}
}
class C extends C{
public void methodA(){
}
public void methodA(){
}
}
备忘录模式
将类的状态属性进行保存，在类想要恢复到上一个记录的时候可以进行恢复。
class A
{
private String state;
private int version;
public void createMo(){
memory.setMemory(this,new MemoryVersion(version++,state));
}
//根据版本来进行回归状态
public void reset(int version){
memory.getMemory(this).version;
}
//作为匿名内部类存在
class MemoryVersion implements MeomeryModel{
pirvate Integer version;
private String state;
public MemoryVersion(Integer version,String state){
this.version = version;
this.state = state;
}
set{version,state}
get{version,state}
}
}
interface MemoryModel{
int version();
String state();
}
final class memory{
//缓存所有的state
private static Map<Class,MemoryModel> memory = new HashMap<>();
public static void getMemory(Class clazz,int version){
if(Clazz==null){
throw new NullPointException("this clazz Class is null ");
}
return memory.get(clazz);
}
}
//中介者
interface A {
void send (String message,Class name)
}
class B implements A{
private College
}
//抽象 公用类
abstract class College{
//每个类都有共同的中介
private A a;
public College(A a){
this.a = a;
}
}
//实际类
class collegeA extends College{
public CollegeA(A a){
super(a);
}
public void send(){
}
}