设计模式

Java常见的设计模式（23种）

设计模式可以分为三大类：

创建型模式（5种）：工厂模式、抽象工厂模式、单例模式、建设者模式、
结构性模式（7种）：代理模式、适配器模式、装饰者模式、桥接模式等......
行为型模式（11种）：策略模式、观察者模式、迭代模式......

单例模式

一个类只能有一个实例（只能创建出一个对象），为了节省内存资源，虽然说使用静态方法也能达到这个目的但是单例模式是面向对象的，能够为我们提供更好的编程思维。

怎么保证只有一个实例？

我们知道，当创建一个新对象时，我们会调用类的构造方法，创建多个对象，那我们就会调用多次构造方法，现在我们要保证只有一个实例，也就是说我们不管创建多少个对象，都只调用一次构造方法，那么怎么实现呢？我们可以给构造方法加上private修饰符，这样构造方法就只能被本类访问了，其他地方你要创建类对象，要访问构造方法就会被拒绝，但是这样的话在其他类要就不能使用当前类对象了，所以为了解决这个问题，可以对外提供一个公共方法返回一个对象。

总结一下就是：

构造方法私有化
对外提供一个公共方法返回一个对象

代码实现：

/**
 * @author PgRightWu
 * @version 1.0
 * @date 2020/12/8 16:42
 * @description  单例模式
 */
        /*
        * 单例模式步骤
        * 1.构造方法私有化
        * 2.对外提供公共方法返回一个对象
        * */
public class Singleton {
//    1.构造私有化
    private Singleton(){}
//    饿汉式（一开始就创建）
    private static Singleton s = new Singleton();
//    2.对外提供私有方法保证返回一个对象(因为外部调用类的方法要实例化对象，所以用static修饰，可以通过类名调用)
    public static Singleton getSingleton(){
        return s;
    }

}
class TestSingleton{
    public static void main(String[] args) {
        Singleton s1 = Singleton.getSingleton();
        Singleton s2 = Singleton.getSingleton();
        Singleton s3 = Singleton.getSingleton();
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);

    }
}

这样的话，不管创建多少个Singleton对象，都是指向同一个内存地址，也就是只有一个实例

采用懒汉式实现单例模式，其实也很简单，懒汉式就是什么时候用就什么时候创建对象

实现代码：

public class Singleton {
//    1.构造私有化
    private Singleton(){}
//    懒汉式（什么时候用什么时候创建）
    private static Singleton s;
//    2.对外提供私有方法保证返回一个对象(因为外部调用类的方法要实例化对象，所以用static修饰，可以通过类名调用)
    public static Singleton getSingleton(){
        if(s==null)
            s = new Singleton();
        return s;
    }

}

现在我们来聊一聊单例模式饿汉式与懒汉式的区别

饿汉式是在类加载时就进行实例化，而懒汉式默认不会实例化，是什么时候new什么时候才实例化
饿汉式是线程安全的，因为在类加载时对象就已经实例化了，而懒汉式不是线程安全的，是什么时候用就什么时候实例化，这样当多个线程同时需要实例化某个对象时，访问实例化代码，就会生成多个对象，所以是线程不安全的（可以通过同步锁解决）。
饿汉式是在类加载时实例化对象，所以会占用内存空间，造成内存空间的浪费，而懒汉式是什么时候用什么时候实例化对象，相对不会造成内存浪费。

工厂模式

创建对象的最佳方式，相当于把创建对象的过程进行了封装，这样可以将实例化对象的逻辑不对外共享，对外提供一个工厂类方便调用

工厂模式分为三种

普通工厂模式

//step1:创建接口
interface Fruit {
    public void product();
}

//step2：创建类实现接口
class Apple implements Fruit {
    @Override
    public void product() {
        System.out.println("开始生产苹果汁");
    }
}
class Orange implements Fruit {
    @Override
    public void product() {
        System.out.println("开始生产橙汁");
    }
}
class Banana implements Fruit {
    @Override
    public void product() {
        System.out.println("开始生产香蕉汁");
    }
}

//step3：创建工厂类，实现给定指定条件创建指定对象
public class FactoryBean {
    //        1.普通工厂模式
    public Fruit getFruit(String type) {
        if (type.equals("Apple")) {
//           创建对象的逻辑-----【封装】
            return new Apple();
        } else if (type.equals("Orange")) {
//           创建对象的逻辑-----【封装】
            return new Orange();
        } else if (type.equals("Banana")) {
//           创建对象的逻辑-----【封装】
            return new Banana();
        } else
            return null;
    }

//step4：使用工厂类，通过传递类型参数获取指定类的对象。
public class FactoryTest {
    public static void main(String[] args) {
        FactoryBean f = new FactoryBean();
        Fruit fruit = f.getFruit("Orange");
        Fruit fruit2 = f.getFruit("Apple");
        Fruit fruit3 = f.getFruit("Banana");
        fruit.product();
        fruit2.product();
        fruit3.product();
    }
}

多工厂模式
相当于普通工厂模式的提升，提供了多个方法实现不同对象的实例化过程。

public class FactoryBean {
//    2.多工厂模式
    public Apple getApple() {
        return new Apple();
    }

    public Orange getOrange() {
        return new Orange();
    }

    public Banana getBanana() {
        return new Banana();
    }

public class FactoryTest {
    public static void main(String[] args) {
//    2.多工厂模式测试
    FactoryBean f = new FactoryBean();
        Apple apple = f.getApple();
        Banana banana = f.getBanana();
        Orange orange = f.getOrange();
        apple.product();
        banana.product();
        orange.product();
    }
}

静态工厂模式

相当于多工厂模式的提升，提供的多个方法通过static修饰这样不用创建实例可以通过类名直接调用

public class FactoryBean {
//    静态工厂模式（就是给方法加上static，这样就可以通过类名直接调用了）
    public static Apple getApple() {
        return new Apple();
    }

    public static Orange getOrange() {
        return new Orange();
    }

    public static Banana getBanana() {
        return new Banana();
    }
}

public class FactoryTest {
    public static void main(String[] args) {
        Apple apple = FactoryBean.getApple();
		Banana banana = FactoryBean.getBanana();
		Orange orange = FactoryBean.getOrange();
		apple.product();
		banana.product();
		orange.product();
    }
}

代理模式

创建对象，不是直接创建，而是由一个代理对象帮我创建，只要调用代理对象，就能返回需要的目标对象

观察者模式

当对象间存在一对多的依赖关系时，当对一个对象进行数据更新时，则会自动更新依赖它的对象的数据。应用场景很多，例如：微信公众号

posted @ 2020-12-22 21:22 cpcnice 阅读(58) 评论(0) 收藏举报

刷新页面返回顶部

cpcnice

设计模式

设计模式

Java常见的设计模式（23种）

单例模式

工厂模式

代理模式

观察者模式

公告