新 生 代 GC（ Minor GC）： 指 发 生 在 新 生 代 的 垃 圾 收 集 动 作， 因 为 Java 对 象 大 多 都 具 备 朝 生 夕 灭 的 特 性， 所 以 Minor GC 非 常 频 繁， 一 般 回 收 速 度 也 比 较 快。 
老 年 代 GC（ Major GC/ Full GC）： 指 发 生 在 老 年 代 的 GC， 出 现 了 Major GC， 经 常 会 伴 随 至 少 一 次 的 Minor GC（ 但 非 绝 对 的， 在 Parallel Scavenge 收 集 器 的 收 集 策 略 里 就 有 直 接 进 行 Major GC 的 策 略 选 择 过 程）。 Major GC 的 速 度 一 般 会 比 Minor GC 慢 10 倍 以 上。

public class Singleton{
    private Singleton(){}
    private static final Singleton single=new Singleton();
    public static Singleton getInstance(){
        return singleton;
    }
}

public class Singleton{
    private Singleton(){}
    private static Singleton singleton=null;
    public static Singleton getInstance(){
        if(singleton==null){
            singleton=new Singleton();
        }
        return singleton;
    }
}

public class Singleton{
    private static calss My{
        private static final Singleton single=new Singleton();
    }
    private Singleton(){
        System.out.println("this is new instance");
    }
    public static final Singleton getInstance(){
       return My.single;
    }
}

//定义小汽车接口
public interface ICar{}
//高档小汽车
public class UpCar implements ICar{}
//中档小汽车
public class MidCar implements ICar{}
//低档小汽车
public class DnCar implements ICar{}
//简单工厂
public class CarSimpleFactory{
    public static final String UPTYPE="uptype";
    public static final String MIDTYPE="midtype";
    public static final String DNTYPE="dntype";
    public static ICar create(String mark){
        ICar obj=null;
        if(mark.equals(UPTYPE)){
            obj=new UpCar();
        }
        if(mark.equals(MIDTYPE)){
            obj=new MidCar();
        }
        if(mark.equals(ONTYPE)){
            obj=new OnCar();
        }
        return obj;
    }
}

//定义小汽车接口
public interface ICar{}
//高档小汽车
public class UpCar implements ICar{}
//中档小汽车
public class MidCar implements ICar{}
//低档小汽车
public class DnCar implements ICar{}

//定义公共汽车接口
public interface IBus{}
//高档公共汽车
public class UpBus implements IBus{}
//中档公共汽车
public class MidBus implements IBus{}
//低档公共汽车
public class DnBus implements IBus{}

//定义抽象工厂
public abstract class AbstractFactory{
    public abstract ICar create();
    public abstract IBus create();
    
}

//定义高档工厂
public class UpFactory extends AbstracetFactory{
    public ICar create(){
        return new UpCar();
    }
    public IBus create(){
        return new UpBus();
    }
}
//定义高档工厂
public class MidFactory extends AbstracetFactory{
    public ICar create(){
        return new MidCar();
    }
    public IBus create(){
        return new MidBus();
    }
}
//定义中档工厂
public class DnFactory extends AbstracetFactory{
    public ICar create(){
        return new DnCar();
    }
    public IBus create(){
        return new DnBus();
    }
}

public class Unit{...}
public class Unit2{...}
public class Unit3{...}
public class Product{
   Unit u;
   Unit2 u2;
   Unit3 u3;
}

//定义生成器类接口IBuild
public intgerface IBuild{
    public void createUnit();
    public void createUnit2();
    public void createUnit3();
    public Product composite();//返回值是Product对象
}
//定义3个生成器类
public class BuildProduct implements IBuild{//生成第1种Product
    Product p=new Product();
    public void createUnit(){
        //p.u=...
    }
    public void createUnit2(){
        //p.u2=...
    }
    public void createUnit3(){
        //p.u3=...
    }
    public Product composite(){
        return p;
    }
}

public class BuildProduct2 implements IBuild{//生成第2种Product
    Product p=new Product();
    public void createUnit(){
        //p.u=...
    }
    public void createUnit2(){
        //p.u2=...
    }
    public void createUnit3(){
        //p.u3=...
    }
    public Product composite(){
        return p;
    }
}

public class BuildProduct3 implements IBuild{//生成第3种Product
    Product p=new Product();
    public void createUnit(){
        //p.u=...
    }
    public void createUnit2(){
        //p.u2=...
    }
    public void createUnit3(){
        //p.u3=...
    }
    public Product composite(){
        return p;
    }
}

pulic class Director{
    private IBuild build;
    public Director(IBuild build){
        this.build=build;
    }
    public Product build(){
        build.createUnit();
        build.createUnit2();
        build.createUnit3();
        return build.composite();
    }
    public static void main(String[] args){
        IBuild build=new IBuild();
        Director direct=new Director();
        Product product=direct.build();
    }
}

class Student{
    String name;
    int age;
    Address add;
    Student(String name,int age,Address add){
        this.name=name
        this.age=age;
        this.add=add;
    
    }
    //省略getter\setter方法具体实现
    getter;
    setter;
}
class Address{
    String pro;
    String city;
    String zip
    public Address(String p,String c,String z){
        pro=p;city=c;zip=z;
    }
    getter;
    setter;
}

public class Student{
    Student(Student s){
    //省略代码学生基本信息类
        name=s.getName();
        age=s.getAge();
        add=s.getAdd();
    }
}
public class test{
    Adress add=new Address("liangzehua","dalian","116081");
    Student s=new Student("zhang",20,add);
    Student s2=new Student(s);//以s为原型复制对象s2
    Student s3=new Student(s);//以s为原型复制对象s3
}

class Address{
    public Address(Adress add){
        pro=add.getPro();
        city=add.getCity();
        zip=add.getZip();
    }
    
}
Class Student{
    Student (Student s){
        name=s.getName();
        age=s.getAge();
        add=new Address(s.getAdd());
    }
}

public class Student implements Cloneable{
    //其他代码同上
    protectd Object clone()throws CloneNotSupportedException{
        return super.clone();
    }
}
//测试类
public class Test{
    public static void main(String[] args){
        Address add=new Address("liaoning","dalian","116081");
        Student s=new Student("zhang",20,add);
        Student s2=(Student)s.clone();
    }
}

class Address implements Cloneable{
    protected Object clone() throws CloneNotSupportedException{
        Address add=(Address)super.clone();
        return add;
    }
}
class Student implements Cloneable{
    protected Object clone() throws CloneNotSupportException{
        Student s=(Student)super.clone();
        s.setAdd((Address)add.clone));
        return s;
    }
}
//test类同上

class Address implements Serializable{
    public Address(Adress add){
        pro=add.getPro();
        city=add.getCity();
        zip=add.getZip();
    }
}
class Student implements Clonable,Serializable{
    protected Object clone() throws CloneNotSupportException{
    Object obj=null;
    try{
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos=new ObjectOutputStream(bos);
        oos.writeObject(this);
        //从流里读回来
        ByteArrayInputStream bis = new ByteArrayInputStream();
        ObjectInputStream ois=new ObjectInputStream(bis);
        ois.readObject();
    }catch(Exception e){
        e.printStackTrace();
    }
    return obj;
    }
}

//以请假为例，少于一天组长决定，多于一天少于两条主任决定，两天以上经理决定

//请求类
public class Request(){
    int day;
    Request(int day){
        this.day=day;
    }
}

//抽象处理者
public abstract class Handler{

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

//三个具体处理者类（组长，主任，经理）
public class ZuZhang() extends Handler{
    static int limit=1;
    public boolean hanle(Request req){
        if(req.day<=limit){
            System.out.println("ZuZhang agree the request");
            return true;
        }
        return getNext.hanle(req);
    }
}
public class ZhuRen() extends Handler{
    static int limit=2;
    public boolean hanle(Request req){
        if(req.day<=limit){
            System.out.println("ZhuRen agree the request");
            return true;
        }
        return getNext.hanle(req);
    }
}
public class JingLi() extends Handler{
 
    public boolean hanle(Request req){
        System.out.println("JingLi agree the request");
        return true;
    }
}
//生成责任链前后顺序关系类
public class MyChain{
    private Handler one=new ZuZhang();
    private Handler two=new ZhuRen();
    private Handler three=new JingLi();
    public void createChain(){
        one.setNext(two);
        two.setNext(three);
    }

    public void handle(Request req){
        one.handle(req);
    }
}
//简单测试类
public Test{
    public static void main(String[] args){
        Request req=new Request(1);
        MyChain mc=new MyChain();
        mc.createChain();
        mc.handle(req);
    }
}

//抽象命令接口
interface ICommand{
    public void sweep();
}
//命令接收者
class Student{
    public void sweep(){
        System.out.println("we are sweeping the floor");
    }
    
}

//命令发送者
class Teacher implements ICommand{
    private Student receiver=null;
    public Teacher(Student receiver){
        this.receiver=receiver;
    }
    public void sweep(){
        receiver.sweep();
    }
}
//命令请求者
class Invoke{
    ICommand command;
    public Invoke(ICommand command){
        this.command=command;
    }
    public void execute(){
        command.execute();
    }
}
//测试类
public class Test{
    public static void main(String[] args){
        Student s=new Student();
        Teacher t=new Teacher(s);
        Invoke invoke=new Invoke(t);
        invoke.execute();
    }
}

//自定义迭代器模式
//抽象迭代器接口
public interface Iterator{
    Object next();
    boolean hasNext();
}
//聚合容器接口
public interface Collection{
    public void add(Object o);
    public Iterator iterator():
}
//自定义数组容器类
public class MyArrayList implements Collection{
    private Object[] elementData;
    private int size;
    public MyArrayList(int size){
        elementData=new Object[size];
        this.size=0;
    }
    public void add(Object o){
        if(this.size==elementData.length){
            int newSize=size*2;//容器扩容，并拷贝原数据
            elementData=Arrays.copyof(elementData,newSize);
        }
        elementData[size]=o;
        size++;
    }
    public Object get(int size){
        return elementData[size];
    }
    pulic Iterator iterator(){
        return new ArrayListIterator();
    }
    private class ArrayListIterator implements Iterator{
        private int currenIndex=0;
        public boolean hasNext(){
            if(currentIndex>=size) return false;
            else return true;
            
        }
        public Object next(){
            Object o=elementData[currentIndex];
            currentIndex++;
            return o;
        }
    }
}

//定义抽象需求分析接口IShape
interface IShape{
    float getArea();//明确的需求分析
    float getLength();//明确的需求分析
    Object accept(IVisitor v);//可扩展的需求分析
}
//定义具体功能实现类
class Triangle implements IShape{
    float x1,y1,x2,y2,x3,y3;
    public Triangle(float x1,float y1,float x2,float y2,float x3,float y3){
        this.x1=x2;
        ..........
    }
    public float getDist(float u1,float v1,float u2 , float v2){
         .....//求任意两点之间的距离
    }
    public float getArea(){}//求面积
    public float getLength(){}//求周长
    public Object accept(IVisitor v){
         return v.visit(this);
    }
}
//定义访问者接口
interface IVisitor{
    Object visit(Triangle t);
}
//定义其他扩展需求
class Point{
    float x,y;
}
class CenterVisitor implements IVisitor{
    public Object visit(Triangle t){
        Point pt=new Point();
        pt.x=(t.x1+t.x2+t.x3)/3;
        pt.y=(t.y1+t.y2+t.y3)/3;
        return pt;
    }
}
//simple test class
public class Test3{
    public static void main(String[] args){
        IVisitor v=new CenterVisitor();
        Triangle t=new Triangle(0,0,2,0,0,2);
        Point p=(Point)t.accept(v);
    }
}

//租房者
public class Renter{
    String NO;
    String name;
    Mediator me;
    Renter(String N,String na,Mediator me){
        No=N;name=na;this.me=me;
    }
    public String getNO(){
        return NO;
    }
    public String getName(){
        reutn name;
    }
    void receive(String msg){
        .....
    }
    void send(String msg){
        me.send(this,msg);
    }
}
//出租者
public class Saler{
    String NO;
    String name;
    Mediator me;
    Saler(String N,String na,Mediator me){
        NO=N;.....
    }
    getNO(){}
    getName(){}
    void receive(String msg){}
    void send(String msg){
        me.send(this,msg);
    }
}
//房屋中介者
public class Mediator{
    Map<String,Renter> m=new HashMap();
    Map<String,Saler> m2=new HashMap();
    void addRenter(Renter r){
        m.put(r.getNO(),r);
    }
    void addSaler(Saler s){
        m2.put(s.getNO(),s);
    }
    void send(Renter r,String msg){
        ....
        Set<String> se=m2.keySet();
        Iterator<String> it=se.iterator();
        while(it.hasNext){
            String key=it.next();
            Saler sa=m2.get(key);
            sa.receive(r.getNO()+rr.getName()+msg);
        }
    }
    void send(RentSaler rs,String msg){
        ....
        Set<String> se=m2.keySet();
        Iterator<String> it=se.iterator();
        while(it.hasNext){
            String key=it.next();
            Renter r=m.get(key);
            r.receive(s.getNO()+s.getName()+msg);
        }
    }
}
//test
pulic class Test{
     public static void main(String[] args){
         Mediator me=new Mediator();
         Renter r=new Renter("1000","li",me);
         Saler s=new Saler("2000","sun",me);
         Saler s2=new Saler("2001","sun2",me);
         me.addRenter(r);
         me.addSaler(s);me.addSaler(s);
         r.send("I want to rent a house");
         r.send("I want to sale a house");
     }
}

//备忘录类
public class Memento implements Serializable{
    private int pos;
    pulibc int getPos(){
        return pos;
    }
    public void setPos(int pos){
        this.pos=pos;
    }
}
//备忘录管理类
public class Caretaker{
    File file;
    String strPath;
    Catetaker(){
        strPath=this.getClass().getResources("/").getPath();
        file=new File(strPath+"two/Mymeme.txt");
    }
    public Memento getMemento(){
        Memento me=new Memento();
        if(file.exists()){
            try{
                .....//获取备忘录信息
            }catch(Exception e){e.printStackTrace();}
        }
    }
    pulic void saveMemento(Memento me){//保存到备忘录
        FileOutputStream fos=new FileOutputStream(strPath+"two/Mymeme.txt");
        ObjectOutputStream outobj=new ObjectOutputStream(fos);
        outobj.writeObject(me);
        
    }
}
//原生者类
pulic class ReadTopic{
    private long pos;
    private String strPath;
    private RandomAccessFile in;
    public ReadTopic(){
        strPath=this.getClass().getResource("/").getPath();
        in=new RandomAccessFile(strPath);
    }
    public void restoreFormMe(Memento me){
        pos=me.getPost();
        in.seek(pos);
    }
    public Memento createMemento(){
        pos=in.getFilePointer();
        Memento me=new Memento();
        me.setPos((int)pos);
        return me;
    }
    public String getNextTopic(){
        String s=null;
        s=in.readLine();
        return s;
    }
}

//test
public class Test{
     public static void main(String[] args){
         ReadTopic rt=new ReadTopic();
         Memento mt=new Memento();
         Caretaker ct=new Caretaker();
         Scanner sc=new Scanner(System.in);
         System.out.println("从断点处计算嘛？");
         String strMark=sc.nextLine();
         if(strMark.equals")){
             me=ct.getMemento();//获得备忘录对象
             rd.restoreFormMe(me)//恢复原发者状态
         }
         do{
             String tStrTopic =rd.getNextTopic()；//做题目
             ....
         }while(strMark.equals("y"));
         me.rd.createMemento();//创建备忘录
         rd.close();
         ct.saveMemento(me0;//保存备忘录对象
     }
}

//观察者接口IObserver
public interface IObserver{
    public void refresh(String data);
}
//主题接口ISubject
public interface ISubject{
    public void register(IObserver obs);//注册观察者
    public void unregister(IObserver obs);//撤销观察者
    public void notifyObservers()；//通知所以观察者
}
//主题实现类
public class Subject implemnts ISubject{
    private Vector<IObserver> vec = new Vector();//观察者维护向量
    private String data;//主题中心数据
    public String getData(){return data;}
    public void setData(String data){
        this.data=data;
    }
    public void register(IObserver obs){
        vec.add(obs);
    }
    public void unregister(IObserver obs){
        if(vec.contains(obs)){
            vec.remove(obs);
        }
    }
    public void notifyObservers(){
        for(int i=0;i<vec.size;i++){
            IObserver obs=vec.get(i）;
            obs.refresh(data);
        }
    }
    
}
//一个具体的观察者类
public class Observer implements IObserver{
    public void refresh(String data){
        System.out.println("I have received thd data:"+data_);
    }
}
//Test
public class Test{
    public static void main(String [] args){
        IObserver obs=new Observer();//定义观察者对象
        IObserver obs2=new Observer();//定义观察者对象2
        Subject subject=new Subject();//定义主题对象
        subject.register(obs);//主题添加观察者
        subject.register(obs2);
        subject.setData("hello");//主题中心数据改变了
        subject.notifyObservers();//通知所以观察者进行数据相应
    }
}

//定义状态抽象接口
interface IState{
    public void goState();
}
//定义状态实现类
class ConcreteStateA implements IState{
    public void goState(){
        System.out.println("this is ConcreteStateA");
    }
}
class ConcreteStateB implements IState{
    public void goState(){
        System.out.println("this is ConcreteStateB");
    }
}

//定义状态上下文维护类
class Context{
     private IState state;
     public void setState(IState state){
         this.state=state;
     }
     pulic void manage(){
         //根据条件选择状态
         state.goState();
     }
}

//抽象算法接口
public interface ICalc{
    int calc(int a,int b);
}
//计算两个整数加法
public class AddCalc implements ICalc{
    public int calc(int a,int b){
        return a+b;
    }
}
//计算两个整数减法
public class MinusCalc implements ICalc{
    public int calc(int a,int b){
        return a-b;
    }
}
//计算两个整数乘法
public class MulCalc implements ICalc{
    public int calc(int a,int b){
        return a*b;
    }
}
//计算两个整数除法
public class DivCalc implements ICalc{
    public int calc(int a,int b){
        return a/b;
    }
}
//选择器功能
public class Select{
    private ICalc obj;
    public Select(ICalc obj){
        this.obj=obj;
    }
    public int calc(int a,int b){
        return obj.calc(a,b);
    }
}
//test
public class Test{
    public static void main(String [] args){
        ICalc c=new AddCalc();
        Select obj=new Select(c);
        int result=obj.calc(1,2);
        System.out.println("result:"+result);
    }
}

public interface ILess<T>{
    boolean less(T x,T y);
}
//泛型方法类
public class Algo<T> {
    public T getMax(T t[],ILess<T> cmp){
        T maxValue=t[0];
        for(int i=1;i<t.length;i++){
            if(cmp.less(maxValue,t[i]){
                maxValue=t[i];
            }
        }
        return maxValue;
    }
}
//整型比较器
public class InteLess implements ILess<Integer>{
    public boolean less(Integer x,Integer y){
        return x<y;
    }
}
//学生基本类
public class Student{
    String name;
    int grade;
    public Student(String name,int grade){
        this.name=name;
        this.grade=grade;
    }
}
//学生成绩比较类
public class StudentLess implements ILess<Student>{
    public boolean less(Student x,Student y){
        return x.grade<y.grade;
    }
}
//Test
public class Test{
    public static void main(String[] args){
        Algo<Integer> obj=new Algo();
        ILess<Integer> cmp=new InteLess();
        Integer a[]={3,9,1,8};
        Integer max=obj.getMax(a,cmp);
        System.out.println("Integer max="+max);
        
        
        Algo<Student> obj2=new Algo();
        ILess<Student> cmp2=new InteLess();
        Student s[]={new Student("li",70),new Student("sun",99)};
        Student max2=obj2.getMax(s,cmp
        System.out.println("Student max grade ="+max);
    }
}

//定义抽象享元角色
public interface IFlyweight{
    String getUniversity();
    String getCity();
    String getProvince();
}
//具体享元类Flyweight
public class Flyweight implements IFlyweight{
    private String university;
    private String city;
    private String province;
    public Flyweight(String u,String c,String p){
    University=u;
    ...
    }
    getter();
}
//享元工厂类
public class FlyweightFactory{
    private FleyweightFactory(){}
    private static FlyweightFactory fact=new FlyweightFactory();
    private Map<String,IFlyweight> map=new HashMap();
    public synchronized static FlyweightFactory getInstance(){
        return fact;
    }
    public void addFlyweight(String key,IFlyweight fly){
        map.put(key,fly);
    }
    public synchronized IFlyweight getFlyWeight(String key){
        IFlyweight obj=map.get(key);
        return obj;
    }
    
}
//学生基本信息类
public class StudInfo{
    private String name;
    private int age;
    private IFlyweight fly;
    public StudInfo(String n,int a,IFlyweight f){
        name=n;
        ....
    }
    public void display(){
       System.out.println("name="+name);
       ....
    }
}
//Test
public class Test{
    public static void main(String[] args){
        FlyweightFactory fact=new FlyweightFactory.getInstance();
        IFlyweight fly=new IFlyweight("LNNU","DALIAN","LIAONING");
        IFlyweight fly2=new IFlyweight("JIDA","CHIANGHUN","JILIN");
        fact.addFlyweight("one",fly);//想享元工厂添加享元对象
        fact.addFlyweight("two",fly2);
        
        IFlyweight obj=null;
        obj=fact.getFlyweight("one");//从享元工厂获取享元对象
        StudInfo s-new StudInfo("zhang",20,obj);
        obj=fact.getFlyweight("two");
        StudInfo s2-new StudInfo("Li",20,obj);
        
        s.display();
        s2.display();
        
        
    }
}

public interface IMath{
    int add(int a,int b);
}

pulic class ThirdCompany{
    public int addCalc(int a,int b){
        return a+b;
    }
}

public class MyMath implements IMath{
    ThirdCompany third;
    public MyMath(ThirdCompany third){
       this.third=third;
    }
    public int add(int a,int b){
        return third.addCalc(a,b);
    }
}
//Test
pbulic class Test{
    public static void main(String[] args){
        ThirdCompany third=ThirdCompany();
        IMath obj=new MyMath();
        int v=obj.add(1,2);
        System.out.println(v);
    }
}

interface ITV{
   public void buyTV();
}
class Buyer implements ITV{
    public void buyTV(){
        System.out.println("i have bought the tv by proxy");
    }

}
//定义代理
class BuyerProxy implements ITV{
    private Buyer buyer;
    public BuyerProxy(Buyer buyer){
        this.buyer=buyer;
    }
    public void buyTV(){
       preProcess();
       buyer.buyTV();
       postProcess();
    }
    public void preProcess(){
       ...
    }
    public void postProccess(){...}
}

//定义邮寄接口
public interface IPost{
    public void post();
}
//平信邮寄类
pulic SimplePost imlements IPost{
    public void post(){
        System.out.println("this is Simple post");
    }
}
//挂号邮寄类
class MarkPost implement IPost{
   public void post(){
       System.out.println("this is Mark post");
   }
}
//抽象事物类
abstract class AbstractThing{
    private IPost obj;
    public AbstractThing(IPost obj){this.obj=obj}
    public void post(){
        obj.post();
    }
}
//具体事物类
//信件类
class Letter extends AbstractThing{
    public Letter(IPost obj){
        super(obj);
    }
}
//包裹类
class Parcel extends AbstractThing{
    public Parcel(IPost obj){
        super(obj);
    }
}
//通过abstractThing 类中的成员变量obj，他就像桥梁一样，使得事物类与功能类巧妙的结合
//test
public class Test{
    public static void main(Stirng[] args){
        IPost p=new SimplePost();
        Letter letter=new Letter(p);
        letter.post();
    }
}

interface ILogger{
    void log(String msg);
}
class ConsoleLogger implements ILogger{
    public void log(String msg){
    //控制台形式保存文件
       System.out.println(msg);
    }
}
class FileLogger implements ILogger{
    public void log(String msg){
    //文件形式保存日志
    }
}
//抽象装饰器
abstract class Decorator implements ILogger{
    protected ILogger logger;
    public Decorator(ILogger logger){
        this.logger=logger;
    }
}
//信息大写装饰类
class UpLogger extends Decorator{
   public UpLogger(ILogger logger){
       super(logger);
   }
   public void log(String msg){
       msg=msg.toUpperCase();
       logger.log(msg);
   }
}
//XML格式化装饰类
class XMLLogger extends Decorator{
    public XMLLogger(ILogger logger){
        super(logger);
    }
    public void log(String msg){
        String s="<msg>"+
        "<content>"+msg+"</content>"+
        "</msg>";
        logger.log(msg);
    }
}
//Test
public class Test{
    public static void main(String[] args){
        ILogger existobj=new FileLogger();
        ILogger newobj=new XMLLogger(existobj);
        String s[]={"how","are","you"};
        for(int i=0;i<s.length;i++){
            newobj.log(s[i]);
            thread.sleep(1000);
        }
        System.out.println("End");
    }
}

class Container{//冰箱冷藏功能类
    public void init(){
    //init
    }
    public void run(){//冰箱运行}
    public void shutdown(){//冰箱关机}
}
class Freezer{//冰箱冷冻功能类
    public void init(){
    //init
    }
    public void run(){//冰箱运行}
    public void shutdown(){//冰箱关机}
}
class Refrigerator{//外观类
    Container c=new Container();
    Freezer f=new Freezer();
    public void init(){
        c.init;
        f.init;
    }
    public void run(){
        c.run;
        f.run;
    }
    public shutdown(){
        c.shutdown;
        f.shutdown;
    }
}
//用户只需要指导冰箱，不需要知道冷藏室和冷冻室，也不要要知道他们的开关机。
public class Test{
    public static void main(String[] args){
        Refrigerator r=new Refrigerator();
        r.init();
        r.run();
        r.shutdown();
    }
}