1, 简单工厂模式, 工厂模式与抽象工厂模式
- public interface Human {
- public void say();
- }
- class Man implements Human {
- public void say() {
- System.out.println("男人");
- }
- }
- class Woman implements Human {
- public void say() {
- System.out.println("女人");
- }
- }
简单工厂模式: 简单来说 , 在工厂类中添加判断方法返回对应的类;
缺点 违背开放封闭原则, 需要经常修改工厂类
- class SampleFactory {
- public static Human makeHuman(String type){
- if(type.equals("man")){
- return new Man();
- }else if(type.equals("womman")){
- return new Woman();
- }
- }
- }
工厂模式: 将逻辑判断拿到客户端执行
- interface Factory {
- public Human crateMan();
- }
- class ManFactory implements Factory{
- public Human crateMan() {
- return new Man();
- }
- }
- class WomanFactory implements Factory{
- public Human crateMan() {
- return new Woman();
- }
- }
- class NormalFatory{
- public static void main(String[] args) {
- Factory factory=new ManFactory();
- Human man2=factory.crateMan();
- man2.say();
- }
- }
抽象工厂模式: 因为实际业务中, 通过客户端添加逻辑代码非常长, 而且不容易修改. 现在可以用子类抽象工厂来组装分离不同的业务.
- interface Car {
- void gotowork();
- }
- class Bus implements Car {
- public void gotowork() {
- System.out.println("坐公交车去上班!");
- }
- }
- class Train implements Car {
- public void gotowork() {
- System.out.println("坐火车去上班!");
- }
- }
- interface AbstractFactory {
- Human getHuman();
- Car getCar(); }
- class ManFactory implements IAbstractFactory {
- public Car getCar() {
- return new Bus();
- }
- public Human getHuman() {
- return new Man();
- }
- }
- class WomanFactory implements IAbstractFactory {
- public Car getCar() {
- return new Train();
- }
- public Human getHuman() {
- return new Woman();
- }
- }
- class AbstractFactoryTest{
- public static void main(String[] args) {
- IAbstractFactory factory = new ManFactory();
- Car car = factory.getCar();
- Human human = factory.getHuman();
- human.say();
- car.gotowork();
- IAbstractFactory factory2 = new ManFactory();
- car = factory2.getCar();
- human = factory.getHuman();
- human.say();
- car.gotowork();
- } }
2 , 策略模式: 上面 1 所述的模式我们发现 工厂中主要嵌套方法, 如果嵌套的是属性, 就是策略模式.
- class Strategy{
- Human human;
- Strategy(Human human){
- this.human = human;
- }
- public void doExec1(){
- human.say();
- /* 一般这里都是和工厂模式一样添加逻辑判断 */
- }
- }
3, 代理模式 : 我的理解代理就是对象的引用访问控制; 相当于是策略模式的延伸. 通过 Proxy 访问对象
- class Proxy{
- Woman woman;
- Proxy(Woman woman){
- this.woman = woman;
- }
- public void doExec1(){
- woman.say();
- }
- }
4, 原型模式 : 这里涉及一个深拷贝和浅拷贝的概念.
1浅克隆 浅复制仅仅复制所考虑的对象, 而不复制它所引用的对象. Object 类提供的方法 clone 只是拷贝本对象, 其对象内部的数组, 引用对象等都不拷贝, 还是指向原生对象的内部元素地址
2深克隆 深复制把要复制的对象所引用的对象都复制了一遍, 在 jvm 中新建个对象.
浅克隆, 部分对象未实现 Cloneable 接口
深克隆, 所有对象都实现 Cloneable 接口重写 clone() 或者通过流序列化如下所示
在所有涉及的类都实现 Serializable 接口
- Object deepClone() throws IOException, ClassNotFoundException{
- // 将对象写到流里
- ByteArrayOutputStream bos = new ByteArrayOutputStream();
- ObjectOutputStream oos = new ObjectOutputStream(bos);
- oos.writeObject(this);
- // 从流里读回来
- ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
- ObjectInputStream ois = new ObjectInputStream(bis);
- return ois.readObject();
- }
简单来说, Man man =new Man() 就是创建一个原型, Man man1 = man.clone(); 这里就是浅客隆
5, 模版模式 定义一套模版, 子类在模版的结构中添加不同的逻辑. 我们对工厂模式的案例重写下
- abstract class Human{
- public void say();
- public void action();
- template(){
- this.say();
- this.action();
- }
- }
- class Man implements Human {
- public void say() {
- System.out.println("男人");
- }
- public void action(){
- System.out.println("玩游戏");
- }
- }
- class Woman implements Human {
- public void say() {
- System.out.println("女人");
- }
- public void action(){
- System.out.println("贴面膜");
- }
- }
客户端
- public static void main(String[] args) {
- Human human;
- human = new Man();
- human.template();
- human = new Woman();
- human.template();
- }
6, 外观模式 我的理解就是对 类方法的不同组合
- class Facade{
- Man man;
- Woman woman;
- // A 组合
- public methodA(){
- man.say();
- woman.action();
- }
- //B 组合
- public methodB(){
- man.say();
- woman.say();
- }
- }
7, 建造者模式 这个模式 与外观模式好像, 这不过外观模式 多用于不同对象的方法组合. 建造者模式是一种 类由多个方法组合
- class Director{
- // 这个方法内部是固定的, 就像做好菜的秘方一样
- public void group(Human human){
- human.say();
- huamn.action();
- ...//say 方法建造过程中可以放前, 也可以放 action 后.
- }
- }
时间有限, 篇幅有点长了, 下篇再写. 以上只是一个识别设计模式的简单案例, 实际代码中可能会有三四种模式的复合或者更多复合. 可能因为个人的理解和角度不同, 如果觉得有问题, 请留言.
来源: https://www.cnblogs.com/nicknailo/p/9816754.html