java-设计模式

设计模式分为三类公23种：

1. 创建型模式：单例模式、简单工厂模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。
2.结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
4.行为型模式：模版方法模式、命令模式、迭代器模式、观察者模式、备忘录模式、解释器模式（Interpreter模式）、状态模式、策略模式、职责链模式(责任链模式)、访问者模式。

1.单列模式

/**
 * 饿汉设计模式
 * @author xinchunyu
 * @CreateTime: 2019年9月23日 下午2:16:11 
 * @version V1.0
 */
public class Student {
    //私有化构造函数  让外界不能创建对象
    private Student(){
      
    }
    private static Student instance = new Student();
    
    public static Student getInstance(){
        return instance;
    }
}

/**
 * 懒汉模式
 * @author xinchunyu
 * @CreateTime: 2019年9月23日 下午2:20:43 
 * @version V1.0
 */
public class Person {
    //私有化构造函数
    private Person(){
        
    }
    
    private static Person person = null;
    //为了解决安全问题加了同步
    public synchronized static Person getInstance(){
        if(person == null){
            person = new Person();
        }
        return person;
    }
}

2.简单工厂模式

public abstract class Animal {
    public abstract void eat();
}
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
/**
 * 简单工厂
 * @author xinchunyu
 * @CreateTime: 2019年9月23日 下午2:44:15 
 * @version V1.0
 */
public class AnimalFactory {
    public AnimalFactory(){
        
    }
    //创建对象
    public static Animal createAnimal(String name){
        if("dog".equals(name)){
            return new Dog();
        }else if("cat".equals(name)){
            return new Cat();
        }
        return null;
    }
}

/**
 * 演示
 * @author xinchunyu
 * @CreateTime: 2019年9月23日 下午2:52:43 
 * @version V1.0
 */
public class AnimalDemo {
   public static void main(String[] args) {
    Dog dog = (Dog)AnimalFactory.createAnimal("dog");
    dog.eat();
    
    Cat cat = (Cat)AnimalFactory.createAnimal("cat");
    cat.eat();
    }
}

3.工厂方法模式

public abstract class Animal {
   abstract void eat();
}
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
public interface AnimalFactory {
    Animal createAnimal();
}
//工厂方法
public class CatFactory implements AnimalFactory{
    @Override
    public Animal createAnimal() {
        return new Cat();
    }
}
//工厂方法
public class DogFactory implements AnimalFactory {
    @Override
    public Animal createAnimal() {
        return new Dog();
    }
}

4.抽象工厂模式

//电脑接口
public interface Computer {
  void sellMoney();
}
//手机接口
public interface Phone {
   void sellNum();
}
//苹果的电脑实现类
public class AppleComputer implements Computer {
    @Override
    public void sellMoney() {
        System.out.println("苹果电脑买10000元");
    }
}
//苹果的手机实现类
public class ApplePhone implements Phone {
    @Override
    public void sellNum() {
    System.out.println("苹果手机本月销量500万台");
    }
}
//小米电脑接口实现类
public class XiaomiComputer implements Computer {
    @Override
    public void sellMoney() {
      System.out.println("小米电脑卖4999");
    }
}
//小米手机实现类
public class XiaomiPhone implements Phone {
    @Override
    public void sellNum() {
        System.out.println("小米本月卖了1000万台");
    }
}

//工厂接口
public interface Factory {
   Phone createPhone();
   Computer createComputer();
}
// apple电脑和手机的工厂实现类
public class AppleFactory implements Factory {

    @Override
    public Phone createPhone() {
        return new ApplePhone();
    }
    @Override
    public Computer createComputer() {
        return new AppleComputer();
    }
}
//小米工厂实现类
public class XiaomiFactory implements Factory {

    @Override
    public Phone createPhone() {
        return new XiaomiPhone();
    }
    @Override
    public Computer createComputer() {
        return new XiaomiComputer();
    }
}
//演示类
public class Demo {

    public static void main(String[] args) {
        XiaomiFactory xf = new XiaomiFactory();
        XiaomiComputer xc = (XiaomiComputer) xf.createComputer();
        XiaomiPhone xp = (XiaomiPhone) xf.createPhone();
        xc.sellMoney();
        xp.sellNum();

        AppleFactory af = new AppleFactory();
        AppleComputer ac = (AppleComputer) af.createComputer();
        ApplePhone ap = (ApplePhone) af.createPhone();
        ac.sellMoney();
        ap.sellNum();
    }
}

适配器模式

//方法接口
public interface UserDao {
     
    void add();
    void update();
    void delete();
    void query();
}
//适配器模式     通过实现空方法为了让UserDaoImpl 可以选择性的重写方法
public class UserAdapter implements UserDao {

    @Override
    public void add() {
    }
    @Override
    public void update() {
    }
    @Override
    public void delete() {
    }
    @Override
    public void query() {
    }
}
public class UserDaoImpl extends UserAdapter {
    @Override
    public void add() {
        System.out.println("执行了增加操作");
    }
}
//演示
public class UserDemo {

    public static void main(String[] args) {
        UserDaoImpl userDaoImpl = new UserDaoImpl();
        userDaoImpl.add();
    }
}

1.装饰者模式
装饰者模式定义：在不改变原有对象的基础上附加功能，相比生成子类更灵活。
适用场景：动态的给一个对象添加或者撤销功能。
优点：可以不改变原有对象的情况下动态扩展功能，可以使扩展的多个功能按想要的顺序执行，以实现不同效果。
缺点：更多的类，使程序复杂
类型：结构型。

/**
 * User 抽象组件
 * UserImpl 具体实现
 * Decorator 抽象装饰者
 * SeeDecorator 具体装饰者
 * DrinkDecorator 具体装饰者
 */
//最高层抽象类
public interface User {
    void doEat();
}
//具体实现类
public class UserImpl implements User {
    @Override
    public void doEat() {
        System.out.println("正在吃着饭");
    }
}
//装饰抽象类
public abstract class Decorator implements User{
    //很重要,组合抽象构件到自己的类中
    private User user;
    
    public Decorator(User user){
        this.user = user;
    }
    @Override
    public void doEat(){
        this.user.doEat();
    };
}
//装饰具体类
public class DrinkDecorator extends Decorator{
    public DrinkDecorator(User user) {
        super(user);
    }
    @Override
    public void doEat() {
        super.doEat();
        System.out.println("还喝着水");
    }
}
//装饰具体类
public class SeeDecorator extends Decorator {
    public SeeDecorator(User user) {
        super(user);
    }
    @Override
    public void doEat() {
        super.doEat();
        System.out.println("还看着电视");
    }
}

模板模式
定义：定义一个操作中的算法骨架，将一些步骤声明为抽象方法迫使子类去实现。不同的子类可以以不同的方式实现这些抽象方法
简单理解就是：将关键的业务方法、逻辑或算法封装起来，而把具体的一些容易变化的步骤留给之类来进行具体不同的设置，具体表现就是实现了父类的方法

/**
 * MyTemplate 模板抽象类
 * CustomerDaoImpl 模板子类
 * StudentDaoImpl  模板子类
 * Demo 演示类
 */
//模板抽象类
public abstract class MyTemplate {
    //骨架不让子类重写
    public final void execute(){
        start();
        //用钩子做判断
        if(flag()){
            run();
        }
        end();
    }
    //在模板方法中有一种函数叫做钩子函数，钩子函数的作用是让实现类可以通过一些方法来控制模板中的流程
    public abstract boolean flag();
    public abstract void run();
    public void start(){
        System.out.println("begin connection...");
    }
    public void end(){
        System.out.println("end connection...");
    }
}
//模板子类
public class CustomerDaoImpl extends MyTemplate {
    @Override
    public boolean flag() {
        return true;
    }
    @Override
    public void run() {
        System.out.println("操作用户数据");
    }
}
//模板子类
public class StudentDaoImpl extends MyTemplate {
    @Override
    public boolean flag() {
        return false;
    }
    @Override
    public void run() {
        System.out.println("操作学生数据");   
    }
}
//演示类
public class Demo {
    public static void main(String[] args) {
        MyTemplate t1 = new CustomerDaoImpl();
        t1.execute();
        
        MyTemplate t2 = new StudentDaoImpl();
        t2.execute();
    }
}
//结果： 
//begin connection...
//操作用户数据
//end connection...
//begin connection...
//end connection...

代理模式--静态代理

/*
 * 静态代理
 * BuyHouse 接口
 * BuyHouseImpl 接口实现类
 * BuyHouseProxy 代理类
 * Demo 演示类
 */
//接口
public interface BuyHouse {
    void doing();
}
//接口实现类
public class BuyHouseImpl implements BuyHouse {
    @Override
    public void doing() {
        System.out.println("正在买房。。。");
    }
}
//静态代理类
public class BuyHouseProxy implements BuyHouse {

    private BuyHouse buyHouse;
    
    public BuyHouseProxy(BuyHouse buyHouse){
        this.buyHouse = buyHouse;
    }
    @Override
    public void doing() {
        System.out.println("开始买房");
        this.buyHouse.doing();
        System.out.println("买房结束");
    }
}
//演示类
public class Demo {
    public static void main(String[] args) {
        BuyHouseProxy bp = new BuyHouseProxy(new BuyHouseImpl());
        bp.doing();
    }
}
//结果： 
//开始买房
//正在买房。。。
//买房结束

代理模式--jdk动态代理

/**
 * jdk利用反射动态代理
 * BuyHouse 接口
 * BuyHouseImpl 接口实现类
 * DynamicInvocationHandler 代理实现类
 * Demo 演示类
 */
//接口
public interface BuyHouse {
   void doing();
}
//接口实现类
public class BuyHouseImpl implements BuyHouse {
    @Override
    public void doing() {
        System.out.println("正在买房。。。");
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
//动态代理实现类
public class DynamicInvocationHandler implements InvocationHandler {

    private BuyHouse buyHouse;
    public DynamicInvocationHandler(BuyHouse buyHouse) {
        this.buyHouse = buyHouse;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始买房");
        Object invoke = method.invoke(buyHouse, args);
        System.out.println("买房结束");
        return invoke;
    }
}
import java.lang.reflect.Proxy;
//演示
public class Demo {
    public static void main(String[] args) {
        BuyHouse buyHouse = new BuyHouseImpl();
        DynamicInvocationHandler h = new DynamicInvocationHandler(buyHouse);
        BuyHouse b = (BuyHouse)Proxy.newProxyInstance(buyHouse.getClass().getClassLoader(), buyHouse.getClass().getInterfaces(), h);
        b.doing();
    }
}
//结果:
//开始买房
//正在买房。。。
//买房结束
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 194,242评论 5赞 459
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 81,769评论 2赞 371
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 141,484评论 0赞 319
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,133评论 1赞 263
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 61,007评论 4赞 355
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,080评论 1赞 272
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,496评论 3赞 381
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,190评论 0赞 253
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,464评论 1赞 290
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,549评论 2赞 309
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,330评论 1赞 326
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,205评论 3赞 312
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,567评论 3赞 298
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 28,889评论 0赞 17
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,160评论 1赞 250
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,475评论 2赞 341
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,650评论 2赞 335

推荐阅读更多精彩内容

  • JAVA设计模式
    面试被人问到了设计模式，发现这方面知识漏洞还非常大，所以在这里记录备忘一下。原文：https://blog.csd...
    onlyHalfSoul阅读 484评论 0赞 2
  • JAVA设计模式-HeadFirst讲解
    什么是设计模式 模式是在某情景下，针对某问题的某种解决方案。模式必然应用于一个重复出现的问题。问题包括了一个目标和...
    liaowenhao阅读 1,438评论 0赞 6
  • java设计模式23种
    极客学院-23 种设计模式 Java之美[从菜鸟到高手演变]之设计模式Java之美[从菜鸟到高手演变]之设计模式 ...
    John13阅读 2,836评论 0赞 0
  • Java设计模式简述（理论，理论，理论）
    本文说明：本文章只简单叙述设计模式，而且仅仅从理论上简单叙述，仅此而已！！！ 本文摘自网络，纯粹复制粘贴，不喜可以...
    Ling912阅读 652评论 1赞 5
  • 2018-05-05
    还没细细看花，没淋一场雨，春已去，某年一定要再江南等一场雨。“风住尘香花已尽”，好在春意都在诗词里了，多少人都只想...
    草芊芊阅读 193评论 1赞 0