一、Java 中有几种设计模式?
Java 中一般认为有 23 种设计模式
分为三大类:
1. 创建型模式 5 种
2. 结构型模式 7 种
3. 行为型模式 11 种
二、什么是单例设计模式?
1. 单例模式定义
2. 单例模式的特点
3. 单例的四大原则
4. 实现单例模式的方式
(1) 饿汉式 (立即加载):
/**
* 饿汉式(立即加载)
*/
public class Singleton1 {
/**
* 私有构造
*/
private Singleton1() {
System.out.println("构造函数Singleton1");
}
/**
* 初始值为实例对象
*/
private static Singleton1 single = new Singleton1();
/**
* 静态工厂方法
* @return 单例对象
*/
public static Singleton1 getInstance() {
System.out.println("getInstance");
return single;
}
public static void main(String[] args){
System.out.println("初始化");
Singleton1 instance = Singleton1.getInstance();
}
}
(2) 懒汉式 (延迟加载):
/**
* 懒汉式(延迟加载)
*/
public class Singleton2 {
/**
* 私有构造
*/
private Singleton2() {
System.out.println("构造函数Singleton2");
}
/**
* 初始值为null
*/
private static Singleton2 single = null;
/**
* 静态工厂方法
* @return 单例对象
*/
public static Singleton2 getInstance() {
if(single == null){
System.out.println("getInstance");
single = new Singleton2();
}
return single;
}
public static void main(String[] args){
System.out.println("初始化");
Singleton2 instance = Singleton2.getInstance();
}
}
(3) 同步锁 (解决线程安全问题):
/**
*
* 同步锁(解决线程安全问题)
*/
public class Singleton3 {
/**
* 私有构造
*/
private Singleton3() {}
/**
* 初始值为null
*/
private static Singleton3 single = null;
public static Singleton3 getInstance() {
// 等同于 synchronized public static Singleton3 getInstance()
synchronized(Singleton3.class){
// 注意:里面的判断是一定要加的,否则出现线程安全问题
if(single == null){
single = new Singleton3();
}
}
return single;
}
}
(4) 双重检查锁 (提高同步锁的效率):
/**
* 双重检查锁(提高同步锁的效率)
*/
public class Singleton4 {
/**
* 私有构造
*/
private Singleton4() {}
/**
* 初始值为null
*/
private static Singleton4 single = null;
/**
* 双重检查锁
* @return 单例对象
*/
public static Singleton4 getInstance() {
if (single == null) {
synchronized (Singleton4.class) {
if (single == null) {
single = new Singleton4();
}
}
}
return single;
}
}
(5) 静态内部类:
特点:即能延迟加载,也能保证线程安全
/**
*
* 静态内部类(延迟加载,线程安全)
*/
public class Singleton5 {
/**
* 私有构造
*/
private Singleton5() {}
/**
* 静态内部类
*/
private static class InnerObject{
private static Singleton5 single = new Singleton5();
}
public static Singleton5 getInstance() {
return InnerObject.single;
}
}
(6) 内部枚举类实现 (防止反射攻击):
public class SingletonFactory {
/**
* 内部枚举类
*/
private enum EnumSingleton{
Singleton;
private Singleton6 singleton;
//枚举类的构造方法在类加载是被实例化
private EnumSingleton(){
singleton = new Singleton6();
}
public Singleton6 getInstance(){
return singleton;
}
}
public static Singleton6 getInstance() {
return EnumSingleton.Singleton.getInstance();
}
}
class Singleton6 {
public Singleton6(){}
}
三、什么是工厂设计模式?
1. 简单工厂 (Simple Factory)
定义:
角色:
使用说明:
代码如下:
// 水果接口:
public interface Fruit {
void whatIm();
}
// 苹果类:
public class Apple implements Fruit {
@Override
public void whatIm() {
System.out.println("苹果");
}
}
// 梨类:
public class Pear implements Fruit {
@Override
public void whatIm() {
System.out.println("梨");
}
}
//水果工厂:
public class FruitFactory {
public Fruit createFruit(String type) {
if (type.equals("apple")) {//生产苹果
return new Apple();
} else if (type.equals("pear")) {//生产梨
return new Pear();
}
return null;
}
}
// 使用工厂生产产品:
public class FruitApp {
public static void main(String[] args) {
FruitFactory mFactory = new FruitFactory();
Apple apple = (Apple) mFactory.createFruit("apple");//获得苹果
Pear pear = (Pear) mFactory.createFruit("pear");//获得梨
apple.whatIm();
pear.whatIm();
}
}
2. 工厂方法 (Factory Method)
定义:
角色:
使用说明:
代码如下:
// 水果接口、苹果类和梨类:代码和上例一样
// 抽象工厂接口:
public interface FruitFactory {
Fruit createFruit();//生产水果
}
// 苹果工厂:
public class AppleFactory implements FruitFactory {
@Override
public Apple createFruit() {
return new Apple();
}
}
// 梨工厂:
public class PearFactory implements FruitFactory {
@Override
public Pear createFruit() {
return new Pear();
}
}
// 使用工厂生产产品:
public class FruitApp {
public static void main(String[] args){
AppleFactory appleFactory = new AppleFactory();
PearFactory pearFactory = new PearFactory();
Apple apple = appleFactory.createFruit();//获得苹果
Pear pear = pearFactory.createFruit();//获得梨
apple.whatIm();
pear.whatIm();
}
}
3. 抽象工厂 (Abstract Factory)
定义:
角色:
使用说明:
用抽象工厂来实现:
// cpu接口和实现类:
public interface Cpu {
void run();
class Cpu650 implements Cpu {
@Override
public void run() {
System.out.println("650 也厉害");
}
}
class Cpu825 implements Cpu {
@Override
public void run() {
System.out.println("825 更强劲");
}
}
}
// 屏幕接口和实现类:
public interface Screen {
void size();
class Screen5 implements Screen {
@Override
public void size() {
System.out.println("" + "5寸");
}
}
class Screen6 implements Screen {
@Override
public void size() {
System.out.println("6寸");
}
}
}
// 抽象工厂接口:
public interface PhoneFactory {
Cpu getCpu();//使用的cpu
Screen getScreen();//使用的屏幕
}
// 小米手机工厂:
public class XiaoMiFactory implements PhoneFactory {
@Override
public Cpu.Cpu825 getCpu() {
return new Cpu.Cpu825();//高性能处理器
}
@Override
public Screen.Screen6 getScreen() {
return new Screen.Screen6();//6寸大屏
}
}
//红米手机工厂:
public class HongMiFactory implements PhoneFactory {
@Override
public Cpu.Cpu650 getCpu() {
return new Cpu.Cpu650();//高效处理器
}
@Override
public Screen.Screen5 getScreen() {
return new Screen.Screen5();//小屏手机
}
}
// 使用工厂生产产品:
public class PhoneApp {
public static void main(String[] args){
HongMiFactory hongMiFactory = new HongMiFactory();
XiaoMiFactory xiaoMiFactory = new XiaoMiFactory();
Cpu.Cpu650 cpu650 = hongMiFactory.getCpu();
Cpu.Cpu825 cpu825 = xiaoMiFactory.getCpu();
cpu650.run();
cpu825.run();
Screen.Screen5 screen5 = hongMiFactory.getScreen();
Screen.Screen6 screen6 = xiaoMiFactory.getScreen();
screen5.size();
screen6.size();
}
}