String s1="a";
String s2="b";
String s3="ab";
String s4=s1+s2;
/*
如果被拼接的字符串中有变量，执行字符串拼接操作会进行如下几个步骤
①StringBuilder s=new StringBuilder();
②s.append(s1); s.append(s2);
③s.toString();
如果要被拼接的字符串中全是常量或者常量引用，则仍然使用编译器优化，不会涉及到上面三步。
*/
System.out.println(s4==s3);//false

//下面这两行代码输出的结果为什么是nullabc呢？一起来分析一下源码吧
String s=null+"abc";
System.out.println(s);//nullabc

//StringBuilder类，当传入一个对象时会将该对象转化成一个字符串
public StringBuilder append(Object obj) {
	return append(String.valueOf(obj));
}
//String类，当该对象为null时，会返回一个"null"字符串，否则返回该对象的toString方法
public static String valueOf(Object obj) {
	return (obj == null) ? "null" : obj.toString();
}

String s=new String("ab");
/*
创建了两个对象
对象1：new String("ab");
对象2：常量池中的"ab";
*/

String s1=new String("a")+new String("b");
/*
创建了6个对象
对象1：new StringBuilder();
对象2：new String("a");
对象3：常量池中的"a";
对象4：new String("b");
对象5：常量池中的"b";
对象6：当append操作结束后，会调用StringBuilder的toString方法，将StringBuilder对象转化为String对象，
	此时又发生了一次new的操作:new String(value, 0, count);
tips：这里虽然创建了6个对象，但实际上在常量池中并没有创建"ab";
*/

String s1=new String("ab");
s1.intern();
String s2="ab";
System.out.println(s1==s2);//false;
/*
这是因为一个是堆中的对象，一个是常量池中的对象
*/

String s3=new String("a")+new String("b");
s3.intern();
String s4="ab";
System.out.println(s3==s4);//true(jdk7及以上版本的结果);
/*
这个是不是感觉很匪夷所思？
原因是在创建了s3之后，常量池中并没有"ab"这个对象，
而在执行s3.intern()后，常量池中多了一个指向堆中的对象的指针，
所以当执行s4="ab"时，s4实际上也是指向了堆中创建的那个对象。
为什么这么做呢？指针才占4个字节，用指针省空间。
*/

//代表所有车
interface Car{
    public void run();
}
//比亚迪
class Biyadi implements Car{
    public void run(){
        System.out.println("比亚迪run");
    }
}
//奥迪
class Aodi implements Car{
    public void run(){
        System.out.println("奥迪run");
    }
}
//工厂
interface CarFactory{
    public void createCar();
}
//具体的实现
class BiyadiCarFactory implements CarFactory{
    public void createCar(){
        return new Biyadi();
    }
}

class AodiCarFactory implements CarFactory{
    public void createCar(){
        return new Aodi();
    }
}

//使用工厂方法
public void travel(CarFactory carFactory){
	//我开什么车去旅游全凭其他人给我什么车，假如公司有钱了，可能给我传递了更好的车
    Car car=carFactory.createCar();
    car.run();
}
/*虽然可能还是会有依赖，但是在本实现中依赖基本上已经消失了
其实依赖不可能完全消失，我们使用模式的时候可能只是将散落在程序各个部分的依赖都集中起来*/

//不使用工厂方法
public void travel(){
	//我只能开比亚迪去旅游，不能被更改
    Car car=new BiyadiCar();
    car.run();
}

interface OutputStream{
    public void print();
}

class ConcreteOutputStream implements OutputStream{
    public void print(){}
}
//装饰器
abstract class Decorator implements OutputStream{
    protected OutputStream  outputStream;
    public Decorator(OutputStream outputStream){
        this.outputStream=outputStream;
    }

    public  void print(){
        outputStream.print();
    }
}
//缓冲
class BufferedOutputStream extends Decorator{

    public BufferedOutputStream(OutputStream outputStream){
        super(outputStream);
    }

    public void print(){
        System.out.println("I am BufferedOutputStream");
        super.print();
    }
}
//安全
class SecureOutputStream extends Decorator{

    public SecureOutputStream(OutputStream outputStream){
        super(outputStream);
    }

    public void print(){
        System.out.println("I am SecureOutputStream");
        super.print();
    }
}
//输出到文件
class FileOutputStream extends Decorator{

    public FileOutputStream(OutputStream outputStream){
        super(outputStream);
    }

    public void print(){
        System.out.println("I am FileOutputStream");
        super.print();
    }
}

class Sale{
    public double buySomething(){
        double d=xxx;
        //...
        if(tax==ChineseTax){
            //...
        }else if(tax==AmericeTax){
            //...
        }elseif(tax==JapanTax){
            //...
        }
        //...
    }
}

interface Tax{
    public double calculate(double money);
}

class ChineseTax implements Tax{
    public double calculate(double money){
        //...
    }
}
class AmericaTax implements Tax{
    public double calculate(double money){
        //...
    }
}

class Sale{
    private Tax tax;
    public Sale(Tax tax){this.tax=tax;}
    
    public double buySomething(){
        double d=xxx;
        //...
        tax.calculate(d);//替换掉先前的if-else
        //...
    }
}