凌木LSJ
凌木LSJ

设计模式JAVA

1 创建型

如何合理的创建对象？

1.1 单例模式

字面意思就是只能创建一个对象实例时使用。

例如，Windows中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。

特点：全局就这一个对象时

懒汉式的实现方式如下：

/**
 * 懒汉单例模式
 */
public class SingleLazyDemo {

    //避免在外部被实例化
    private SingleLazyDemo() {
    }

    private static volatile SingleLazyDemo instance = null;

    //实例化
    public static synchronized SingleLazyDemo getInstance(){
        if(instance == null){
            instance = new SingleLazyDemo();
        }
        return  instance;
    }
    
}

测试效果如下： 

 设计模式JAVA_第1张图片

设计模式JAVA_第2张图片

 饿汉式实现方式如下：

public class SingleHungryDemo {
    //避免在外部被实例化
    private SingleHungryDemo() {
    }

    private static final SingleHungryDemo instance ;
    //一旦加载就创建一个单例
    static {
        instance = new SingleHungryDemo();
    }

    //实例化
    public static synchronized SingleHungryDemo getInstance(){
        return instance;
    }
}

饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题。

1.2 原型模式

特点：应用于克隆型对象创建，拷贝原型创建新的对象

原型模式的克隆分为浅克隆和深克隆，Java中的Object类提供了浅克隆的clone()方法，具体原型类只要实现Cloneable接口就可实现对象的浅克隆。

浅克隆的实现方式如下：

import lombok.Data;

@Data
public class PrototypeShallowDemo implements Cloneable{

    private String name;
    private String describe;

    public PrototypeShallowDemo(String name,String describe){
        this.name = name;
        this.describe = describe;
    }

    @Override
    public String toString(){
        return "my name is " + name + ", my info is " + describe;
    }

    protected Object clone() throws CloneNotSupportedException{
        return super.clone();
    }

}

测试效果如下：

设计模式JAVA_第3张图片

浅拷贝的特点：

  • 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象；
  • 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，即克隆一份地址。 

深拷贝可以使用对象序列化的方式实现：

@Data
public class PrototypeDeepDemo implements Cloneable, Serializable {
    private String name;
    private PrototypeShallowDemo prototypeShallowDemo;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object object = super.clone();
        PrototypeDeepDemo prototypeDeepDemo = (PrototypeDeepDemo) object;
        prototypeDeepDemo.prototypeShallowDemo = (PrototypeShallowDemo) prototypeShallowDemo.clone();
        return object;
    }
}

1.3 工厂方法模式

特点：创建于使用分离，将创建的对象作为“产品”，把创建产品的对象称为“工厂”。

满足“开闭原则”的前提下，客户随意增删或改变对软件相关对象的使用。

首先实现要生产的产品：

//定一个产品类
public interface Product {
    public String Show();
}

//具体产品1
public class ProductCoffee implements Product{
    @Override
    public String Show() {
        return "this is coffee";
    }
}

//具体产品2
public class ProductPhone implements Product{
    @Override
    public String Show() {
        return "this is phone";
    }
}

然后实现生产工厂：

//定义一个抽象工厂，使用接口interface或者抽象abstract
public interface AbstractFactory {
    public Product CreateProduct();
}

//具体的生产工厂1
public class FactoryCoffee implements AbstractFactory{
    @Override
    public Product CreateProduct() {
        return new ProductCoffee();
    }
}

//具体的生产工厂2
public class FactoryPhone implements AbstractFactory{
    @Override
    public Product CreateProduct() {
        return new ProductPhone();
    }
}

测试实例，调用不同的工厂生产产品：

    @GetMapping("/demo4")
    public String demo4() {
        FactoryCoffee factoryCoffee = new FactoryCoffee();
        Product product = factoryCoffee.CreateProduct();
        FactoryPhone factoryPhone = new FactoryPhone();
        return product.Show() + "______" + factoryPhone.CreateProduct().Show();
    }

设计模式JAVA_第4张图片

 1.4 抽象工厂模式

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

使用抽象工厂模式一般要满足以下条件。

① 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。

② 系统一次只可能消费其中某一族产品，即同族的产品一起使用。

设计模式JAVA_第5张图片

在抽象工厂模式包含如下几个角色：

  • AbstractFactory（抽象工厂）：它声明了一组用于创建一族产品的方法，每一个方法对应一种产品。
  • ConcreteFactory（具体工厂）：它实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中。
  • AbstractProduct（抽象产品）：它为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法
  • ConcreteProduct（具体产品）：它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。

1）创建抽象产品和具体产品

//抽象产品1
public abstract class Animal {
    public abstract void getName();
    public abstract void addFood();
    public abstract void getColor();
}

//具体动物1
public class Horse extends Animal{
    @Override
    public void getName() {
        System.out.println("this name is horse");
    }

    @Override
    public void addFood() {
        System.out.println("添加食物");
    }

    @Override
    public void getColor() {
        System.out.println("白色");
    }
}

//具体动物2
public class Cattle extends Animal{
    @Override
    public void getName() {
        System.out.println("this name is cattle");
    }

    @Override
    public void addFood() {
        System.out.println("添加食物");
    }

    @Override
    public void getColor() {
        System.out.println("黑色");
    }
}

//抽象产品2
public abstract class Plant {
    public abstract void getName();
    public abstract void addWater();
}

//具体植物1
public class Fruit extends Plant{
    @Override
    public void getName() {
        System.out.println("这是水果");
    }

    @Override
    public void addWater() {
        System.out.println("浇水");
    }
}

//具体植物2
public class Vegetable extends Plant{
    @Override
    public void getName() {
        System.out.println("这是蔬菜");
    }

    @Override
    public void addWater() {
        System.out.println("浇水");
    }
}

2）抽象工厂

public interface Farm {
    public Plant createPlant();
    public Animal createAnimal();
}

3）具体工厂

//具体工厂1
public class HongXingFarm implements Farm{
    @Override
    public Plant createPlant() {
        System.out.println("蔬菜产生");
        return new Vegetable();
    }

    @Override
    public Animal createAnimal() {
        System.out.println("牛产生");
        return new Cattle();
    }
}

//具体工厂2
public class MingLeFarm implements Farm{
    @Override
    public Plant createPlant() {
        System.out.println("水果产生");
        return new Fruit();
    }

    @Override
    public Animal createAnimal() {
        System.out.println("马产生");
        return new Horse();
    }
}

 4）测试

    @GetMapping("/demo5")
    public void demo5(){
        Farm farm ;
        Animal animal;
        Plant plant;

        farm = new HongXingFarm();
        animal = farm.createAnimal();
        plant = farm.createPlant();

        animal.getName();
        animal.addFood();

        plant.getName();
        plant.addWater();

    }

设计模式JAVA_第6张图片

1.5 建造者模式

背景：在软件开发过程中有时需要创建一个复杂的对象，这个复杂对象通常由多个子部件按一定的步骤组合而成。例如，计算机是由CPU、主板、内存、硬盘、显卡、机箱、显示器、键盘、鼠标等部件组装而成的。

它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

建造者模式的主要角色如下：

  • 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个组成部件。
  • 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法getResult()。
  • 具体建造者（Concrete Builder）：实现Builder接口，完成复杂产品的各个部件的具体创建方法。
  • 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

1）设计产品构成

public class Product  {
    private  String partA;
    private  String partB;
    private  String partC;

    public void setPartA(String partA) {
        this.partA = partA;
    }
    public void setPartB(String partB) {
        this.partB = partB;
    }
    public void setPartC(String partC) {
        this.partC = partC;
    }

    public void show()
    {
        System.out.println(partA + partB + partC);
    }
}

2）建造者，负责进行产品的组装

public abstract class Builder {
    //创建产品对象
    protected  Product product=new Product();
    public  abstract void buildPartA();
    public  abstract void buildPartB();
    public  abstract void buildPartC();
    //返回产品对象
    public  Product getResult() {
        return  product;
    }
}

3）具体构造者，实现具体的构建细节

public class HongXIngBuilder extends Builder{
    @Override
    public void buildPartA() {
        product.setPartA("建造PartA");
    }

    @Override
    public void buildPartB() {
        product.setPartB("建造PartB");
    }

    @Override
    public void buildPartC() {
        product.setPartC("建造PartC");
    }
}

4）指挥者，选择具体构建者进行构建

public class Director {

    private  Builder builder;

    public  Director(Builder builder) {
        this.builder=builder;
    }

    //产品构建与组装方法
    public Product construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}

5）使用

    @GetMapping("/demo6")
    public void demo6(){
        //选择HongXIngBuilder
        Builder builder1 = new HongXIngBuilder();
        Director director1 = new Director(builder1);
        Product product1 = director1.construct();
        product1.show();
    }

2 结构型

结构型模式字面意思就是设计程序结构的。

2.1 代理模式

代理就类似于中介，某些情况下不能或者不想直接访问另一个对象，这时需要找一个中介帮忙完成某项任务，这个中介就是代理对象。

代理模式的主要角色如下:

  • 抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
  • 真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
  • 代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。

1）抽象主题

public interface Subject {
    void Request();
    void GetInfo();
}

2）真实主题

public class RealSubject implements Subject{
    @Override
    public void Request() {
        System.out.println("【*】开始访问 ");
    }

    @Override
    public void GetInfo() {
        System.out.println("【info】信息展示 "  + new Date());
    }
}

3）代理

public class Proxy implements Subject{

    private RealSubject realSubject;

    @Override
    public void Request() {
        if(realSubject == null){
            realSubject = new RealSubject();
        }
        preRequest();
        realSubject.Request();
        postRequest();
    }

    @Override
    public void GetInfo() {
        if(realSubject == null){
            realSubject = new RealSubject();
        }
        realSubject.GetInfo();
    }

4）使用

    @GetMapping("/demo7")
    public void demo7(){
        Proxy proxy = new Proxy();
        proxy.GetInfo();
        proxy.Request();
    }

设计模式JAVA_第7张图片

 2.2 适配器模式

开发中两个对象因接口不兼容而不能在一起工作的实例，这时需要第三者进行适配。适配器模式就是将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。

适配器模式包含以下主要角色：

  • 目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口。
  • 适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口。
  • 适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。

1）目标接口

public interface Target {

    void Request();
}

2）适配目标类

public class Adapter {

    public void specificRequest(){
        System.out.println("适配具体请求");
    }

}

 3）适配器

public class TargetAdapter extends Adapter implements Target {
    @Override
    public void Request() {
        specificRequest();
    }
}

4）使用

    @GetMapping("/demo8")
    public void demo8(){
        Target target = new TargetAdapter();
        target.Request();
    }

2.3 桥接模式

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

桥接（Bridge）模式包含以下主要角色：

  • 抽象化（Abstraction）角色：定义抽象类，并包含一个对实现化（Implementor）角色的引用。Abstraction 充当桥接类。
  • 扩展抽象化（Refined Abstraction）角色：是抽象化（Abstraction）角色的子类，实现父类中的业务方法，并通过组合关系调用实现化（Implementor）角色中的业务方法。
  • 实现化（Implementor）角色：定义实现化角色的接口，供扩展抽象化（Refined Abstraction）角色调用。
  • 具体实现化（Concrete Implementor）角色：给出实现化（Implementor）角色接口的具体实现。

比如4种类型画笔，3种颜色，实现一个画板：

实现方式1: 四种画笔，每种画笔创建三种颜色，共4 *3 = 12 个类

实现方式2:如下，四个形状具体实现类，三个颜色具体实现类，然后定义双继承，也是12个类

设计模式JAVA_第8张图片

实现方式3：如下，用个“桥”去拼接形状和颜色，只有一座“桥”所以类的数量就看上面的4+3=7 

设计模式JAVA_第9张图片

设计模式JAVA_第10张图片

//实现化角色
public interface Impl {
    public void ImplInfo();
}

//具体实现化角色
public class TypeOneImpl implements Impl{
    @Override
    public void ImplInfo() {
        System.out.println("具体实现1");
    }
}

//抽象化角色
public abstract class Abstr {
    protected Impl impl;

    protected Abstr(Impl impl){
        this.impl = impl;
    }

    public abstract void Operation();
}

//扩展抽象化角色
public class AbstrOne extends Abstr{
    public AbstrOne(Impl impl) {
        super(impl);
    }

    @Override
    public void Operation() {
        System.out.println("扩展抽象化访问");
        impl.ImplInfo();
    }

}

//使用
    @GetMapping("/demo9")
    public void demo9(){
        Impl impl = new TypeOneImpl();
        Abstr abstr = new AbstrOne(impl);
        abstr.Operation();
    }

2.4 装饰模式

在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式。

装饰模式主要包含以下角色：

  • 抽象构件（Component）角色：定义一个抽象接口以规范准备接收附加责任的对象。
  • 具体构件（Concrete Component）角色：实现抽象构件，通过装饰角色为其添加一些职责。
  • 抽象装饰（Decorator）角色：继承抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
  • 具体装饰（Concrete Decorator）角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。

设计模式JAVA_第11张图片

1）抽象构件角色

public interface Shape {
    void draw();
}

2）具体构件角色，未被修饰的原本的内容

public class Rectangle implements Shape{
    @Override
    public void draw() {
        System.out.println("Shape: Rectangle");
    }
}

public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("Shape: Circle");
    }
}

3）抽象修饰角色

public abstract class ShapeDecorator implements Shape{

    protected Shape shape;

    public ShapeDecorator(Shape shape){
        this.shape = shape;
    }

    public void draw(){
        shape.draw();
    }
}

4）具体修饰角色，添加修饰类型——颜色修饰

public class RedShapeDecorator extends ShapeDecorator{

    public RedShapeDecorator(Shape shape) {
        super(shape);
    }

    @Override
    public void draw(){
        shape.draw();
        setRedBorder(shape);
    }

    private void setRedBorder(Shape shape){
        System.out.println("Border Color: Red");
    }

}

5）使用

    @GetMapping("/demo10")
    public void demo10(){
        Shape shapeCircle = new Circle();
        ShapeDecorator redCircle = new RedShapeDecorator(new Circle());
        ShapeDecorator redRectangle = new RedShapeDecorator(new Rectangle());

        shapeCircle.draw();
        System.out.println("-----");
        redCircle.draw();
        redRectangle.draw();
    }

设计模式JAVA_第12张图片

2.5 外观模式

当一个系统的功能越来越强，子系统会越来越多，客户对系统的访问也变得越来越复杂。这时如果系统内部发生改变，客户端也要跟着改变，这违背了“开闭原则”，也违背了“迪米特法则”，所以有必要为多个子系统提供一个统一的接口，从而降低系统的耦合度。

外观模式包含以下主要角色：

  • 外观（Facade）角色：为多个子系统对外提供一个共同的接口。
  • 子系统（Sub System）角色：实现系统的部分功能，客户可以通过外观角色访问它。
  • 客户（Client）角色：通过一个外观角色访问各个子系统的功能。

1）外观角色

public interface Shape {
   void draw();
}

2）子系统

public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Rectangle::draw()");
   }
}

public class Square implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Square::draw()");
   }
}

3）客户角色

public class ShapeMaker {
   private Shape circle;
   private Shape rectangle;
 
   public ShapeMaker() {
      circle = new Circle();
      rectangle = new Rectangle();
      square = new Square();
   }
 
   public void drawCircle(){
      circle.draw();
   }
   public void drawRectangle(){
      rectangle.draw();
   }

}

4）使用

      ShapeMaker shapeMaker = new ShapeMaker();
 
      shapeMaker.drawCircle();
      shapeMaker.drawRectangle();

2.6 享元模式

在面向对象程序设计过程中，有时会面临要创建大量相同或相似对象实例的问题。

运用共享技术来有效地支持大量细粒度对象的复用。

享元模式的主要角色有如下：

  • 抽象享元角色（Flyweight）：是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
  • 具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。
  • 非享元（Unsharable Flyweight）角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
  • 享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检查系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

1）非享元

public class UnSharedFlyweight {

    private String info;
    public UnSharedFlyweight(String info){
        this.info = info;
    }

    public String getInfo(){
        return info;
    }

    public void setInfo(String info){
        this.info = info;
    }
}

2）抽象享元

public interface AbstractFlyweight {
    void operation(UnSharedFlyweight unSharedFlyweight);
}

3）具体享元

public class ConcreteFlyweight implements AbstractFlyweight{
    private String key;
    public ConcreteFlyweight(String key){
        this.key = key;
        System.out.println("具体享元" + key + "被创建！");
    }

    @Override
    public void operation(UnSharedFlyweight unSharedFlyweight) {
        System.out.print("具体享元" + key + "被调用, ");
        System.out.println("非享元信息是 " + unSharedFlyweight.getInfo());
    }
}

4）享元工厂

public class FlyweightFactory {
    private HashMap flyweights = new HashMap();

    public AbstractFlyweight getFlyweight(String key){
        AbstractFlyweight flyweight = flyweights.get(key);
        if(flyweight != null){
            System.out.println("具体享元" + key + "已经存在，获取成功！");
        }else{
            flyweight = new ConcreteFlyweight(key);
            flyweights.put(key,flyweight);
        }
        return flyweight;
    }

}

5）使用

    @GetMapping("/demo11")
    public void demo11(){
        FlyweightFactory factory = new FlyweightFactory();
        AbstractFlyweight flyweight1 = factory.getFlyweight("a");
        AbstractFlyweight flyweight2 = factory.getFlyweight("a");
        AbstractFlyweight flyweight3 = factory.getFlyweight("b");
        AbstractFlyweight flyweight4 = factory.getFlyweight("b");
        AbstractFlyweight flyweight5 = factory.getFlyweight("b");

        flyweight1.operation(new UnSharedFlyweight("第一次调用a"));
        flyweight2.operation(new UnSharedFlyweight("第二次调用a"));
        flyweight3.operation(new UnSharedFlyweight("第一次调用b"));
        flyweight4.operation(new UnSharedFlyweight("第二次调用b"));
        flyweight5.operation(new UnSharedFlyweight("第三次调用b"));
    }

设计模式JAVA_第13张图片

实例应用：棋子（ChessPieces）类是抽象享元角色，它包含了一个落子的DownPieces(Graphics g,Point pt)方法；白子（WhitePieces）和黑子（BlackPieces）类是具体享元角色，它实现了落子方法；Point是非享元角色，它指定了落子的位置；WeiqiFactory是享元工厂角色，它通过ArrayList来管理棋子，并且提供了获取白子或者黑子的getChessPieces(String type)方法。 

2.7 组合模式

有时又叫作部分-整体模式，它是一种将对象组合成树状的层次结构的模式，用来表示“部分-整体”的关系，使用户对单个对象和组合对象具有一致的访问性。

透明组合模式

//抽象构件
interface Component {
    public void add(Component c);
    public void remove(Component c);
    public Component getChild(int i);
    public void operation();
}

//树叶构件
class Leaf implements Component {
    private String name;
    public Leaf(String name) {
        this.name = name;
    }
    public void add(Component c) {
    }
    public void remove(Component c) {
    }
    public Component getChild(int i) {
        return null;
    }
    public void operation() {
        System.out.println("树叶" + name + "：被访问！");
    }
}

//树枝构件
class Composite implements Component {
    private ArrayList children = new ArrayList();
    public void add(Component c) {
        children.add(c);
    }
    public void remove(Component c) {
        children.remove(c);
    }
    public Component getChild(int i) {
        return children.get(i);
    }
    public void operation() {
        for (Object obj : children) {
            ((Component) obj).operation();
        }
    }
}

//使用
        Component c0 = new Composite();
        Component c1 = new Composite();
        Component leaf1 = new Leaf("1");
        Component leaf2 = new Leaf("2");
        Component leaf3 = new Leaf("3");
        c0.add(leaf1);
        c0.add(c1);
        c1.add(leaf2);
        c1.add(leaf3);
        c0.operation();

3 行为型模式

3.1 模版方法模式

场景：设计一个系统时知道了算法所需的关键步骤，而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。又例如例如，简历模板、论文模板、Word中模板文件等。

模版方法模式特点如下：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。

模板方法模式包含以下主要角色：

（1）抽象类（Abstract Class）：负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。这些方法的定义如下

        ① 模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。

        ② 基本方法：是整个算法中的一个步骤，包含以下几种类型。

（2）具体子类（Concrete Class）：实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的一个组成步骤。

//抽象类
public abstract class StencilAbstract {

    public void TemplateMethod() {    //模版方法
        SpecificMethod();
        abstractMethod1();
        abstractMethod2();
    }

    public void SpecificMethod(){    //具体方法
        System.out.println("抽象类中的具体方法被调用");
    }

    public abstract void abstractMethod1();
    public abstract void abstractMethod2();
}

//具体子类
public class ConcreteStencil extends StencilAbstract {
    @Override
    public void abstractMethod1() {
        System.out.println("抽象方法1的实现调用");
    }

    @Override
    public void abstractMethod2() {
        System.out.println("抽象方法2的实现调用");
    }
}

//调用
    @GetMapping("/demo12")
    public void demo12(){
        StencilAbstract sa = new ConcreteStencil();
        sa.TemplateMethod();
    }

3.2 策略模式

当实现某一个功能存在多种算法或者策略，我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能。

策略模式：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。

策略模式的主要角色如下：

  • 抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。
  • 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。
  • 环境（Context）类：持有一个策略类的引用，最终给客户端调用。

1）抽象策略类

public interface AbstractStrategy {
    public void strategyMethod();
}

2）具体策略类

//具体实现方法2
public class ConcreteStrategyA implements AbstractStrategy{
    @Override
    public void strategyMethod() {
        System.out.println("具体策略A的策略方法被访问！");
    }
}

//具体实现方法1
public class ConcreteStrategyB implements AbstractStrategy{
    @Override
    public void strategyMethod() {
        System.out.println("具体策略B的策略方法被访问！");
    }
}

3）环境类

public class EnvironmentContext {
    private AbstractStrategy strategy;

    public AbstractStrategy getStrategy(){
        return strategy;
    }

    public void setStrategy(AbstractStrategy getStrategy){
        this.strategy = strategy;
    }

    public void strategyMethod(){
        strategy.strategyMethod();
    }
}

4）调用

    @GetMapping("/demo13")
    public void demo13(){
        EnvironmentContext context = new EnvironmentContext();
        AbstractStrategy strategy = new ConcreteStrategyA();
        context.setStrategy(strategy);
        context.strategyMethod();
        System.out.println("_______________");
        strategy = new ConcreteStrategyB();
        context.setStrategy(strategy);
        context.strategyMethod();
    }

3.3 命令模式

背景：在软件开发系统中，常常出现“方法的请求者”与“方法的实现者”之间存在紧密的耦合关系。

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

命令模式包含以下主要角色：

  • 抽象命令类（Command）角色：声明执行命令的接口，拥有执行命令的抽象方法execute()。
  • 具体命令角色（Concrete Command）角色：是抽象命令类的具体实现类，它拥有接收者对象，并通过调用接收者的功能来完成命令要执行的操作。
  • 实现者/接收者（Receiver）角色：执行命令功能的相关操作，是具体命令对象业务的真正实现者。
  • 调用者/请求者（Invoker）角色：是请求的发送者，它通常拥有很多的命令对象，并通过访问命令对象来执行相关请求，它不直接访问接收者。

1）抽象命令类

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

2）具体命令类

public class ConcreteCommand implements Command{

    private Receiver receiver;

    public ConcreteCommand(){
        receiver = new Receiver();
    }
    @Override
    public void execute() {
        receiver.action();
    }
}

3）调用者，发起请求的地方

public class Invoker {
    private Command command;

    public Invoker (Command command){
        this.command = command;
    }

    public void setCommand(Command command){
        this.command = command;
    }

    public void call(){
        System.out.println("调用者治性命令！");
        command.execute();
    }
}

4）接收者，真正实现业务的地方

public class Receiver {
    public void action(){
        System.out.println("接受者的action()方法被调用");
    }
}

5）调用实现

    @GetMapping("/demo14")
    public void demo14(){
        Command cmd = new ConcreteCommand();
        Invoker invoker = new Invoker(cmd);
        invoker.call();
    }

3.4 职责链模式

背景：一个请求有多个对象可以处理，但每个对象的处理条件或权限不同。例如Struts2的拦截器、JSP和Servlet的Filter。

职责链模式：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

职责链模式主要包含以下角色：

  • 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
  • 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
  • 客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

1）抽象处理者

public abstract class RCAbstractHandler {

    private RCAbstractHandler next;

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

    public RCAbstractHandler getNext(){
        return next;
    }

    //处理请求的方法
    public abstract void handleRequest(String request);

}

2）具体处理者

//具体处理者1
public class ConcreteHandle1 extends RCAbstractHandler{

    @Override
    public void handleRequest(String request) {
        if(request.contains("a")){
            System.out.println("ConcreteHandle1 开始处理");
        }else {
            if(getNext() != null){
                getNext().handleRequest(request);
            }else{
                System.out.println("无处理");
            }
        }
    }

}

//具体处理者2
public class ConcreteHandle2 extends RCAbstractHandler{
    @Override
    public void handleRequest(String request) {
        if(request.contains("b")){
            System.out.println("ConcreteHandle2 开始处理");
        }else {
            if(getNext() != null){
                getNext().handleRequest(request);
            }else{
                System.out.println("无处理");
            }
        }
    }
}

3）调用

    @GetMapping("/demo15")
    public void demo15(@RequestParam("content") String content){
        RCAbstractHandler handler1 = new ConcreteHandle1();
        RCAbstractHandler handler2 = new ConcreteHandle2();

        handler1.setNext(handler2);
        handler1.handleRequest(content);
    }

设计模式JAVA_第14张图片

 3.5 状态模式

背景：应用程序中的有些对象可能会根据不同的情况做出不同的行为，我们把这种对象称为有状态的对象。

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

状态模式包含以下主要角色：

  • 环境（Context）角色：也称为上下文，它定义了客户感兴趣的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理。
  • 抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为。
  • 具体状态（Concrete State）角色：实现抽象状态所对应的行为。

1）环境角色

public class StateContext {
    private State state;

    public StateContext(){
        this.state = new ConcreteStateA();
    }

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

    public State getState(){
        return state;
    }

    public void Handle(State state){
        state.Handle(this,state);
    }
}

2）抽象状态

public abstract class State {
    public abstract void Handle(StateContext context,State state);
}

3）具体状态

//具体算法A
public class ConcreteStateA extends State{
    @Override
    public void Handle(StateContext context,State state) {
        System.out.println("this is A");
        context.setState(state);
    }
}

//具体算法B
public class ConcreteStateB extends State{
    @Override
    public void Handle(StateContext context,State state) {
        System.out.println("this is B");
        context.setState(state);
    }
}

4）调用

    @GetMapping("/demo16")
    public void demo16(){
        StateContext context = new StateContext();
        context.Handle(new ConcreteStateA());
        context.Handle(new ConcreteStateA());
        context.Handle(new ConcreteStateB());
    }

设计模式JAVA_第15张图片

3.6 观察者模式

背景：在现实世界中，许多对象并不是独立存在的，其中一个对象的行为发生改变可能会导致一个或者多个其他对象的行为也发生改变

观察者（订阅者）模式：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

观察者模式的主要角色如下：

  • 抽象主题（Subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
  • 具体主题（Concrete Subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
  • 抽象观察者（Observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
  • 具体观察者（Concrete Observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。

1）抽象主题角色

public abstract class ObserverSubject {

    protected List observers=new ArrayList();

    //增加观察者方法
    public void add(Observer observer)
    {
        observers.add(observer);
    }
    //删除观察者方法
    public void remove(Observer observer)
    {
        observers.remove(observer);
    }
    public abstract void notifyObserver(String info); //通知观察者方法
}

2）具体主题

public class ObConcreteSubject extends ObserverSubject {
    @Override
    public void notifyObserver(String info) {
        System.out.println("具体目标发生改变...");
        System.out.println("--------------");

        for(Object obs:observers)
        {
            ((Observer)obs).response(info);
        }
    }
}

3）抽象观察者

public interface Observer {
    void response(String info);
}

4）具体观察者角色

//具体观察者1
public class ObConcreteObserver1 implements Observer{
    @Override
    public void response(String info) {
        System.out.println("具体观察者1作出反应:" + info);
    }
}

//具体观察者2
public class ObConcreteObserver1 implements Observer{
    @Override
    public void response(String info) {
        System.out.println("具体观察者1作出反应:" + info);
    }
}

5）调用

    @GetMapping("/demo17")
    public void demo17(){
        ObserverSubject subject = new ObConcreteSubject();
        Observer observer1 = new ObConcreteObserver1();
        Observer observer2 = new ObConcreteObserver2();

        subject.add(observer1);
        subject.add(observer2);
        subject.notifyObserver("降价了！");
    }

设计模式JAVA_第16张图片

 3.7 中介模式

背景：在现实生活中，常常会出现好多对象之间存在复杂的交互关系，这种交互关系常常是“网状结构”，它要求每个对象都必须知道它需要交互的对象。

中介模式（调停模式）：定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。

中介者模式包含以下主要角色：

  • 抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
  • 具体中介者（Concrete Mediator）角色：实现中介者接口，定义一个List来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。
  • 抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
  • 具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

1）中介者

//抽象中介者
public abstract class AbstractMediator {
    public abstract void register(AbstractCollege college);
    public abstract void replay(AbstractCollege cl);
}

//具体中介者
public class ConcreteMediator extends AbstractMediator{

    private List colleges = new ArrayList<>();

    @Override
    public void register(AbstractCollege college) {
        if(!colleges.contains(college)){
            colleges.add(college);
            college.setMediator(this);
        }
    }

    @Override
    public void replay(AbstractCollege cl) {
        for(AbstractCollege college : colleges){
            if(!college.equals(cl)){
                college.receive();
            }
        }
    }
}

2）同事类

//抽象
public abstract class AbstractCollege {
    protected AbstractMediator mediator;

    public void setMediator(AbstractMediator mediator){
        this.mediator = mediator;
    }

    public abstract void receive();
    public abstract void send();
}

//具体1
public class ConcreteCollege1 extends AbstractCollege{
    @Override
    public void receive() {
        System.out.println("college1 收到请求 ");
    }

    @Override
    public void send() {
        System.out.println("college1 发出请求 ");
        mediator.replay(this);//转发
    }
}

//具体2
public class ConcreteCollege2 extends AbstractCollege {
    @Override
    public void receive() {
        System.out.println("college2 收到请求 ");
    }

    @Override
    public void send() {
        System.out.println("college2 发出请求 ");
        mediator.replay(this);
    }
}

3）调用

    @GetMapping("/demo18")
    public void demo18(){
        AbstractMediator mediator = new ConcreteMediator();
        AbstractCollege c1,c2;
        c1 = new ConcreteCollege1();
        c2 = new ConcreteCollege2();
        mediator.register(c1);
        mediator.register(c2);
        c1.send();
        c2.send();
    }

不同对象之间的信息沟通 

设计模式JAVA_第17张图片

3.8 迭代器模式

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

迭代器模式主要包含以下角色：

  • 抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
  • 具体聚合（Concrete Aggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
  • 抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含hasNext()、first()、next()等方法。
  • 具体迭代器（Concrete Iterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

1）抽象聚合

public interface IteratorAggregate {
    public void add(Object obj);
    public void remove(Object obj);
    public Iterator getIterator();
}

2）具体聚合

public class ConcreteAggregate implements IteratorAggregate{
    private List list = new ArrayList<>();
    @Override
    public void add(Object obj) {
        list.add(obj);
    }

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

    @Override
    public Iterator getIterator() {
        return new ConcreteIterator(list);
    }
} 
  
3）抽象迭代器
 
  
public interface Iterator {
    Object first();
    Object next();
    boolean hashNext();
}
 
  
4）具体迭代器
 
  

public class ConcreteIterator implements Iterator{

    private List list = new ArrayList<>();
    private int index = 0;

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

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

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

    @Override
    public boolean hashNext() {
        if(index >= list.size()){
            return false;
        }else {
            return true;
        }
    }
} 
  
5）调用
 
  
    @GetMapping("/demo19")
    public void demo19(){
        IteratorAggregate ag = new ConcreteAggregate();
        ag.add("中山大学");
        ag.add("华南理工");
        ag.add("清华大学");
        ag.add("北大大学");

        Iterator it = ag.getIterator();
        while(it.hashNext()){
            Object ob = it.next();
            System.out.println(ob.toString() + "\n");
        }
        Object ob = it.first();
        System.out.println("\nFirst" + ob.toString());
    }
 
  
3.9 访问者模式
 
  
背景：有些集合对象中存在多种不同的元素，且每种元素也存在多种不同的访问者和处理方式。
 
  
访问者模式定义：将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方式。 
 
  
访问者模式包含以下主要角色:
 
  
     
   
  • 抽象访问者（Visitor）角色：定义一个访问具体元素的接口，为每个具体元素类对应一个访问操作visit()，该操作中的参数类型标识了被访问的具体元素。
    •  
   
  • 具体访问者（Concrete Visitor）角色：实现抽象访问者角色中声明的各个访问操作，确定访问者访问一个元素时该做什么。
    •  
   
  • 抽象元素（Element）角色：声明一个包含接受操作accept()的接口，被接受的访问者对象作为accept()方法的参数。
    •  
   
  • 具体元素（Concrete Element）角色：实现抽象元素角色提供的accept()操作，其方法体通常都是visitor.visit(this)，另外具体元素中可能还包含本身业务逻辑的相关操作。
    •  
   
  • 对象结构（Object Structure）角色：是一个包含元素角色的容器，提供让访问者对象遍历容器中的所有元素的方法，通常由List、Set、Map等聚合类实现。
    •  
  
 
  
1）抽象访问者
 
  
public interface AbstractVisitor {
    void visit(ConcreteElementA element);
    void visit(ConcreteElementB element);
}
 
  
2）具体访问者
 
  
//具体访问者A
public class ConcreteVisitorA implements AbstractVisitor{
    @Override
    public void visit(ConcreteElementA element) {
        System.out.println("具体A访问者访问：" + element.Operation());
    }

    @Override
    public void visit(ConcreteElementB element) {
        System.out.println("具体A访问者访问：" + element.Operation());
    }
}

//具体访问者B
public class ConcreteVisitorB implements AbstractVisitor{
    @Override
    public void visit(ConcreteElementA element) {
        System.out.println("具体B访问者访问：" + element.Operation());
    }

    @Override
    public void visit(ConcreteElementB element) {
        System.out.println("具体B访问者访问：" + element.Operation());
    }
}
 
  
3）抽象元素
 
  
public interface Element {
    void accept(AbstractVisitor visitor);
}

 
  
4）具体元素
 
  
//具体元素A
public class ConcreteElementA implements Element{
    @Override
    public void accept(AbstractVisitor visitor) {
        visitor.visit(this);
    }

    public String Operation(){
        return "具体元素A的操作！";
    }
}

//具体元素B
public class ConcreteElementB implements Element{
    @Override
    public void accept(AbstractVisitor visitor) {
        visitor.visit(this);
    }

    public String Operation(){
        return "具体元素B的操作！";
    }
}
 
  
5）对象结构元素
 
  
public class ObjectStructure {
    private List list = new ArrayList();

    public void accept(AbstractVisitor visitor){
        Iterator element = list.iterator();
        while(element.hasNext()){
            element.next().accept(visitor);
        }
    }

    public void add(Element element){
        list.add(element);
    }

    public void remove(Element element){
        list.remove(element);
    }
}
 
  
6）调用
 
  
    @GetMapping("/demo20")
    public void demo20(){
        ObjectStructure obs = new ObjectStructure();
        obs.add(new ConcreteElementA());
        obs.add(new ConcreteElementB());

        AbstractVisitor visitorA = new ConcreteVisitorA();
        obs.accept(visitorA);

        AbstractVisitor visitorB = new ConcreteVisitorB();
        obs.accept(visitorB);
    }
 
  
设计模式JAVA_第18张图片
 
  
3.10  备忘录模式
 
  
备忘录模式（快照模式）能记录一个对象的内部状态，当用户后悔时能撤销当前操作，使数据恢复到它原先的状态。
 
  
备忘录模式的主要角色如下：
 
  
     
   
  • 发起人（Originator）角色：记录当前时刻的内部状态信息，提供创建备忘录和恢复备忘录数据的功能，实现其他业务功能，它可以访问备忘录里的所有信息。
    •  
   
  • 备忘录（Memento）角色：负责存储发起人的内部状态，在需要的时候提供这些内部状态给发起人。
    •  
   
  • 管理者（Caretaker）角色：对备忘录进行管理，提供保存与获取备忘录的功能，但其不能对备忘录的内容进行访问与修改。
    •  
  
 
  
1）备忘录
 
  
public class Memento {
    private String state;
    public Memento (String state){
        this.state = state;
    }

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

    public String getState(){
        return state;
    }
}
 
  
2）发起人
 
  
public class Originator {
    private String state;
    public void setState(String state){
        this.state = state;
    }

    public String getState(){
        return state;
    }

    public Memento createMemento(){
        return new Memento(state);
    }

    public void restoreMemento(Memento m){
        this.setState(m.getState());
    }
}
 
  
3）管理者
 
  
public class Caretaker {
    private Memento memento;

    public void setMemento(Memento m){
        this.memento = m;
    }

    public Memento getMemento(){
        return memento;
    }
}
 
  
4）调用
 
  
    @GetMapping("/demo21")
    public void demo21(){
        Originator or = new Originator();
        Caretaker cr = new Caretaker();
        or.setState("S0");
        System.out.println("初始状态：" + or.getState());
        cr.setMemento(or.createMemento()); //保存状态
        or.setState("S1");
        System.out.println("新的状态：" + or.getState());
        or.restoreMemento(cr.getMemento()); //恢复状态
        System.out.println("恢复状态：" + or.getState());
    }
 
  
设计模式JAVA_第19张图片
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(JavaWeb,设计模式,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的运行
    
                    
    • 
                    
  • 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):获取指定键的值。如果键
    
                    
    • 
                    
  • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    
                    
    • 
                                
  • [黑洞与暗粒子]没有光的世界
                                    comsci

                                    
         无论是相对论还是其它现代物理学,都显然有个缺陷,那就是必须有光才能够计算 
 
     但是,我相信,在我们的世界和宇宙平面中,肯定存在没有光的世界.... 
 
     那么,在没有光的世界,光子和其它粒子的规律无法被应用和考察,那么以光速为核心的 
 
&nbs
    
                                
    • 
                                
  • jQuery Lazy Load 图片延迟加载
                                    aijuans
jquery
                                    
    基于 jQuery 的图片延迟加载插件，在用户滚动页面到图片之后才进行加载。 
对于有较多的图片的网页，使用图片延迟加载，能有效的提高页面加载速度。 
 
 版本： 
 

  jQuery v1.4.4+ 
 

  jQuery Lazy Load v1.7.2 
 
 
 注意事项： 
 
 
 需要真正实现图片延迟加载，必须将真实图片地址写在 data-original 属性中。若 src
    
                                
    • 
                                
  • 使用Jodd的优点
                                    Kai_Ge
jodd
                                    
    1.  简化和统一 controller ，抛弃 extends SimpleFormController ，统一使用 implements Controller 的方式。 
2.  简化 JSP 页面的 bind, 不需要一个字段一个字段的绑定。 
3.  对 bean 没有任何要求，可以使用任意的 bean 做为 formBean。 
  
使用方法简介
    
                                
    • 
                                
  • jpa Query转hibernate Query
                                    120153216
Hibernate
                                    
    public List<Map> getMapList(String hql,
			Map map) {
		org.hibernate.Query jpaQuery = entityManager.createQuery(hql);
		if (null != map) {
			for (String parameter : map.keySet()) {
				jp
    
                                
    • 
                                
  • Django_Python3添加MySQL/MariaDB支持
                                    2002wmj
mariaDB
                                    
    现状 
首先，[email protected] 中默认的引擎为 django.db.backends.mysql 。但是在Python3中如果这样写的话，会发现 django.db.backends.mysql 依赖 MySQLdb[5] ，而 MySQLdb 又不兼容 Python3 于是要找一种新的方式来继续使用MySQL。 MySQL官方的方案 
首先据MySQL文档[3]说，自从MySQL
    
                                
    • 
                                
  • 在SQLSERVER中查找消耗IO最多的SQL
                                    357029540
SQL Server
                                    
    返回做IO数目最多的50条语句以及它们的执行计划。 
select top 50   
 
(total_logical_reads/execution_count) as avg_logical_reads,  
 
(total_logical_writes/execution_count) as avg_logical_writes,  
 
(tot
    
                                
    • 
                                
  • spring UnChecked 异常 官方定义！
                                    7454103
spring
                                    
      如果你接触过spring的 事物管理！那么你必须明白 spring的 非捕获异常！ 即 unchecked 异常！ 因为 spring 默认这类异常事物自动回滚！！ 
 
 
 
 
public static boolean isCheckedException(Throwable ex)
    {
   return !(ex instanceof RuntimeExcep
    
                                
    • 
                                
  • mongoDB 入门指南、示例
                                    adminjun
javamongodb操作
                                    
    一、准备工作 
1、 下载mongoDB 
下载地址：http://www.mongodb.org/downloads 
选择合适你的版本 
相关文档：http://www.mongodb.org/display/DOCS/Tutorial 
2、 安装mongoDB 
A、 不解压模式： 
将下载下来的mongoDB-xxx.zip打开，找到bin目录，运行mongod.exe就可以启动服务，默
    
                                
    • 
                                
  • CUDA 5 Release Candidate Now Available
                                    aijuans
CUDA
                                    
    The CUDA 5 Release Candidate is now available at http://developer.nvidia.com/<wbr></wbr>cuda/cuda-pre-production. Now applicable to a broader set of algorithms, CUDA 5 has advanced fe
    
                                
    • 
                                
  • Essential Studio for WinRT网格控件测评
                                    Axiba
JavaScripthtml5
                                    
    Essential Studio for WinRT界面控件包含了商业平板应用程序开发中所需的所有控件，如市场上运行速度最快的grid 和chart、地图、RDL报表查看器、丰富的文本查看器及图表等等。同时，该控件还包含了一组独特的库，用于从WinRT应用程序中生成Excel、Word以及PDF格式的文件。此文将对其另外一个强大的控件——网格控件进行专门的测评详述。 
 
 
网格控件功能 
1、
    
                                
    • 
                                
  • java 获取windows系统安装的证书或证书链
                                    bewithme
windows
                                    
      
    有时需要获取windows系统安装的证书或证书链，比如说你要通过证书来创建java的密钥库  。 
有关证书链的解释可以查看此处 。 
  
public static void main(String[] args) {
		SunMSCAPI providerMSCAPI = new SunMSCAPI();
		S
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(set类型和zset类型)
                                    bijian1013
redis数据库NoSQL
                                    
    4.sets类型 
        Set是集合，它是string类型的无序集合。set是通过hash table实现的，添加、删除和查找的复杂度都是O(1)。对集合我们可以取并集、交集、差集。通过这些操作我们可以实现sns中的好友推荐和blog的tag功能。 
        sadd：向名称为key的set中添加元
    
                                
    • 
                                
  • 异常捕获何时用Exception，何时用Throwable
                                    bingyingao

                                    
    用Exception的情况 
 try { 
       //可能发生空指针、数组溢出等异常 
        } catch (Exception e) { 
         
    
                                
    • 
                                
  • 【Kafka四】Kakfa伪分布式安装
                                    bit1129
kafka
                                    
    在http://bit1129.iteye.com/blog/2174791一文中，实现了单Kafka服务器的安装，在Kafka中，每个Kafka服务器称为一个broker。本文简单介绍下，在单机环境下Kafka的伪分布式安装和测试验证   1. 安装步骤 
  
Kafka伪分布式安装的思路跟Zookeeper的伪分布式安装思路完全一样，不过比Zookeeper稍微简单些(不
    
                                
    • 
                                
  • Project Euler
                                    bookjovi
haskell
                                    
    Project Euler是个数学问题求解网站，网站设计的很有意思，有很多problem，在未提交正确答案前不能查看problem的overview，也不能查看关于problem的discussion thread，只能看到现在problem已经被多少人解决了，人数越多往往代表问题越容易。 
    看看problem 1吧： 
 Add all the natural num
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-ArrayDeque
                                    BrokenDreams
Collections
                                    
            表、栈和队列是三种基本的数据结构，前面总结的ArrayList和LinkedList可以作为任意一种数据结构来使用，当然由于实现方式的不同，操作的效率也会不同。 
        这篇要看一下java.util.ArrayDeque。从命名上看
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-装饰模式-Decorator
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.Fi
    
                                
    • 
                                
  • Maven学习(一)
                                    chenyu19891124
Maven私服
                                    
        学习一门技术和工具总得花费一段时间，5月底6月初自己学习了一些工具，maven+Hudson+nexus的搭建，对于maven以前只是听说，顺便再自己的电脑上搭建了一个maven环境，但是完全不了解maven这一强大的构建工具，还有ant也是一个构建工具，但ant就没有maven那么的简单方便，其实简单点说maven是一个运用命令行就能完成构建，测试，打包，发布一系列功
    
                                
    • 
                                
  • [原创]JWFD工作流引擎设计----节点匹配搜索算法(用于初步解决条件异步汇聚问题) 补充
                                    comsci
算法工作PHP搜索引擎嵌入式
                                    
    本文主要介绍在JWFD工作流引擎设计中遇到的一个实际问题的解决方案，请参考我的博文"带条件选择的并行汇聚路由问题"中图例A2描述的情况(http://comsci.iteye.com/blog/339756),我现在把我对图例A2的一个解决方案公布出来，请大家多指点 
 
 节点匹配搜索算法(用于解决标准对称流程图条件汇聚点运行控制参数的算法) 
 
 需要解决的问题：已知分支
    
                                
    • 
                                
  • Linux中用shell获取昨天、明天或多天前的日期
                                    daizj
linuxshell上几年昨天获取上几个月
                                    
    在Linux中可以通过date命令获取昨天、明天、上个月、下个月、上一年和下一年 
 
 
# 获取昨天 
date -d 'yesterday'  # 或 date -d 'last day' 
# 获取明天 
date -d 'tomorrow'   # 或 date -d 'next day' 
# 获取上个月 
date -d 'last month' 
# 
    
                                
    • 
                                
  • 我所理解的云计算
                                    dongwei_6688
云计算
                                    
          在刚开始接触到一个概念时，人们往往都会去探寻这个概念的含义，以达到对其有一个感性的认知，在Wikipedia上关于“云计算”是这么定义的，它说： 
 
        Cloud computing is a phrase used to describe a variety of computing co
    
                                
    • 
                                
  • YII CMenu配置
                                    dcj3sjt126com
yii
                                    
    Adding id and class names to CMenu 
We use the id and htmlOptions to accomplish this. Watch.   
//in your view
$this->widget('zii.widgets.CMenu', array(
	'id'=>'myMenu',
	'items'=>$this-&g
    
                                
    • 
                                
  • 设计模式之静态代理与动态代理
                                    come_for_dream
设计模式
                                    
    静态代理与动态代理 
        代理模式是java开发中用到的相对比较多的设计模式，其中的思想就是主业务和相关业务分离。所谓的代理设计就是指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如我们在进行删除操作的时候需要检验一下用户是否登陆，我们可以删除看成主业务，而把检验用户是否登陆看成其相关业务
    
                                
    • 
                                
  • 【转】理解Javascript 系列
                                    gcc2ge
JavaScript
                                    
    理解Javascript_13_执行模型详解 
 
  摘要: 在《理解Javascript_12_执行模型浅析》一文中,我们初步的了解了执行上下文与作用域的概念，那么这一篇将深入分析执行上下文的构建过程，了解执行上下文、函数对象、作用域三者之间的关系。函数执行环境简单的代码:当调用say方法时，第一步是创建其执行环境，在创建执行环境的过程中，会按照定义的先后顺序完成一系列操作:1.首先会创建一个
    
                                
    • 
                                
  • Subsets II
                                    hcx2013
set
                                    
    Given a collection of integers that might contain duplicates, nums, return all possible subsets. 
Note: 
 
 Elements in a subset must be in non-descending order. 
 The solution set must not conta
    
                                
    • 
                                
  • Spring4.1新特性——Spring缓存框架增强
                                    jinnianshilongnian
spring4
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • shell嵌套expect执行命令
                                    liyonghui160com

                                    
      
  
一直都想把expect的操作写到bash脚本里,这样就不用我再写两个脚本来执行了,搞了一下午终于有点小成就,给大家看看吧. 
  系统:centos 5.x 
  
1.先安装expect 
yum -y install expect 
  
2.脚本内容: 
cat auto_svn.sh 
  
#!/bin/bash

    
                                
    • 
                                
  • Linux实用命令整理
                                    pda158
linux
                                    
    0. 基本命令   　　linux 基本命令整理   　 
　1. 压缩 解压   　　tar -zcvf a.tar.gz a   #把a压缩成a.tar.gz   　　tar -zxvf a.tar.gz     #把a.tar.gz解压成a   　 
　2. vim小结   　　2.1 vim替换   　　:m,ns/word_1/word_2/gc  
    
                                
    • 
                                
  • 独立开发人员通向成功的29个小贴士
                                    shoothao
独立开发
                                    
      
 概述：本文收集了关于独立开发人员通向成功需要注意的一些东西,对于具体的每个贴士的注解有兴趣的朋友可以查看下面标注的原文地址。  
   
 
 明白你从事独立开发的原因和目的。 
 保持坚持制定计划的好习惯。 
 万事开头难，第一份订单是关键。 
 培养多元化业务技能。 
 提供卓越的服务和品质。 
 谨小慎微。 
 营销是必备技能。 
 学会组织，有条理的工作才是最有效率的。 
 “独立
    
                                
    • 
                                
  • JAVA中堆栈和内存分配原理
                                    uule
java
                                    
    1、栈、堆  
1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）3. 堆：存放所有new出来的对象。4. 静态域：存放静态成员（static定义的）5. 常量池：存放字符串常量和基本类型常量（public static f
    
                                
    •