清云青云
清云青云

JAVA 23种设计模式示例

目录

一.单例模式

二.工厂方法模式

三.抽象工厂模式

四.建造者模式

五.原型模式

六.享元模式

七.门面模式

八.适配器模式

九.装饰者模式

十.策略模式

十一.模板方法模式

十二.观察者模式

十三.责任链模式

十四.代理模式

十五.桥接模式

十六.组合模式

十七.命令模式

十八.状态模式

十九.中介者模式

二十.迭代器模式

二十一.访问者模式

二十二.备忘录模式

二十三.解释器模式

JAVA 23种设计模式示例_第1张图片

一.单例模式

某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例。

1.懒汉模式：延时加载，只有在真正使用到的时候，才进行实例化。

public class LazySingleton {
	
	private volatile static LazySingleton instance = null;
	
	private LazySingleton() {
		
	}
	
	public static LazySingleton getInstance() {
		if(null == instance) {
			synchronized (LazySingleton.class) {
				if(null == instance) {
					instance = new LazySingleton();
				}
			}
		}
		return instance;
	}
	
}

（1）线程安全问题

（2）double check加锁优化

（3）编译器（JIT），CPU对满足as-if-series的指令会进行指令重排，会导致获取到未初始化的实例，所以需要加上volatile关键字进行修饰，防止指令重排（创建一个对象，需要经过开辟空间、赋默认值、初始化的过程）。

2.饿汉模式：

只有在真正主动使用对应的类时，才会触发初始化，例如（当前类时启动类即main函数所在类，直接进行new操作，访问静态属性、访问静态方法，用反射访问类等）；类加载的初始化阶段就完成了实例的初始化，本质上就是借助于jvm类加载机制，保证实例的唯一性（初始化过程只会执行一次）及线程安全（JVM以同步的形式来完成类加载的整个过程）。

类加载过程：

（1）加载二进制数据到内存中，生成对应的class数据结构

（2）连接：a.验证，b.准备（给类的静态成员变量赋默认值），c.解析

（2）初始化：给类的静态变量赋初值

public class HungrySingleton {

	public static String name = "qingyun";
	private static HungrySingleton instance = new HungrySingleton();

	
	private HungrySingleton() {
		
	}
	
	public static HungrySingleton getInstance() {
		return instance;
	}
	
}

使用静态内部类实现饿汉模式：

public class InnerClassSingleton {
	
	public static String name= "qingyun";
	
	private InnerClassSingleton() {
		
	}
	
	private static class SingletonHolder{
		private static InnerClassSingleton instance = new InnerClassSingleton();
	}
	
	public static InnerClassSingleton getInstance() {
		return SingletonHolder.instance;
	}
	
}

当访问静态name属性时，不会加载instance的初始化，只有真正使用到对应的类时，才会初始化，例如调用InnerClassSingleton.getInstance()。

要想反编译查看类加载的过程，可以通过idea的Terminal查看，进入class所在的目录，执行javap命令：

JAVA 23种设计模式示例_第2张图片

3.使用序列化、反序列化的方式创建单例，需要保证类的唯一性。

（1）把类序列化

类需要实现Serializable接口，并且需要设置serialVersionUID 的值，使用jdk自带的ObjectOutputStream把类序列化到磁盘上。

public class LazySingletonMain {

    public static void main(String[] args) {
        try {
            //获取实体
            LazySingleton instance = LazySingleton.getInstance();
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("name"));
            oos.writeObject(instance);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class LazySingleton implements Serializable {
    private static final long serialVersionUID = 1L;

    private volatile static LazySingleton instance = null;

    private LazySingleton() {

    }

    public static LazySingleton getInstance() {
        if(null == instance) {
            synchronized (LazySingleton.class) {
                if(null == instance) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

执行完后会生产序列化的文件

JAVA 23种设计模式示例_第3张图片

 （2）把类反序列化，保证是单例的

使用jdk自带的ObjectInputStream把序列化的类反序列化，这样使用序列化的方式进行单例创建才能保证唯一性。

public class LazySingletonMain {

    public static void main(String[] args) {
        try {
            LazySingleton instance = LazySingleton.getInstance();
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("name"));
            //反序列化实体
            LazySingleton lazySingleton = (LazySingleton)ois.readObject();
            System.out.println(lazySingleton == instance);  //输出true
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class LazySingleton implements Serializable {
    //需要制定版本，才能在序列化和反序列化中匹配为同一个实体
    private static final long serialVersionUID = 1L;

    private volatile static LazySingleton instance = null;

    private LazySingleton() {

    }

    public static LazySingleton getInstance() {
        if(null == instance) {
            synchronized (LazySingleton.class) {
                if(null == instance) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }

    //反序列化的时候，生成实体时执行此处代码
    private Object readResolve() throws ObjectStreamException {
        return getInstance();
    }
}

二.工厂方法模式

Factory Method 定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法模式使得一个类的实例化延时到子类。

应用场景：

1.当你不知道该使用对象的确切类型的时候；

2.当你希望为库或框架提供扩展其它内部组件的方法时。

主要优点：

1.将具体产品和创建者解耦；

2.符合单一职责原则；

3.符合开闭原则。

public class FactoryMethod {

    public static void main(String[] args) {
        //创建子类，使用继承的父类来接收
        //Application application = new CreateProductA();
        Application application = new CreateProductB();
        //使用接口类来接收创建出来类，体现了多态
        Product productObject = application.getProduct();
        //创建的是哪个类，调用到的就是哪个类的方法实现
        productObject.method();
    }
}

//定义一个接口类
interface Product{
    public void method();
}

//类实现了接口，必须实现接口中的方法
class ProductA implements Product{
    @Override
    public void method() {
        System.out.println("ProductA method");
    }
}


class ProductB implements Product{
    @Override
    public void method() {
        System.out.println("ProductB method");
    }
}

//抽象类里面不一定要有抽象方法；有抽象方法，类必须要是抽象类
abstract class Application {
    //工厂方法类，返回的是一个接口类
    abstract Product getProduct();
}

//子类继承了抽象类，子类必须实现抽象类里的方法
class CreateProductA extends Application{
    @Override
    Product getProduct() {
        //ProductA实现了Product接口，所以可以把创建的ProductA用Product接收
        return new ProductA();
    }
}

//子类继承了抽象类，子类必须实现抽象类里的方法
class CreateProductB extends Application{
    @Override
    Product getProduct() {
        return new ProductB();
    }
}

三.抽象工厂模式

Abstract Factory提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

应用场景：

程序需要处理不同序列的相关产品，但是你不希望它依赖于这些产品的具体类时，可是使用抽象工厂。

优点：

1.可以确信你从工厂得到的产品彼此是兼容的；

2.可以避免具体产品和客户端代码之间的紧密耦合；

3.符合单一职责原则；

4.符合开闭原则。

public class AbstractFactory {
    public static void main(String[] args) {
        //创建一个类，使用其实现的接口来接收
        IDataBaseUtils iDataBaseUtils = new MysqlDataBaseUtils();
        IConnection iConnection = iDataBaseUtils.getConnection();
        iConnection.connection();
        ICommand iCommand = iDataBaseUtils.getCommand();
        iCommand.command();
    }
}

interface IConnection{
    void connection();
}

interface ICommand{
    void command();
}

interface IDataBaseUtils{
    //包含一组的工厂方法
    IConnection getConnection();
    ICommand getCommand();
}

class MysqlConnection implements IConnection{
    @Override
    public void connection() {
        System.out.println("mysql connection");
    }
}

class OracleConnection implements IConnection{
    @Override
    public void connection() {
        System.out.println("oracle connection");
    }
}

class MysqlCommand implements ICommand{
    @Override
    public void command() {
        System.out.println("mysql command");
    }
}

class OracleCommand implements ICommand{
    @Override
    public void command() {
        System.out.println("oracle command");
    }
}

class MysqlDataBaseUtils implements IDataBaseUtils{
    @Override
    public IConnection getConnection() {
        return new MysqlConnection();
    }
    @Override
    public ICommand getCommand() {
        return new MysqlCommand();
    }
}

class OracleDataBaseUtils implements IDataBaseUtils{
    @Override
    public IConnection getConnection() {
        return new OracleConnection();
    }
    @Override
    public ICommand getCommand() {
        return new OracleCommand();
    }
}

四.建造者模式

将一个复杂对象的创建与他的标识分离，使得同样的构建过程可以创建不同的表示

应用场景：

1.需要生成的对象具有复杂的内部结构；

2.需要生成的对象内部属性本身相互依赖；

3.与不可变对象配合使用。

优点：

1.建造者独立，易扩展；

2.便于控制细节风险。

spring源码中的使用：

1.org.springframework.web.servlet.mvc.method.RequestMappingInfo;

2.org.springframework.beans.factory.support.BeanDefinitionBuilder;

public class BuilderTest {

    public static void main(String[] args) {
        ProductBulider productBulider = new DefaultCreateBuilderProduct();
        Director director = new Director(productBulider);
        Product product = director.makeProduct("xxx", "1", "2", "3");
        System.out.println(product.toString());
    }
}

interface ProductBulider{
    void buliderProductName(String productName);
    void buliderPart1(String part1);
    void buliderPart2(String part2);
    void buliderPart3(String part3);
    Product bulid();
}

class Director{
    private ProductBulider productBulider;

    public Director(ProductBulider productBulider){
        this.productBulider = productBulider;
    }

    public Product makeProduct(String productName, String part1, String part2, String part3){
        productBulider.buliderProductName(productName);
        productBulider.buliderPart1(part1);
        productBulider.buliderPart2(part2);
        productBulider.buliderPart3(part3);
        Product product = productBulider.bulid();
        return product;
    }
}

class DefaultCreateBuilderProduct implements ProductBulider{
    private String productName;
    private String part1;
    private String part2;
    private String part3;

    @Override
    public void buliderProductName(String productName) {
        this.productName = productName;
    }

    @Override
    public void buliderPart1(String part1) {
        this.part1 = part1;
    }

    @Override
    public void buliderPart2(String part2) {
        this.part2 = part2;
    }

    @Override
    public void buliderPart3(String part3) {
        this.part3 = part3;
    }

    @Override
    public Product bulid() {
        return new Product( this.productName,  this.part1,  this.part2,  this.part3);
    }
}

class Product{
    private String productName;
    private String part1;
    private String part2;
    private String part3;

    public Product(){

    }

    public Product(String productName, String part1, String part2, String part3) {
        this.productName = productName;
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    public String getPart1() {
        return part1;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public String getPart2() {
        return part2;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    public String getPart3() {
        return part3;
    }

    public void setPart3(String part3) {
        this.part3 = part3;
    }

    @Override
    public String toString() {
        return "Product{" +
                "productName='" + productName + '\'' +
                ", part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3='" + part3 + '\'' +
                '}';
    }
}

简化版的构造模式（内部静态类）

public class BuilderTest {

    public static void main(String[] args) {
        Product product = new Product.ProductBuilder().productName("xxx").part1("1").part2("2").part3("3").bulid();
        System.out.println(product.toString());
    }
}


class Product{
    private final String productName;
    private final String part1;
    private final String part2;
    private final String part3;

    static class ProductBuilder{
        private  String productName;
        private  String part1;
        private  String part2;
        private  String part3;

        public ProductBuilder productName(String productName){
            this.productName = productName;
            return this;
        }

        public ProductBuilder part1(String part1){
            this.part1 = part1;
            return this;
        }

        public ProductBuilder part2(String part2){
            this.part2 = part2;
            return this;
        }

        public ProductBuilder part3(String part3){
            this.part3 = part3;
            return this;
        }

        Product bulid(){
            return new Product(this.productName,this.part1,this.part2,this.part3);
        }
    }

    public Product(String productName, String part1, String part2, String part3) {
        this.productName = productName;
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
    }

    @Override
    public String toString() {
        return "Product{" +
                "productName='" + productName + '\'' +
                ", part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3='" + part3 + '\'' +
                '}';
    }
}

五.原型模式

原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

应用场景：

当代码不需要依赖于需要复制的对象的具体类时，请使用Prototype模式。

优点：

1.可以不耦合具体类的情况下克隆对象；

2.避免重复的初始化代码；

3.更方便的构建复杂对象。

Spring源码中的应用：

1.org.springframework.beans.factory.support.AbstractBeanDefinition

2.java.util.Arrays

public class PrototypeTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        BaseInfo baseInfo = new BaseInfo("1111");
        Product product = new Product("xx商品","part1","part2","part3",baseInfo);
        System.out.println(product.toString());
        Product clone = product.clone();
        System.out.println(clone.toString());
    }

}

class BaseInfo implements Cloneable{
    private String productId;

    public BaseInfo(String productId){
        this.productId = productId;
    }

    @Override
    protected BaseInfo clone() throws CloneNotSupportedException{
        BaseInfo baseInfo = (BaseInfo)super.clone();
        return baseInfo;
    }

    @Override
    public String toString() {
        return super.hashCode()+" ] BaseInfo{" +
                "productId='" + productId + '\'' +
                '}';
    }
}

class Product implements Cloneable{
    private String productName;
    private String part1;
    private String part2;
    private String part3;
    private BaseInfo baseInfo;

    @Override
    protected Product clone() throws CloneNotSupportedException{
        Product product = (Product)super.clone();
        BaseInfo baseInfo = (BaseInfo)product.baseInfo.clone();
        product.setBaseInfo(baseInfo);
        return product;
    }

    public Product(String productName, String part1, String part2, String part3,BaseInfo baseInfo) {
        this.productName = productName;
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
        this.baseInfo = baseInfo;
    }

    @Override
    public String toString() {
        return super.hashCode()+"Product{" +
                "productName='" + productName + '\'' +
                ", part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3='" + part3 + '\'' +
                ", baseInfo=" + baseInfo +
                '}';
    }

    public BaseInfo getBaseInfo() {
        return baseInfo;
    }

    public void setBaseInfo(BaseInfo baseInfo) {
        this.baseInfo = baseInfo;
    }
}

对一个对象的拷贝我们使实体实现Cloneable接口，重写它的clone方法；若是实体里面引入了其它的实体，例如上面的Product类中引入了BaseInfo类，若是BaseInfo类没有实现Cloneable接口，重写它的clone方法，则对BaseInfo的拷贝是浅拷贝（类的hashcode相同）：

浅拷贝的问题时，修改其中一个的BaseInfo值时，另一个也会跟随着变化。

要达到深拷贝的程度，我们需要让引入的BaseInfo也实现Cloneable接口，重写它的clone方法，在Product类中调用clone方法时，调用下BaseInfo的clone来拷贝BaseInfo，此时是深拷贝（类的hashcode不相同）：

六.享元模式

     享元模式运用共享技术有效的支持大量细粒度的对象。

优点：

1.如果系统有大量类似的对象，可以节省大量的内存及CUP资源

Spring源码中的运用：

1.String、Integer、Long
2.com.sun.org.apache.bcel.internal.generic.InstructionConstants
public class FlyWeightTest {

    public static void main(String[] args) {
        //创建多个marker对象，里面的参数BaseMessage相同时使用共享的方式
        Marker marker1 = new Marker(new BigDecimal(10),new BigDecimal(30),BaseMessageFactory.getBaseMessage("xx","xxxtip"));
        Marker marker2 = new Marker(new BigDecimal(60),new BigDecimal(80),BaseMessageFactory.getBaseMessage("xx","xxxtip"));
        System.out.println(marker1.toString());
        System.out.println(marker2.toString());
    }
}

class Marker{
    private BigDecimal lat;
    private BigDecimal lon;
    private BaseMessage baseMessage;

    public Marker(BigDecimal lat, BigDecimal lon, BaseMessage baseMessage) {
        this.lat = lat;
        this.lon = lon;
        this.baseMessage = baseMessage;
    }

    @Override
    public String toString() {
        return "Marker{" +
                "lat=" + lat +
                ", lon=" + lon +
                ", baseMessage=" + baseMessage.toString() +
                '}';
    }
}

class BaseMessageFactory{
    //使用map存放已经创建的对象，供其他线程创建时复用
    private static Map map = new ConcurrentHashMap();
    public static BaseMessage getBaseMessage(String title,String tip){
        if(map.containsKey(title)){
            return map.get(title);
        }
        BaseMessage baseMessage = new BaseMessage(title,tip);
        map.put(title,baseMessage);
        return baseMessage;
    }
}


class BaseMessage{
    //字段使用final修饰，创建后不可改变值
    private final String title;
    private final String tip;

    BaseMessage(String title, String tip) {
        System.out.println("create BaseMessage:"+title);
        this.title = title;
        this.tip = tip;
    }

    @Override
    public String toString() {
        return "BaseMessage{" +
                "title='" + title + '\'' +
                ", tip='" + tip + '\'' +
                '}';
    }
}

七.门面模式

    门面模式为子系统中的一组接口提供一个一致的接口，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

JAVA 23种设计模式示例_第4张图片

 应用场景：

1.当需要使用复杂子系统的有限但直接的接口时，请使用Facade模式。

2.当您想要将子系统组织成层时，请使用Facade。

优点：

1.简化客户端的调用。

源码中的经典应用：

1.org.apache.catalina.connector.RequestFacade
public class FacadeTest {

    public static void main(String[] args) {
        Client1 client1 = new Client1();
        client1.pritlnSomething();
    }
}

//客户端1
class Client1{
    Facate facate = new Facate();

    public void pritlnSomething(){
        //使用门面模式来统一调用
        facate.printAll();
    }
}

//门面模式，有facate来统一调用需要调用的方法
class Facate{
    SubMessage1 subMessage1 = new SubMessage1();
    SubMessage2 subMessage2 = new SubMessage2();
    SubMessage3 subMessage3 = new SubMessage3();

    public void printAll(){
        subMessage1.printSub1();
        subMessage2.printSub2();
        subMessage3.printSub3();
    }
}

//子类
class SubMessage1{
    public void printSub1(){
        System.out.println("printSub1...");
    }
}

class SubMessage2{
    public void printSub2(){
        System.out.println("printSub2...");
    }
}

class SubMessage3{
    public void printSub3(){
        System.out.println("printSub3...");
    }
}

八.适配器模式

    适配器模式将一个类的接口转换成客户希望的另一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

应用场景：

1.当你希望使用某些现有类，但其接口与你的其它代码不兼容时，请使用适配器类。

2.当你希望重用几个现有的子类，这些子类缺少一些不能添加到超类中的公共功能时，请使用该模式。

优点：

1.符合单一职责原则。

2.符合开闭原则。

JDK & Spring源码中的应用

JDK:
1.java.util.Arrays # asList()
2.java.util.Collections # list()
Spring:
1.org.springframework.context.event.GenericApplicationListenerAdapter
Object形式的适配器模式（注入类的方式）:
public class AdapterObject {

    public static void main(String[] args) {
        Target target = new Adapter(new Adaptee());
        System.out.println(target.adapter10v());
    }
}

interface Target{
    int adapter10v();
}

class Adapter implements Target{

    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public int adapter10v() {
        int i = adaptee.adapter220v();
        //经过处理，输出10V的电压
        int j = i/22;
        System.out.println(String.format("原电压  %d  v   转化后电压   %d  v",i,j));
        return j;
    }
}

//提供220V电压的类
class Adaptee{
    public int adapter220v(){
        return 220;
    }
}
Class形式的适配器模式（继承类的方式）：
public class AdapterClassDemo {

    public static void main(String[] args) {
        TargetClass targetClass = new AdapterClass();
        System.out.println(targetClass.adapter10v());
    }
}

interface TargetClass{
    int adapter10v();
}

//使用类继承的方式
class AdapterClass extends AdapteeClass implements TargetClass{

    @Override
    public int adapter10v() {
        int i = adapter220v();
        int j = i /22;
        System.out.println(String.format("原电压  %d  v   转化后电压   %d  v",i,j));
        return j;
    }
}


class AdapteeClass{
    public int adapter220v(){
        return 220;
    }
}

九.装饰者模式

      装饰者模式Decorator在不改变原有对象的基础上，将功能附加到对象上。

应用场景：

1.扩展一个类的功能或给一个类添加附加功能。

优点：

1.不改变原有对象的情况下，给一个对象扩展功能。

2.使用不同的组合可以实现不同的效果。

3.符合开闭原则（对扩展开放，对修改关闭）。

经典案例：

1.javax.servlet.http.HttpServletRequest
2.javax.servlet.http.HttpServletResponse
public class DecoratorTest {
    public static void main(String[] args) {
        //这是一开始既有的实现
        /*Component component = new CreateComponent();
        component.operation();*/
        //使用接口接收创建的类；创建具体类的实现作为它实现的接口，此接口是一个参数，即可在不改变原有对象的基础上，扩展附加一些属性
        Component component = new CreateDecorator2(new CreateDecoator1(new CreateComponent()));
        component.operation();
    }
}

interface Component{
    void operation();
}

class CreateComponent implements Component{
    @Override
    public void operation() {
        System.out.println("拍照");
    }
}

//抽象类实现接口，可以不实现接口中的方法，当子类继承此抽象类时再对接口中的方法进行实现
abstract class Decorator implements Component{
    Component component;

    public Decorator(Component component){
        this.component = component;
    }
}

//子类继承抽象父类，需要实现父类未实现的接口方法，需要调用父类的定义的构造函数
class CreateDecoator1 extends Decorator{

    //构造父类的构造方法
    public CreateDecoator1(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        System.out.println("美颜");
        //调用创建CreateDecoator1类时传递到父抽象类Decorator的component
        component.operation();
    }
}

class CreateDecorator2 extends Decorator{

    public CreateDecorator2(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        System.out.println("滤镜");
        component.operation();
    }
}

十.策略模式

     策略模式Stragety定义了算法族，分别封装起来，让它们直接可以互相替换，此模式的变化独立于算法的使用者。

应用场景：

1.业务代码需要根据场景不同，切换不同的实现逻辑。

2.代码中存在大量if - else判断。

优点：

1.符合开闭原则。

2.避免使用多重条件转移语句，例if - else 语句、switch语句。

3.可以提高算法的安全性和保密性。

经典案例：

1.java.util.Arrays # sort(T[] a, Comparator c)
2.org.springframework.beans.factory.support.InstantiationStrategy
public class StrategyTest {

    public static void main(String[] args) {
        Zombie zombie = new NormalZombie(new OneStepMove(),new OneAttack());
        zombie.display();
        zombie.move();
        zombie.attack();
        //根据传入的值，改变对应的方法调用输出的结果
        zombie.setMoveable(new TenStepMove());
        zombie.setAttackable(new TenAttack());
        System.out.println("......进过策略模式传递对象改变后，调用同样的方法输出结果......");
        zombie.move();
        zombie.attack();
    }
}

//移动的接口
interface Moveable{
    void move();
}
//攻击的接口
interface Attackable{
    void attack();
}

//定义一个抽象类
abstract class Zombie {
    abstract void display();
    Moveable moveable;
    Attackable attackable;
    abstract void move();
    abstract void attack();

    public Zombie(Moveable moveable, Attackable attackable) {
        this.moveable = moveable;
        this.attackable = attackable;
    }

    public void setMoveable(Moveable moveable) {
        this.moveable = moveable;
    }

    public void setAttackable(Attackable attackable) {
        this.attackable = attackable;
    }
}

//子类继承抽象类
class NormalZombie extends Zombie{

    public NormalZombie(Moveable moveable, Attackable attackable) {
        super(moveable, attackable);
    }

    @Override
    void display() {
        System.out.println("普通类");
    }

    @Override
    void move() {
        moveable.move();
    }

    @Override
    void attack() {
        attackable.attack();
    }
}

//子类继承抽象类
class StyleZombie extends Zombie{

    public StyleZombie(Moveable moveable, Attackable attackable) {
        super(moveable, attackable);
    }

    @Override
    void display() {
        System.out.println("风格类......");
    }

    @Override
    void move() {
        moveable.move();
    }

    @Override
    void attack() {
        attackable.attack();
    }
}

//定义类实现具体的移动方法
class OneStepMove implements Moveable{
    @Override
    public void move() {
        System.out.println("走一步");
    }
}

class TenStepMove implements Moveable{
    @Override
    public void move() {
        System.out.println("走十步");
    }
}

class OneAttack implements Attackable{
    @Override
    public void attack() {
        System.out.println("一次攻击");
    }
}

class TenAttack implements Attackable{
    @Override
    public void attack() {
        System.out.println("十次攻击");
    }
}

程序执行输出结果值：

JAVA 23种设计模式示例_第5张图片

十一.模板方法模式

      模板方法模式Template Method定义一个操作的算法骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构，即可重定义改算法的某些特定步骤。

应用场景：

1.一次性实现一个算法不变的部分，并将可变部分留给子类实现。

2.各个子类中，公共部分被提取出来，集中到一个公共的父类中，避免代码重复。

优点：

1.提高代码复用性：将相同部分代码，放到抽象的父类中；

2.提供扩展性：将不同的代码，放到不同的子类中，通过对子类的扩展，增加新的行为；

3.符合开闭原则：通过父类调用子类的操作，通过对子类的扩展来增加新的行为。

Servlet Api & Spring源码：

//service中定义了doGet/doPost等方法，具体的实现由子类进行
1.javax.servlet.http.HttpServlet #service()

//handleRequest中定义了ModelAndView返回值，具体的实现由子类进行
2.org.springframework.web.servlet.mvc.AbstractController #handleRequest()
public class TemplateTest {

    public static void main(String[] args) {
        AbstraceClass abstraceClass = new SubClass2();
        abstraceClass.operator();
    }
}

/**
 * 抽象父类
 */
abstract class AbstraceClass{
    //一般此方法是默认调用的方法
    public void operator(){
        System.out.println("准备");
        System.out.println("处理");
        //调用模板方法，此方法由子类实现
        templateMethod();
    }

    protected abstract void templateMethod();
}

class SubClass1 extends AbstraceClass{
    //重写父类定义的抽象方法
    @Override
    protected void templateMethod() {
        System.out.println("子类1实现的方法");
    }
}

class SubClass2 extends AbstraceClass{
    //重写父类定义的抽象方法
    @Override
    protected void templateMethod() {
        System.out.println("子类2实现的方法");
    }
}

十二.观察者模式

    观察者模式Observer定义了对象之间的一对多依赖，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，它的所有依赖者都会收到通知并更新。

应用场景：

1.当更改一个对象的状态可能需要更改其它对象，并且实际的对象集事先未知或动态更改时，请使用观察者模式。

优点：

1.符合开闭原则；

2.可以在运行时建立对象之间的关系。

JDK & Spring源码中的应用：

//定义了存放观察者的集合、添加、删除、通知观察者update的方法
1.java.util.Observable 

//定义了onApplicationEvent通知方法，消息的发布在ApplicationEventMulticaster中，由multicastEvent方法获取getApplicationListeners()注册的监听集合，遍历此集合调用通知方法
2.org.springframework.context.ApplicationListener
public class ObserverTest {
    public static void main(String[] args) {
        Subject subject = new Subject();
        Observer subClass1 = new SubClass1();
        Observer subClass2 = new SubClass2();
        //把观察者对象添加进依赖的对象里面
        subject.add(subClass1);
        subject.add(subClass2);
        subject.notityAll("数据有更新了...");
        System.out.println("...移出某个需要通知的对象后...");
        subject.remove(subClass1);
        subject.notityAll("数据再次更新了...");
    }
}

class Subject {
    List list = new ArrayList();

    //添加需要通知的对象
    public void add(Observer observer){
        if(!list.contains(observer)){
            list.add(observer);
        }
    }

    //移出需要通知的对象
    public void remove(Observer observer){
        list.remove(observer);
    }

    //有变动，通知所有的监听对象
    public void notityAll(Object object){
        for(int i = 0;i < list.size();i++){
            Observer observer = list.get(i);
            observer.notity(object);
        }
    }
}

interface Observer{
    void notity(Object object);
}

class SubClass1 implements Observer{
    @Override
    public void notity(Object object) {
        System.out.println("通知消息1："+object);
    }
}

class SubClass2 implements Observer{
    @Override
    public void notity(Object object) {
        System.out.println("通知消息2："+object);
    }
}

十三.责任链模式

     责任链模式Chain Of Responsibility 为请求创建了一个接收者对象的链。

应用场景：

1.一个请求的处理需要多个对象当中的一个或几个协作处理。

优点：

1.请求的发送者和接受者解耦；

2.可以控制执行顺序；

3.符合开闭原则和单一职责原则。

经典案例：

//doFilter方法里面有一个FilterChain责任链
1.javax.servlet.Filter #doFilter()
2.javax.servlet.FilterChain #doFilter()
//sentinel中进行流控、熔断的策略就是使用的责任链模式，使用8中插槽slot的方式判断是否达到某种限制，达到则抛出对应的异常，触发对应的控制
3.com.alibaba.csp.sentinel.CtSph #lookProcessChain()
public class ChainOfResponsibilityTest {
    public static void main(String[] args) {
        //通过构建者模式创建request
        Request request = new Request.RequestBuilder().isLogin(false).isEnter(false).bulid();
        //定义责任链，LoginHandler的next为EnterHandler，EnterHandler的next为null
        Handler handler = new LoginHandler(new EnterHandler(null));
        boolean process = handler.process(request);
        if(process){
            System.out.println("校验通过");
        } else {
            System.out.println("校验不通过");
        }
    }
}

//定义一个请求类
class Request {
    private boolean isLogin;
    private boolean isEnter;

    public Request(boolean isLogin, boolean isEnter) {
        this.isLogin = isLogin;
        this.isEnter = isEnter;
    }

    //使用建造者模式创建
    static class RequestBuilder{
        private boolean isLogin;
        private boolean isEnter;

        RequestBuilder isLogin(boolean isLogin){
            this.isLogin = isLogin;
            return this;
        }
        
        RequestBuilder isEnter(boolean isEnter){
            this.isEnter = isEnter;
            return this;
        }
        
        Request bulid(){
            Request request = new Request(isLogin,isEnter);
            return request;
        }
    }

    public boolean isLogin() {
        return isLogin;
    }

    public boolean isEnter() {
        return isEnter;
    }
}

//定义一个抽象父类
abstract class Handler{
    Handler next;
    abstract boolean process(Request request);

    public Handler(Handler next) {
        this.next = next;
    }

    public Handler getNext() {
        return next;
    }

    public void setNext(Handler next) {
        this.next = next;
    }
}

//定义子类
class LoginHandler extends Handler{

    //定义next的值
    public LoginHandler(Handler next) {
        super(next);
    }

    @Override
    boolean process(Request request) {
        System.out.println("登陆校验");
        if(request.isLogin()){
            Handler next = getNext();
            if(null == next){
                return true;
            }
            if(next.process(request)){
                return true;
            }
        }
        return false;
    }
}

//定义子类
class EnterHandler extends Handler{

    public EnterHandler(Handler next) {
        super(next);
    }

    @Override
    boolean process(Request request) {
        System.out.println("进入处理");
        if(request.isEnter()){
            Handler next = getNext();
            if(null == next){
                return true;
            }
            if(next.process(request)){
                return true;
            }
        }
        return false;
    }
}

十四.代理模式

    代理模式proxy代理对象具备真实对象的功能，并代替真实对象完成相应操作，并能够在操作执行前后，对操作进行增强处理。

应用场景：

1.日志的采集；

2.实现aop；

3.Rpc远程接口调用。

优点：

1.在不修改目标对象的前提下，能通过代理对象对目标对象进行扩

①静态代理

     需要定义接口或者父类，代理对象和被代理对象需要实现相同的接口或者继承相同的父类，在代理对象中注入被代理类，通过代理对象调用真实的对象。

案例：

public class StaticProxyTest {
    public static void main(String[] args) {
       RentHouse rentHouse = new ProxyRent(new RealRent());
       rentHouse.rent();
    }
}

//定义一个接口类
interface RentHouse{
    void rent();
}

//定义一个真实类
class RealRent implements RentHouse{
    @Override
    public void rent() {
        System.out.println("房东租房");
    }
}

//定义一个代理类，代理类和真实类需要实现相同的接口
class ProxyRent implements RentHouse{
    //代理类需要注入真实的被代理类
    private RealRent realRent;
    public ProxyRent(RealRent realRent) {
        this.realRent = realRent;
    }

    @Override
    public void rent() {
        //在调用被代理类之前代理类可以添加一些其他的步骤
        System.out.println("带客户看房");
        //调用被代理类的方法
        realRent.rent();
        //在调用被代理类之后代理类可以添加一些其他的步骤
        System.out.println("签订合同");
    }
}

②jdk动态代理

      jdk动态代理涉及到java.lang.reflect.InvocationHandler和Proxy类，实现InvocationHandler接口后，重写invoke执行代理类的方法；使用Proxy的newProxyInstanse创建代理类，需要的参数为接口类，所以jdk动态代理需要使用接口类来接收，源码方法如下：

  //jdk创建代理类需要使用interfaces接口作为参数
  public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h)

案例：

public class JdkDynamicProxyTest {
    public static void main(String[] args) {
        //jdk1.8及之前的版本，设置保持jdk代理文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        //jkd1.8之后的版本，设置保持jdk代理文件
        //System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");
        JdkDynamicProxy proxy = new JdkDynamicProxy(new Cat("小猫"));
        Animal animal = (Animal) Proxy.newProxyInstance(proxy.getClass().getClassLoader(),new Class[]{Animal.class},proxy);
        animal.getUp();
        animal.sleep();

        proxy = new JdkDynamicProxy(new Student("学生"));
        Person person = (Person) Proxy.newProxyInstance(proxy.getClass().getClassLoader(),new Class[]{Person.class},proxy);
        person.getUp();
        person.sleep();
    }
}

//定义一个动物的接口
interface Animal{
    //起床的方法
    void getUp();
    //睡觉的方法
    void sleep();
}

//定义一个人的接口
interface Person{
    //起床的方法
    void getUp();
    //睡觉的方法
    void sleep();
}

//定义类实现接口
class Cat implements Animal{
    private String name;

    public Cat(String name) {
        this.name = name;
    }

    @Override
    public void getUp() {
        System.out.println("动物"+name+"起床");
    }

    @Override
    public void sleep() {
        System.out.println("动物"+name+"睡觉");
    }
}

//定义接口实现类
class Student implements Person{

    private String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public void getUp() {
        System.out.println("人类"+name+"起床");
    }

    @Override
    public void sleep() {
        System.out.println("人类"+name+"睡觉");
    }
}

//jdk动态代理，通过实现InvocationHandler，重写invoke方法
class JdkDynamicProxy implements InvocationHandler {
    //需要注入需要代理的类
    private Object bean;

    public JdkDynamicProxy(Object bean) {
        this.bean = bean;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //再调用代理类之前做一些前置处理
        String name = method.getName();
        if("getUp".equals(name)){
            System.out.println("早上好");
        } else if("sleep".equals(name)){
            System.out.println("晚安");
        }
        //执行被代理类的方法
        return method.invoke(bean,args);
    }


}

    可以通过System.getProperties().put来设置生成代理类的class文件，可以在invoke调用真实类之前附加一些处理，需要使用接口来接收代理类，生成的代理类继承自Proxy，实现的接口为创建代理类时传入的接口类，里面有接口类定义的方法。

JAVA 23种设计模式示例_第6张图片

 ③Cglib动态代理

      Cglib是一个机遇ASM字节码生成库，它允许在运行时对字节码进行修改和动态生成，cglib生成的是真实类的子类。主要使用到org.springframework.cglib.proxy.MethodInterceptor和Enhancer类，代理类实现MethodInterceptor接口，重写invoke调用代理类的方法，使用Enhancer字节码增强器来创界代理类。

案例：

public class CglibDynamicProxyTest {
    public static void main(String[] args) {
        //输出生成的代理类
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\aop");
        CglibDynamicPorxy cglibDynamicPorxy = new CglibDynamicPorxy(new CatCglib("小猫"));
        CatCglib catCglib = (CatCglib) cglibDynamicPorxy.getProxy();
        catCglib.getUp();
        catCglib.sleep();

        cglibDynamicPorxy = new CglibDynamicPorxy(new StudentCglib("学生"));
        StudentCglib studentCglib = (StudentCglib) cglibDynamicPorxy.getProxy();
        studentCglib.getUp();
        studentCglib.sleep();
    }
}

//创建代理类
class CglibDynamicPorxy implements MethodInterceptor {
    //注入需要代理的类
    Object bean;

    public CglibDynamicPorxy(Object bean) {
        this.bean = bean;
    }

    //字节码增强器，为无接口的类创建代理
    private Enhancer enhancer = new Enhancer();

    public Object getProxy(){
        //设置父类
        enhancer.setSuperclass(bean.getClass());
        //设置方法的回调
        enhancer.setCallback(this);
        //创建代理-子类，继承自父类
        return enhancer.create();
    }


    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        String name = method.getName();
        if("getUp".equals(name)){
            System.out.println("早上好");
        } else if("sleep".equals(name)){
            System.out.println("晚上好");
        }
        return method.invoke(bean,objects);
    }
}


//定义类实现接口
class CatCglib {
    private String name;

    public CatCglib() {
    }

    public CatCglib(String name) {
        this.name = name;
    }
    public void getUp() {
        System.out.println("动物"+name+"起床");
    }
    public void sleep() {
        System.out.println("动物"+name+"睡觉");
    }
}

//定义类
class StudentCglib{
    private String name;

    public StudentCglib() {
    }

    public StudentCglib(String name) {
        this.name = name;
    }
    public void getUp() {
        System.out.println("人类"+name+"起床");
    }
    public void sleep() {
        System.out.println("人类"+name+"睡觉");
    }
}

    可以通过System.setProperty来设置生成代理类的class文件地址，可以在invoke调用真实类之前附加一些处理，需要使用类来接收代理类，生成的代理类继承自真实类，实现的接口为Factory，里面有类定义的方法，相当于把真实类clone克隆了一份作为代理子类，代理类中有clone方法。

JAVA 23种设计模式示例_第7张图片

十五.桥接模式

     桥接模式Bridge将抽象和实现分离，使它们可以独立变化，它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。

应用场景：

1.当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时；

2.当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时；

3.当一个系统需要在构建的抽象化角色和具体化角色之间增加更多的灵活性时。

优点：

1.抽象和实现分离，扩展能力强；

2.符合开闭原则；

3.符合合成复用原则。

public class BridgeTest {
    public static void main(String[] args) {
        //创建实现化角色
        Animal animal = new Cat();
        //实现化角色，通过创建抽象子类时，注入进去；通过创建的子类进行桥接，使其可以调用到实现化角色
        Behavior behavior = new SubBehavior1(animal);
        behavior.wakeUp();
        //也可以使用其他组合
        behavior = new SubBehavior2(new Sheep());
        behavior.wakeUp();
    }
}

//定义接口-实现化角色
interface Animal{
    void operation();
}

//具体实现化角色
class Cat implements Animal{
    @Override
    public void operation() {
        System.out.println("小猫...");
    }
}

//具体实现化角色
class Sheep implements Animal{
    @Override
    public void operation() {
        System.out.println("山羊");
    }
}

//定义抽象化角色
abstract class Behavior{
    //注入实现化角色
    Animal animal;

    public Behavior(Animal animal) {
        this.animal = animal;
    }

    abstract public void wakeUp();
}

//扩展抽象化角色--桥接
class SubBehavior1 extends Behavior{
    public SubBehavior1(Animal animal) {
        super(animal);
    }

    @Override
    public void wakeUp() {
        System.out.println("扩展抽象化1调用：wakeUp");
        animal.operation();
    }
}

//扩展抽象化角色--桥接
class SubBehavior2 extends Behavior{
    public SubBehavior2(Animal animal) {
        super(animal);
    }

    @Override
    public void wakeUp() {
        System.out.println("扩展抽象化2调用：wakeUp");
        animal.operation();
    }
}

十六.组合模式

     组合模式Composite有时候又叫做整体-部分模式，它是一种将对象组合成树状的层次结构模式，用来表示整体-部分的关系，是用户对单个对象和组合对象有一致的访问性，属于结构形设计模式。它将对象组织到树形结构中，顶层的节点被称为根节点，根节点下面可以包含树枝节点和叶子节点，树枝节点下面又可以包含树枝节点和叶子节点，树形结构图如下：

JAVA 23种设计模式示例_第8张图片

应用场景：

1.在需要表示一个对象整体与部分的层次结构的场合；

2.要求对用户隐藏组合对象与单个对象的不同，用户可以用统一的接口使用组合结构中的所有对象的场合。

优点：

1.组合模式使得客户端代码可以一致的处理当个对象和组合对象，无须关心自己处理的是单个对象还是组合对象，简化了客户端代码；

2.更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而改变源代码，满足开闭原则。

①透明方式

      在该方式中，由于抽象构件声明了所有子类中的方法，所以客户端无须区别树叶对象和树枝对象，对客户端来说是透明的。但其缺点是：树叶构件中没有add（）、remove（）、getChild（）方法，却要实现他们（空实现或抛异常），这样会带来一些安全性问题。

例如使用组合模式组织这样的数型图：

JAVA 23种设计模式示例_第9张图片

public class TransparentCompositeTest {
    public static void main(String[] args) {
        Component composite0 = new Composite();
        Component composite1 = new Composite();
        Component left1 = new Leaf("1");
        Component left2 = new Leaf("2");
        Component left3 = new Leaf("3");
        composite0.add(left1);
        composite0.add(composite1);
        composite1.add(left2);
        composite1.add(left3);
        composite0.operate();
    }
}

//抽象构件-定义子类需要的所有方法
interface Component{
    void add(Component component);
    void remove(Component component);
    Component getChild(int index);
    void operate();
}

//树叶构件-没有添加、删除、获取子类的方法实现
class Leaf implements Component{

    private String name;

    public Leaf(String name) {
        this.name = name;
    }

    @Override
    public void add(Component component) {

    }

    @Override
    public void remove(Component component) {

    }

    @Override
    public Component getChild(int index) {
       return null;
    }

    @Override
    public void operate() {
        System.out.println("叶子："+name+"被访问");
    }
}

//树枝构件-包含它下面的子类集合
class Composite implements Component{

    private List childList = new ArrayList();

    @Override
    public void add(Component component) {
        childList.add(component);
    }

    @Override
    public void remove(Component component) {
       childList.remove(component);
    }

    @Override
    public Component getChild(int index) {
       return childList.get(index);
    }

    @Override
    public void operate() {
        for(Component component : childList){
            component.operate();
        }
    }
}

 ②安全方式

       在该方式中，将管理子构件的方法放到树枝构件中，抽象构件和树叶构件没有对子对象的管理方法，这样就避免了透明方式的安全性问题，但由于叶子和树枝有不同的接口，客户端在调用时要知道树叶对象和树枝对象的存在，所以失去了透明性。

public class SafeCompositeTest {
    public static void main(String[] args) {
        CompositeSafe compositeSafe0 = new CompositeSafe();
        CompositeSafe compositeSafe1 = new CompositeSafe();
        ComponentSafe leaf1 = new LeafSafe("1");
        ComponentSafe leaf2 = new LeafSafe("2");
        ComponentSafe leaf3 = new LeafSafe("3");
        compositeSafe0.add(leaf1);
        compositeSafe0.add(compositeSafe1);
        compositeSafe1.add(leaf2);
        compositeSafe1.add(leaf3);
        compositeSafe0.operate();
    }
}

//抽象构件-只定义公共的方法
interface ComponentSafe{
    void operate();
}

//树叶构件
class LeafSafe implements ComponentSafe{
    private String name;

    public LeafSafe(String name) {
        this.name = name;
    }

    @Override
    public void operate() {
        System.out.println("叶子："+name+"被调用");
    }
}

//树枝构建
class CompositeSafe implements ComponentSafe{

    private List childList = new ArrayList();

    public void add(ComponentSafe componentSafe){
        childList.add(componentSafe);
    }

    public void remove(ComponentSafe componentSafe){
        childList.remove(componentSafe);
    }

    public ComponentSafe getChild(int index){
        return childList.get(index);
    }

    @Override
    public void operate() {
        for(ComponentSafe componentSafe : childList){
            componentSafe.operate();
        }
    }
}

十七.命令模式

     命令模式Command将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开，这样两者之间通过命令对象进行沟通，这样方便将命令对象进行存储、传递、调用、增加和管理。

应用场景：

1.请求调用者需要和请求接收者解耦时，命令模式可以使调用者和接收者不直接交互；

2.系统随机请求命令或经常增加、删除命令时，命令模式可以方便的实现这些功能；

3.当系统需要支持命令的撤销（Undo）操作和恢复（Redo）操作时，可以将命令对象存储起来，采用备忘录模式来实现。

优点：

1.通过引入中间件（抽象接口）降低系统的耦合度；

2.扩展性良好，增加或删除命令非常方便，采用命令模式增加或删除命令不会影响其他类，且满足开闭原则；

3.可以实现宏命令，命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令；

4.方便实现Undo和Redo操作，命令模式可以与备忘录模式结合使用，实现命令的撤销和恢复；

5.可以在现有命令的基础上，增加而外功能，例如日志记录。

public class CommandTest {
    public static void main(String[] args) {
        //创建翻上一个视频的命令对象
        Command upVideoCommand = new UpVideoCommand();
        //创建关闭电视机的命令对象
        Command closeVideoCommand = new CloseVideoCommand();
        //创建调用者
        ControllerInvoker controllerInvoker = new ControllerInvoker();
        //把可以调用的命令设置到调用者中
        controllerInvoker.setUpVideoCommand(upVideoCommand);
        controllerInvoker.setCloseVideoCommand(closeVideoCommand);
        //调用者调用方法-翻上一个视频
        controllerInvoker.upVideo();
        //调用者调用方法-关闭电视机
        controllerInvoker.closeVideo();
    }
}

//抽象命令类
interface Command{
    void execute();
}

//具体命令类-翻上一个视频操作
class UpVideoCommand implements Command{
    //注入此命令的接收者
    private VideoTopReceiver videoTopReceiver;

    public UpVideoCommand() {
        videoTopReceiver = new VideoTopReceiver();
    }

    @Override
    public void execute() {
        System.out.println("按了翻上一个视频的按钮");
        //给接收者发送命令
        videoTopReceiver.upVideo();
    }
}

//具体命令类-关闭电视机
class CloseVideoCommand implements Command{
    //注入此命令的接收者
    private VideoReceiver videoReceiver;

    public CloseVideoCommand() {
        videoReceiver = new VideoReceiver();
    }

    @Override
    public void execute() {
        System.out.println("按了关机的按钮");
        //给接收者发送命令
        videoReceiver.closeVideo();
    }
}

//命令实现者-电视机顶盒
class VideoTopReceiver {
    public void upVideo(){
        System.out.println("收到命令，翻上一个台");
    }
}

//命令实现者-电视机
class VideoReceiver{
    public void closeVideo(){
        System.out.println("收到命令，电视机关机");
    }
}

//调用者-遥控器，设置了可以调用的命令
class ControllerInvoker{
    //定义好有哪些命令可以调用
    private Command upVideoCommand,closeVideoCommand;

    public void setUpVideoCommand(Command upVideoCommand) {
        this.upVideoCommand = upVideoCommand;
    }

    public void setCloseVideoCommand(Command closeVideoCommand) {
        this.closeVideoCommand = closeVideoCommand;
    }

    //当按下调用上一个节目的按钮执行的方法
    public void upVideo(){
        upVideoCommand.execute();
    }

    //当按电视关机的按钮执行的方法
    public void closeVideo(){
        closeVideoCommand.execute();
    }
}

十八.状态模式

      状态模式State对有状态的对象，把复杂的判断逻辑提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。

应用场景：
1.当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式；

2.一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。

优点：

1.结构清晰，状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分隔开来，满足单一职责原则；

2.将状态转换化，减少对象间的相互依赖，将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖；

3.状态类职责明确，有利于程序的扩展，通过定义新的子类很容易的增加新的状态和转换。

例如：线程的状态转换

JAVA 23种设计模式示例_第10张图片

public class StateTest {
    public static void main(String[] args) {
        ThreadContext threadContext = new ThreadContext();
        //启动线程，方法执行前状态：新建，执行后状态：变为就绪
        threadContext.start();
        //获取到cpu资源，方法执行前状态：就绪，执行后状态：变为运行
        threadContext.getCpu();
        //中断线程，方法执行前状态：运行，执行后状态：变为阻塞
        threadContext.suspend();
        //恢复线程，方法执行前状态：阻塞，执行后状态：变为就绪
        threadContext.resume();
        //获取到cpu资源，方法执行前状态：就绪，执行后状态：变为运行
        threadContext.getCpu();
        //停止线程 ，方法执行前状态：运行，执行后状态：变为停止
        threadContext.stop();
    }
}

//环境类-存放全局的状态
class ThreadContext{
    //环境类里面放一个记录状态的类，通过该变此对象的值，来改变环境的状态
    ThreadState state;

    //创建环境类的时候，先默认给一个初始的state状态
    public ThreadContext() {
        state = new New();
    }

    //程序运行过程中获取状态
    public ThreadState getState() {
        return state;
    }

    //程序运行过程中，重新设置状态值
    public void setState(ThreadState state) {
        this.state = state;
    }

    //调用启动方法-状态为新建的时候
    public void start(){
        //把state抽象类强转成具体的子类，调用子类的方法，并把环境类传递过去，这样可以在此方法调用后改变state状态值
        ((New)state).start(this);
    }

    //调用获取cpu资源-状态为就绪的时候
    public void getCpu(){
        //把state抽象类强转成具体的子类，调用子类的方法，并把环境类传递过去，这样可以在此方法调用后改变state状态值
        ((Runnable)state).getCpu(this);
    }

    //调用线程中断-状态为运行的时候
    public void suspend(){
        //把state抽象类强转成具体的子类，调用子类的方法，并把环境类传递过去，这样可以在此方法调用后改变state状态值
        ((Running)state).suspend(this);
    }

    //调用线程结束-状态为运行的时候
    public void stop(){
        //把state抽象类强转成具体的子类，调用子类的方法，并把环境类传递过去，这样可以在此方法调用后改变state状态值
        ((Running)state).stop(this);
    }

    //调用线程结束-状态为阻塞的时候
    public void resume(){
        //把state抽象类强转成具体的子类，调用子类的方法，并把环境类传递过去，这样可以在此方法调用后改变state状态值
        ((Blocked)state).resume(this);
    }
}

//抽象状态类
abstract class ThreadState{
    String stateName;
}

//具体状态类-线程新建状态，可以调用启动方法
class New extends ThreadState{
    public New(){
        stateName = "新建状态";
        System.out.println("线程创建.");
    }

    public void start(ThreadContext threadContext){
        System.out.println("调用线程启动方法start()");
        if("新建状态".equals(stateName)){
            //重新设置环境类中state状态变量的值
            threadContext.setState(new Runnable());
        } else {
            System.out.println("线程没有处于新建状态，不允许启动线程");
        }
    }
}

//具体实现类-线程就绪状态，可以调用获取cpu资源的方法
class Runnable extends ThreadState{

    public Runnable() {
        stateName = "就绪状态";
        System.out.println("线程处于就绪状态");
    }

    public void getCpu(ThreadContext threadContext){
        System.out.println("调用线程获取资源方法getCpu()");
        if("就绪状态".equals(stateName)){
            //重新设置环境类中state状态变量的值
            threadContext.setState(new Running());
        } else {
            System.out.println("线程没有处于就绪状态，不允许获取资源");
        }
    }
}

//具体实现类-线程运行状态，可以调用中断、结束线程的方法
class Running extends ThreadState{

    public Running() {
        stateName = "运行状态";
        System.out.println("线程处于运行状态");
    }

    public void suspend(ThreadContext threadContext){
        System.out.println("调用线程中断方法suspend()");
        if("运行状态".equals(stateName)){
            //重新设置环境类中state状态变量的值
            threadContext.setState(new Blocked());
        } else {
            System.out.println("线程没有处于运行状态，不允许中断");
        }
    }

    public void stop(ThreadContext threadContext){
        System.out.println("调用线程结束方法stop()");
        if("运行状态".equals(stateName)){
            //重新设置环境类中state状态变量的值
            threadContext.setState(new Stop());
        } else {
            System.out.println("线程没有处于运行状态，不允许结束");
        }
    }
}

//具体实现类-线程阻塞状态，可以调用恢复线程的方法
class Blocked extends ThreadState{

    public Blocked() {
        stateName = "阻塞状态";
        System.out.println("线程处于阻塞状态");
    }

    public void resume(ThreadContext threadContext){
        System.out.println("调用线程恢复方法resume()");
        if("阻塞状态".equals(stateName)){
            //重新设置环境类中state状态变量的值
            threadContext.setState(new Runnable());
        } else {
            System.out.println("线程没有处于阻塞状态，不允许恢复");
        }
    }
}

//具体实现类-线程结束状态
class Stop extends ThreadState{

    public Stop() {
        stateName = "结束状态";
        System.out.println("线程处于结束状态");
    }
}

十九.中介者模式

     中介者模式Mediator定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立的改变他们之间的交互。

应用场景：

1.当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时；

2.当想创建一个运行于多个类之间的对象，又不想生成新的子类时。

优点：

1.类之间各司其职，符合迪米特法则；

2.降低了对象之间的耦合性，使得对象易于独立的被复用；

3.将对象之间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。

例如：中介者结构图的实现

JAVA 23种设计模式示例_第11张图片

public class MediatorTest {
    public static void main(String[] args) {
        //创建中介者
        Mediator mediator = new ConcreteMediator();
        //创建同事类
        Colleague concreteColleague1 = new ConcreteColleague1();
        Colleague concreteColleague2 = new ConcreteColleague2();
        //把同事类添加到中介者中
        mediator.register(concreteColleague1);
        mediator.register(concreteColleague2);
        //同事类发送消息
        concreteColleague1.send();
        concreteColleague2.send();
    }
}

//抽象中介者
abstract class Mediator{
    //同事类添加到中介者中
    abstract void register(Colleague colleague);
    //转发消息
    abstract void relay(Colleague colleague);
}

//抽象同事类
abstract class Colleague{
    //记录此同事类关联的中介者
    Mediator mediator;
    //接收消息
    abstract void receive();
    //发送消息
    abstract void send();

    //设置此同事类关联的中介者
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }
}

//具体中介者
class ConcreteMediator extends Mediator{
    //记录注册在此中介者中的同事集合
    private List list = new ArrayList();

    @Override
    void register(Colleague colleague) {
        if(!list.contains(colleague)){
            //把同事类添加到它关联的中介者中
            list.add(colleague);
            //给此同事类设置它关联的中介者
            colleague.setMediator(this);
        }
    }

    @Override
    void relay(Colleague c) {
        for(Colleague colleague : list){
            //转发的同事，不包含发消息的同事
            if(!c.equals(colleague)){
                colleague.receive();
            }
        }
    }
}

//具体同事类
class ConcreteColleague1 extends Colleague{

    @Override
    void receive() {
        System.out.println("具体同事类1收到消息");
    }

    @Override
    void send() {
        System.out.println("具体同事类1发送消息");
        //通过此同事类关联的中介者进行消息转发（不包含转发给自己）
        mediator.relay(this);
    }
}

//具体同事类
class ConcreteColleague2 extends Colleague{

    @Override
    void receive() {
        System.out.println("具体同事类2收到消息");
    }

    @Override
    void send() {
        System.out.println("具体同事类2发送消息");
        //通过此同事类关联的中介者进行消息转发（不包含转发给自己）
        mediator.relay(this);
    }

二十.迭代器模式

      迭代器模式Iterator提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

应用场景：

1.当需要为聚合对象提供多种遍历方式时；

2.当需要为遍历不同的聚合结构提供一个统一的接口时；

3.当访问一个聚合对象的内容而无须暴露其内部细节的表示时。

优点：

1.访问一个聚合对象的内容而无须暴露它的内部表示；

2.遍历任务交由迭代器完成，这简化了聚合类；

3.它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历；

4.增加新的聚合类和迭代器类都很方便，无须修改原有代码；

5.封装性良好，为遍历不同的聚合结构提供一个统一的接口。

public class IteratorTest {

    public static void main(String[] args) {
        //创建聚合类
        Aggegate concreteAggegate = new ConcreteAggegate();
        //向聚合类中添加对象
        concreteAggegate.add("苹果");
        concreteAggegate.add("橘子");
        concreteAggegate.add("香蕉");
        concreteAggegate.add("芒果");
        //把聚合类中的集合对象作为参数传递到迭代器中，创建迭代器
        Iterator iterator = concreteAggegate.getIterator();
        //遍历数据
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("遍历结束");
        System.out.println(iterator.first());
        System.out.println(iterator.hasNext());
        System.out.println(iterator.next());
        System.out.println(iterator.previous());
        System.out.println(iterator.last());
        System.out.println(iterator.hasNext());
    }
}

//聚合抽象类
interface Aggegate{
    //添加元素到集合中
    void add(Object object);
    //从集合中移出元素
    void remove(Object object);
    //获得迭代器
    Iterator getIterator();
}

//抽象迭代器类
interface Iterator{
    //获取第一个元素
    Object first();
    //获取下一个元素
    Object next();
    //获取前一个元素
    Object previous();
    //获取最后一个元素
    Object last();
    //是否还有下一个元素
    boolean hasNext();
}

//具体聚合类
class ConcreteAggegate implements Aggegate{
    //定义一个集合，用于存放加入到聚合类中的对象
    private List list = new ArrayList();

    @Override
    public void add(Object object) {
        list.add(object);
    }

    @Override
    public void remove(Object object) {
        list.remove(object);
    }

    @Override
    public Iterator getIterator() {
        return new ConcreteIterator(list);
    }
}

//具体迭代器
class ConcreteIterator implements Iterator{
    //定义一个集合，用于接收聚合类中的集合对象
    private List list = new ArrayList();
    //迭代器的索引
    int index = -1;

    public ConcreteIterator(List list) {
        this.list = list;
    }

    @Override
    public Object first() {
        index = 0;
        return list.get(index);
    }

    @Override
    public Object next() {
        if(this.hasNext()){
            return list.get(++index);
        }
        return null;
    }

    @Override
    public Object previous() {
        if(index > 0) {
            return list.get(--index);
        }else {
            return null;
        }
    }

    @Override
    public Object last() {
        index = list.size()-1;
        return list.get(index);
    }

    @Override
    public boolean hasNext() {
        if(index >= list.size()-1){
            return false;
        }
        return true;
    }
}
 
  
二十一.访问者模式
 
  
      访问者模式visitor将作用于某种数据结构中的各元素的操作分离出来分装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方式，它将对数据的操作与数据结构进行分离。
 
  
应用场景：
 
  
1.对象结构相对稳定，但其操作算法经常变化的程序；
 
  
2.对象结构中的对象需要提供多种不同且不相关的操作，而且要避免让这些操作的变化影响对象的结构。
 
  
3.对象结构包含很多类型的对象，希望对这些对象实施一些依赖于其具体类型的操作。
 
  
优点：
 
  
1.扩展性好，能够在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能；
 
  
2.复用性好，可以通过访问者来定义整个对象结构通用的功能，从而提高系统的复用程度；
 
  
3.灵活性好，访问者模式将数据结构和作用于结构上的操作解耦，是的操作集合可相对自由的演化而不影响系统的数据结构；
 
  
4.符合单一职责原则，访问者模式把相关的行为封装在一起，构成一个访问者，使每个访问者的功能都比较单一。
 
  
public class VisitorTest {
    public static void main(String[] args) {
        //创建结构对象
        ObjectStructure objectStructure = new ObjectStructure();
        //添加可以访问的元素
        ConcreteElements1 concreteElements1 = new ConcreteElements1();
        ConcreteElements2 concreteElements2 = new ConcreteElements2();
        objectStructure.add(concreteElements1);
        objectStructure.add(concreteElements2);
        //创建访问对象
        Visitor visitor = new ConcreteVisitor1();
        //结构对象接受visitor访问者的访问，遍历结构对象中存的所有元素接受访问
        objectStructure.accept(visitor);
    }
}

//抽象访问者
interface Visitor{
    //访问哪个元素，元素作为参数
    void visit(ConcreteElements1 elements);
    void visit(ConcreteElements2 elements);
}

//抽象元素
interface Elements{
    //接收谁的访问，访问者作为参数传递进来
    void accept(Visitor vistor);
}

//具体访问者
class ConcreteVisitor1 implements Visitor{

    @Override
    public void visit(ConcreteElements1 elements) {
        System.out.print("具体访问者1访问-》");
        elements.operator1();
    }

    @Override
    public void visit(ConcreteElements2 elements) {
        System.out.print("具体访问者1访问-》");
        elements.operator2();
    }
}

//具体元素
class ConcreteElements1 implements Elements{

    //元素接收访问
    @Override
    public void accept(Visitor visitor) {
        //当前元素接受visitor的访问，调用visitor的访问方法
        visitor.visit(this);
    }

    public void operator1(){
        System.out.println("元素1");
    }
}

//具体元素
class ConcreteElements2 implements Elements{

    //元素接收访问
    @Override
    public void accept(Visitor visitor) {
        //当前元素接受visitor的访问
        visitor.visit(this);
    }

    public void operator2(){
        System.out.println("元素2");
    }
}

//对象结构
class ObjectStructure{
    //存放有哪些元素可以访问
    List list = new ArrayList();

    //添加元素到集合
    public void add(Elements elements){
        list.add(elements);
    }

    //接受访问-接受谁的方法，作为参数传递进来
    public void accept(Visitor visitor){
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            //让元素接受某个访问者的访问
            iterator.next().accept(visitor);
        }

    }

}

 
  
二十二.备忘录模式
 
  
       备忘录模式Memento在不破坏封装性的前提下，捕获一个对象的内部状态，并在改对象之外保存这个状态，以便以后当需要时能将该对象恢复到原先保存的状态，该模式又叫快照模式。
 
  
应用场景：
 
  
1.需要保存与恢复数据的场景，如玩游戏时的中间结果存档功能；
 
  
2.需要提供一个可回滚操作的场景，如Word、记事本、Photoshop、Eclipse等软件在编辑时按Ctrl+Z组合键，还有数据库中事务操作。
 
  
优点：
 
  
1.提供了一种可以恢复状态的机制，当用户需要时能够比较方便的将数据恢复到某个历史状态；
 
  
2.实现了内部状态的封装，除了创建它的发起人之外，其它对象都不能够访问这些状态信息；
 
  
3.简化了发起人类，发起人不需要管理和保存其内部状态的各个备份，所有状态信息都保存在备忘录中，并由管理者进行管理，这符合单一职责原则。
 
  
public class MementoTest {
    public static void main(String[] args) {
        //创建管理者
        Caretaker caretaker = new Caretaker();
        //创建发起者
        Originator originator = new Originator();
        originator.setState("0");
        //创建备份
        Memento memento = originator.createMemento();
        //备份添加到管理者中
        caretaker.push(memento);
        originator.setState("1");
        //备份添加到管理者中
        caretaker.push(originator.createMemento());
        originator.setState("2");
        System.out.println("当前状态值:"+originator.getState());
        //第一次还原
        originator.restoreMemento(caretaker.pop());
        System.out.println("第一次还原状态值:"+originator.getState());
        //第二次还原
        originator.restoreMemento(caretaker.pop());
        System.out.println("第二次还原状态值:"+originator.getState());
    }
}

//备忘录实体-需要记录发起人存放的所有字符值
class Memento{
    //字段，与发起人实体中相同的字段
    private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

//发起人角色
class Originator{
    private String state;

    //创建备份录
    public Memento createMemento(){
        //把需要备份的字段都传递到备份类实体中进行备份
        return new Memento(state);
    }

    //恢复备份-通过某个备份文件还原当前发起人的数据
    public void restoreMemento(Memento memento){
        //把备份类记录的值还原到发起人类对应的字段中
        this.state = memento.getState();
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

//管理者-记录着备份的对象
class Caretaker{
    //使用栈记录备份的记录，栈的特性：先进后出，符合还原操作
    private Stack stack = new Stack();

    //添加备份到栈
    public void push(Memento memento) {
        stack.push(memento);
    }

    //还原时，从栈中拿出备份的记录
    public Memento pop(){
        return stack.pop();
    }
}

 
  
二十三.解释器模式
 
  
      解释器模式Interpreter给分析对象定义一个语言，并定义该语言的文法表示，再设计一个解析器来解释语言中的句子。也就是说，用编译语言的方式来分析应用中的实例，这种模式实现了文法表达式处理的接口，该接口解释一个特定的上下文。
 
  
应用场景：
 
  
1.当语言的文法比较简单，且执行效率不是关键问题时；
 
  
2.当问题重复出现，且可以用一种简单的语言来进行表达时；
 
  
3.当一个语言需要解释执行，并且语言中的句子可以表示为一个抽象语法树的时候。
 
  
优点：
 
  
1.扩展性好，由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法；
 
  
2.容易实现，在语法树中的每个表达式节点类都是相似的，所以实现其文法较为简单。
 
  
public class InterpreterTest {
    public static void main(String[] args) {
        Context context = new Context();
        context.checkMes("军人的子女");
        context.checkMes("军人的妻子");
        context.checkMes("工人的子女");
        context.checkMes("警察的父母");
        context.checkMes("警察的朋友");
    }
}

//抽象表达式
interface AbstractExpression{
    //接收某个输入的信息
    boolean interprete(String info);
}

//终结者表达式-名词、代词
class TerminalExpression implements AbstractExpression{

    //定义集合存放允许的词
    private List list = new ArrayList();

    //创建对象时，需要给出允许的词
    public TerminalExpression(String[] arrStr) {
        for(int i = 0;i < arrStr.length;i++){
            list.add(arrStr[i]);
        }
    }

    @Override
    public boolean interprete(String info) {
        //包含这个此，返回true
        if(list.contains(info)){
            return true;
        }
        return false;
    }
}

//非终结者表达式-谓语（动词）
class NonTerminalExpression implements AbstractExpression{
    //记录终结者表达式的对象
    private AbstractExpression jobExpression;
    private AbstractExpression persionExpression;

    public NonTerminalExpression(AbstractExpression jobExpression, AbstractExpression persionExpression) {
        this.jobExpression = jobExpression;
        this.persionExpression = persionExpression;
    }

    @Override
    public boolean interprete(String info) {
        //非终结者进行分词
        String[]  arr = info.split("的");
        //判断是否包含
        return jobExpression.interprete(arr[0]) && persionExpression.interprete(arr[1]);
    }
}

//环境角色
class Context{
    //定义允许的此
    String[] jobArr = {"军人","警察"};
    String[] persionArr = {"父母","子女"};

    //定义一个非终结表达式对象
    AbstractExpression nonTerminalExpression;

    public Context() {
        //创建终结者表达式对象
        TerminalExpression job = new TerminalExpression(jobArr);
        TerminalExpression persion = new TerminalExpression(persionArr);
        nonTerminalExpression = new NonTerminalExpression(job, persion);
    }

    //输入一个字符判断是否符合表达式
    public void checkMes(String info){
        boolean interprete = nonTerminalExpression.interprete(info);
        if(interprete){
            System.out.println(info+"可以享受优先的政策");
        } else {
            System.out.println(info+"正常排队");
        }
    }
}


 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(知识笔记,程序人生,java,设计模式,单例模式,工厂模式,代理模式)

        

            

                
    
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • 数据仓库——维度表一致性
                        墨染丶eye
背诵数据仓库
                        
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                                
  • rust的指针作为函数返回值是直接传递，还是先销毁后创建？
                                    wudixiaotie
返回值
                                    
     这是我自己想到的问题，结果去知呼提问，还没等别人回答， 我自己就想到方法实验了。。 
fn main() {
    let mut a = 34;
    println!("a's addr:{:p}", &a);
    let p = &mut a;
    println!("p's addr:{:p}", &a
    
                                
    • 
                                
  • java编程思想 -- 数据的初始化
                                    百合不是茶
java数据的初始化
                                    
      
1.使用构造器确保数据初始化 
     
/*
 *在ReckInitDemo类中创建Reck的对象 
 */
public class ReckInitDemo {
	

	public static void main(String[] args) {
		//创建Reck对象
		new Reck();
	}
	
	
}
    
                                
    • 
                                
  • [航天与宇宙]为什么发射和回收航天器有档期
                                    comsci

                                    
     
 
 
       地球的大气层中有一个时空屏蔽层,这个层次会不定时的出现,如果该时空屏蔽层出现,那么将导致外层空间进入的任何物体被摧毁,而从地面发射到太空的飞船也将被摧毁... 
 
       所以,航天发射和飞船回收都需要等待这个时空屏蔽层消失之后,再进行 
 
&
    
                                
    • 
                                
  • linux下批量替换文件内容
                                    商人shang
linux替换
                                    
    1、网络上现成的资料 
　　格式: sed -i "s/查找字段/替换字段/g" `grep 查找字段 -rl 路径` 
　　linux sed 批量替换多个文件中的字符串 
　　sed -i "s/oldstring/newstring/g" `grep oldstring -rl yourdir` 
　　例如：替换/home下所有文件中的www.admi
    
                                
    • 
                                
  • 网页在线天气预报
                                    oloz
天气预报
                                    
    网页在线调用天气预报

<%@ page language="java" contentType="text/html; charset=utf-8"
 pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transit
    
                                
    • 
                                
  • SpringMVC和Struts2比较
                                    杨白白
springMVC
                                    
    1. 入口 
spring mvc的入口是servlet，而struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这样就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。 
参见：http://blog.csdn.net/zs15932616453/article/details/8832343 
2
    
                                
    • 
                                
  • refuse copy, lazy girl!
                                    小桔子
copy
                                    
           妹妹坐船头啊啊啊啊！都打算一点点琢磨呢。文字编辑也写了基本功能了。。今天查资料，结果查到了人家写得完完整整的。我清楚的认识到： 
1.那是我自己觉得写不出的高度 
2.如果直接拿来用，很快就能解决问题 
3.然后就是抄咩~~ 
4.肿么可以这样子，都不想写了今儿个，留着作参考吧！拒绝大抄特抄，慢慢一点点写！ 
  
    
                                
    • 
                                
  • apache与php整合
                                    aichenglong
php apache web
                                    
    一  apache web服务器 
 1 apeche web服务器的安装 
  1)下载Apache web服务器 
  2)配置域名(如果需要使用要在DNS上注册) 
  3)测试安装访问http://localhost/验证是否安装成功 
 2 apache管理 
  1)service.msc进行图形化管理 
  2)命令管理，配
    
                                
    • 
                                
  • Maven常用内置变量
                                    AILIKES
maven
                                    
    Built-in properties 
 
  ${basedir} represents the directory containing pom.xml 
  ${version} equivalent to ${project.version} (deprecated: ${pom.version})  
 Pom/Project properties 
Al
    
                                
    • 
                                
  • java的类和对象
                                    百合不是茶
JAVA面向对象 类 对象
                                    
    java中的类： 
  
  java是面向对象的语言，解决问题的核心就是将问题看成是一个类，使用类来解决 
  
java使用 class 类名   来创建类 ，在Java中类名要求和构造方法，Java的文件名是一样的 
  
创建一个A类： 
class A{
} 
  
java中的类：将某两个事物有联系的属性包装在一个类中，再通
    
                                
    • 
                                
  • JS控制页面输入框为只读
                                    bijian1013
JavaScript
                                    
    在WEB应用开发当中，增、删除、改、查功能必不可少，为了减少以后维护的工作量，我们一般都只做一份页面，通过传入的参数控制其是新增、修改或者查看。而修改时需将待修改的信息从后台取到并显示出来，实际上就是查看的过程，唯一的区别是修改时，页面上所有的信息能修改，而查看页面上的信息不能修改。因此完全可以将其合并，但通过前端JS将查看页面的所有信息控制为只读，在信息量非常大时，就比较麻烦。 
  
    
                                
    • 
                                
  • AngularJS与服务器交互
                                    bijian1013
JavaScriptAngularJS$http
                                    
            对于AJAX应用（使用XMLHttpRequests）来说，向服务器发起请求的传统方式是：获取一个XMLHttpRequest对象的引用、发起请求、读取响应、检查状态码，最后处理服务端的响应。整个过程示例如下： 
var xmlhttp = new XMLHttpRequest();

xmlhttp.onreadystatechange
    
                                
    • 
                                
  • [Maven学习笔记八]Maven常用插件应用
                                    bit1129
maven
                                    
    常用插件及其用法位于：http://maven.apache.org/plugins/ 
  
1. Jetty server plugin 
2. Dependency copy plugin 
3. Surefire Test plugin 
4. Uber jar plugin 
  
  
  
  
  
1. Jetty Pl
    
                                
    • 
                                
  • 【Hive六】Hive用户自定义函数(UDF)
                                    bit1129
自定义函数
                                    
    1. 什么是Hive UDF 
Hive是基于Hadoop中的MapReduce，提供HQL查询的数据仓库。Hive是一个很开放的系统，很多内容都支持用户定制，包括： 
 
 文件格式：Text File，Sequence File 
 内存中的数据格式： Java Integer/String, Hadoop IntWritable/Text 
 用户提供的 map/reduce 脚本：不管什么
    
                                
    • 
                                
  • 杀掉nginx进程后丢失nginx.pid，如何重新启动nginx
                                    ronin47
nginx 重启 pid丢失
                                    
    nginx进程被意外关闭，使用nginx -s reload重启时报如下错误：nginx: [error] open() “/var/run/nginx.pid” failed (2: No such file or directory)这是因为nginx进程被杀死后pid丢失了，下一次再开启nginx -s reload时无法启动解决办法：nginx -s reload 只是用来告诉运行中的ng
    
                                
    • 
                                
  • UI设计中我们为什么需要设计动效
                                    brotherlamp
UIui教程ui视频ui资料ui自学
                                    
    随着国际大品牌苹果和谷歌的引领，最近越来越多的国内公司开始关注动效设计了，越来越多的团队已经意识到动效在产品用户体验中的重要性了，更多的UI设计师们也开始投身动效设计领域。 
但是说到底，我们到底为什么需要动效设计？或者说我们到底需要什么样的动效？做动效设计也有段时间了，于是尝试用一些案例，从产品本身出发来说说我所思考的动效设计。 
一、加强体验舒适度 
嗯，就是让用户更加爽更加爽的用你的产品。 
    
                                
    • 
                                
  • Spring中JdbcDaoSupport的DataSource注入问题
                                    bylijinnan
javaspring
                                    
    参考以下两篇文章： 
 
http://www.mkyong.com/spring/spring-jdbctemplate-jdbcdaosupport-examples/ 
 
http://stackoverflow.com/questions/4762229/spring-ldap-invoking-setter-methods-in-beans-configuration 
 
Sprin
    
                                
    • 
                                
  • 数据库连接池的工作原理
                                    chicony
数据库连接池
                                    
           随着信息技术的高速发展与广泛应用，数据库技术在信息技术领域中的位置越来越重要，尤其是网络应用和电子商务的迅速发展，都需要数据库技术支持动 态Web站点的运行，而传统的开发模式是：首先在主程序（如Servlet、Beans）中建立数据库连接；然后进行SQL操作，对数据库中的对象进行查 询、修改和删除等操作；最后断开数据库连接。使用这种开发模式，对
    
                                
    • 
                                
  • java 关键字
                                    CrazyMizzz
java
                                    
     
关键字是事先定义的，有特别意义的标识符，有时又叫保留字。对于保留字，用户只能按照系统规定的方式使用，不能自行定义。 
 
Java中的关键字按功能主要可以分为以下几类： 
   （1）访问修饰符 
      public,private,protected 
      p
    
                                
    • 
                                
  • Hive中的排序语法
                                    daizj
排序hiveorder byDISTRIBUTE BYsort by
                                    
    Hive中的排序语法 2014.06.22  ORDER BY 
hive中的ORDER BY语句和关系数据库中的sql语法相似。他会对查询结果做全局排序，这意味着所有的数据会传送到一个Reduce任务上，这样会导致在大数量的情况下，花费大量时间。 
与数据库中 ORDER BY 的区别在于在hive.mapred.mode = strict模式下，必须指定 limit 否则执行会报错。
    
                                
    • 
                                
  • 单态设计模式
                                    dcj3sjt126com
设计模式
                                    
      单例模式（Singleton）用于为一个类生成一个唯一的对象。最常用的地方是数据库连接。 使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。    
<?phpclass Example{    // 保存类实例在此属性中    private static&
    
                                
    • 
                                
  • svn locked
                                    dcj3sjt126com
Lock
                                    
    post-commit hook failed (exit code 1) with output: 
svn: E155004: Working copy 'D:\xx\xxx' locked 
svn: E200031: sqlite: attempt to write a readonly database 
svn: E200031: sqlite: attempt to write a 
    
                                
    • 
                                
  •  ARM寄存器学习
                                    e200702084
数据结构C++cC#F#
                                    
    无论是学习哪一种处理器，首先需要明确的就是这种处理器的寄存器以及工作模式。 
    ARM有37个寄存器，其中31个通用寄存器，6个状态寄存器。 
1、不分组寄存器（R0-R7） 
    不分组也就是说说，在所有的处理器模式下指的都时同一物理寄存器。在异常中断造成处理器模式切换时，由于不同的处理器模式使用一个名字相同的物理寄存器，就是
    
                                
    • 
                                
  • 常用编码资料
                                    gengzg
编码
                                    
    		List<UserInfo> list=GetUserS.GetUserList(11);
		String json=JSON.toJSONString(list);
		HashMap<Object,Object> hs=new HashMap<Object, Object>();
		for(int i=0;i<10;i++)
		{

    
                                
    • 
                                
  • 进程 vs. 线程
                                    hongtoushizi
线程linux进程
                                    
    我们介绍了多进程和多线程，这是实现多任务最常用的两种方式。现在，我们来讨论一下这两种方式的优缺点。 
首先，要实现多任务，通常我们会设计Master-Worker模式，Master负责分配任务，Worker负责执行任务，因此，多任务环境下，通常是一个Master，多个Worker。 
如果用多进程实现Master-Worker，主进程就是Master，其他进程就是Worker。 
如果用多线程实现
    
                                
    • 
                                
  • Linux定时Job：crontab -e 与 /etc/crontab 的区别
                                    Josh_Persistence
linuxcrontab
                                    
    一、linux中的crotab中的指定的时间只有5个部分：* * * * * 
分别表示：分钟，小时，日，月，星期，具体说来： 
第一段 代表分钟 0—59 
第二段 代表小时 0—23 
第三段 代表日期 1—31 
第四段 代表月份 1—12 
第五段 代表星期几，0代表星期日 0—6 
  
如： 
*/1 * * * *   每分钟执行一次。 
* 
    
                                
    • 
                                
  • KMP算法详解
                                    hm4123660
数据结构C++算法字符串KMP
                                    
         字符串模式匹配我们相信大家都有遇过，然而我们也习惯用简单匹配法（即Brute-Force算法)，其基本思路就是一个个逐一对比下去，这也是我们大家熟知的方法，然而这种算法的效率并不高，但利于理解。 
  
    假设主串s="ababcabcacbab",模式串为t="
    
                                
    • 
                                
  • 枚举类型的单例模式
                                    zhb8015
单例模式
                                    
    E.编写一个包含单个元素的枚举类型[极推荐]。代码如下： 
 
 public enum MaYun {himself; //定义一个枚举的元素，就代表MaYun的一个实例private String anotherField;MaYun() {//MaYun诞生要做的事情//这个方法也可以去掉。将构造时候需要做的事情放在instance赋值的时候：/** himself = MaYun() {*
    
                                
    • 
                                
  • Kafka+Storm+HDFS
                                    ssydxa219
storm
                                    
    cd /myhome/usr/stormbin/storm nimbus &amp;bin/storm supervisor &amp;bin/storm ui &amp;Kafka+Storm+HDFS整合实践kafka_2.9.2-0.8.1.1.tgzapache-storm-0.9.2-incubating.tar.gzKafka安装配置我们使用3台机器搭建Kafk
    
                                
    • 
                                
  • Java获取本地服务器的IP
                                    中华好儿孙
javaWeb获取服务器ip地址
                                    
    
        System.out.println("getRequestURL:"+request.getRequestURL());
		System.out.println("getLocalAddr:"+request.getLocalAddr());
		System.out.println("getLocalPort:&quo
    
                                
    •