java学习05

package day20140918;

import org.junit.Test;
/*
 * 由于昨天面试问到了单例模式
 * 回顾一下
 * 单例设计模式
 * */


//饿汉式，类一加载就存在，线程安全
class SingleE{

    //定义一个私有成员，便于测试
    private int num = 1;
    private static final SingleE single = new SingleE();
    
    private SingleE(){
        num++;
    }
    
    public static SingleE getInstance(){
        return single;
    }
    
    public int getInt(){
        return num;
    }
}

//懒汉式，后加载，线程不安全
class SingleL{
    
    private SingleL(){}
    
    private static SingleL single = null;
    
    public static SingleL getInstance(){
        //两层判断，提高程序的效率，不加这层判断，则每次都要判断锁，程序效率很低
        if(single == null){
            //加锁，防止多线程时，同时生成多个single，不能保证唯一性
            synchronized (SingleL.class) {
                if(single == null){
                    single = new SingleL();
                }
            }
        }
        return single;
    }
}


public class SingleDemo {
    
    @Test
    public void test(){
        
        SingleE s1 = SingleE.getInstance();
        
        System.out.println(s1.getInt());        //2
        SingleE s2 = SingleE.getInstance();
        
        System.out.println(s1.getInt());        //2
        System.out.println(s2.getInt());        //2
        
    }
    
}

package day20140918;

import org.junit.Test;

/*
 * 枚举enum的学习,写一个代表星期的枚举，里面有一个方法，返回对象星期的中文名。
 * 
 * */
public class Syudy {
    
    //定义一个枚举，表示星期一到星期天
    enum WeekDay{
        
        //7个对象
        MON("星期一"),
        TUE("星期二"),
        WED("星期三"),
        THU("星期四"),
        FRI("星期五"),
        SAT("星期六"),
        SUN("星期日");
        
        private String weekName;
        
        //构造函数必须私有，因为枚举只能取定义的值，外部不能new对象
        private WeekDay(String weekName){
            this.weekName = weekName;
        }
        
        public String getName(){
            return weekName;
        }
    }
    
    @Test
    public void test1(){
        
        System.out.println(WeekDay.TUE);                  //TUE
        System.out.println(WeekDay.TUE.getName());        //星期二
    }
    
    
    //第二种方法，用抽象函数
    enum WeekDay1{
        
        MON(){
            public String getWeekName(){
                return "星期一";
            }
        },
        
        TUE{
            public String getWeekName(){
                return "星期二";
            }
        },
        
        WED{
            public String getWeekName(){
                return "星期三";
            }
        },
        
        THU{
            public String getWeekName(){
                return "星期四";
            }
        },
        
        FRI{
            public String getWeekName(){
                return "星期五";
            }
        },
        SAT{
            public String getWeekName(){
                return "星期六";
            }
        },
        
        SUN{
            public String getWeekName(){
                return "星期日";
            }
        };
        
        
        //定义一个抽象方法，获得星期中文名
        public abstract String getWeekName();
    }
    
    @Test
    public void test2(){
        
        WeekDay1 fri = WeekDay1.FRI;
        
        System.out.println(fri.getWeekName());       //星期五
        
        //枚举的偏移量，从0开始
        System.out.println(fri.ordinal());           //4
        
        //得到枚举的所有对象
        WeekDay1 [] wds = WeekDay1.values();
        
        for(WeekDay1 wd : wds){
            System.out.println(wd.getWeekName());
        }
        
        /*星期一
        星期二
        星期三
        星期四
        星期五
        星期六
        星期日*/

    }
}