JAVA中Junit、静态导入、枚举和单例设计模式

知识点一：Junit的使用(有四个类Person.class、PersonTest.class、PersonTest1.class、PersonTest2.class)

先写个Person类：

[java] view plain copy

1. public class Person {  
2.     public void run()  
3.     {  
4.         System.out.println("run.....");  
5.     }  
6.     public int[] array()  
7.     {  
8.         return new int[]{1,2};  
9.     }  
10.     public int  speak()  
11.     {  
12.         return 12;  
13.     }  
14.     public void eat()  
15.     {  
16.         System.out.println("eat.....");  
17.     }  
18. }  

PersonTest：

为Person类写两个测试方法testRun和testEat,需要有@Test注解，并且要引入相关包。我们看到在开头和结尾有两个方法，分别是bfore和after(方法名可以自定义)，它们的注解分别是@Before和@Afterj,这两个方法会在每个测试方法运行前后都执行一次，用来给测试方法中所需要的资源进行初始化和释放资源,例如下面可以将pp的初始化放在before,释放放在after中。而不必在每个测试方法中都写Person pp=new Person()，如果有几百个测试方法，那么再这样写就是灾难。所以放在@Before注解的方法中最合适了，最后在@After注解的方法中释放资源即可

[java] view plain copy

1. public class PersonTest1 {  
2.     @BeforeClass  
3.     public static void beforeClass()  
4.     {  
5.         System.out.println("beforeClass");  
6.     }  
7.     @Test  
8.     public void testRun(){  
9.         Person p=new Person();  
10.         p.run();  
11.     }  
12.     @Test  
13.     public void testEat()  
14.     {  
15.         Person pp=new Person();  
16.         pp.eat();  
17.     }  
18.     @AfterClass  
19.     public static void afterClass()  
20.     {  
21.         System.out.println("afterClass");  
22.     }  
23. }  

PersonTest2:

断言：用于测试需要测试的类的真实值是否是自己期望的。下面列举了Assert类中的assertEquals和assertArrayEquals方法，他们的参数第一个是期望的值，第二个参数是被测试方法的返回的实际的值.

[java] view plain copy

1. public class PersonTest2 {  
2.       
3.     @Test  
4.     public void testSpeak(){  
5.         Person pp=new Person();  
6.         Assert.assertEquals(12, pp.speak());//测试speak这个方法运行的结果是不是你想要的，即是否是12,  
7.           
8.     }  
9.   
10.     @Test  
11.     public void testArray()  
12.     {  
13.         Person pp=new Person();  
14.         //测试某个方法返回的数组是否是第一个参数中数组相同，即是否是你想要的，  
15.         Assert.assertArrayEquals(new int[]{1,2}, pp.array());  
16.     }  
17.   
18. }  

知识点二：静态导入

就是说一个类中的某个静态方法在另外一个类中频繁使用时，就可以将其静态导入(例如Arrays这个类，它里面全是静态方法，如果在另外一个类中频繁调用Arrays.asList()方法，我们就可以在所谓的“另外一个类”中静态导入这个Arrays这个类的某个或全部的静态方法)

格式：import static day1.itcast.demo.speak;

day1.itcast.demo.speak只是个例子，意思是day1.itcast包下的demo类中的speak方法

知识点三：枚举(用到了Junit)

先举个例子说明枚举是怎么来的:

枚举是1.5以后的新特性,枚举的作用：一些函数在运行时，需要传入的参数不是任意的，而是一定范围内的，下面看个例子。下面的方法是jdk1.5以前的解决方法

[java] view plain copy

1. public class EnumDemo {  
2.     /* 
3.      * 枚举是1.5以后的新特性 
4.      * 枚举的作用：一些函数在运行时，需要传入的参数不是任意的，而是一定范围内的，下面看个例子。 
5.      * 下面的方法是jdk1.5以前的解决方法 
6.      * */  
7.       
8.       
9.     /*1 
10.      这个method方法要求传入的参数是自定义Argument类的类型，我们要传入Argument类型的参数 
11.     想到的是Argument类的一个实例就行了，这个实例通常会Argument arg=new  Argument（）； 
12.     但是如果Argument类的构造函数被private呢，具体看测试方法testMethod() 
13.      */  
14.     public void method(Argument arg)  
15.     {  
16.         System.out.println("枚举举例");  
17.     }  
18.       
19.     //2  
20.     @Test  
21.     public void testMethod()  
22.     {  
23.         //下面被注释的部分是不允许的，因为Argument被私有化了  
24.         //Argument arg=new  Argument();  
25.         //为了解决这个问题，我们可以在Argument类中先定义好一些Argument的几个实例，  
26.         //然后直接调用即可，看Argument类中具体代码  
27.         Argument arg=Argument.B;  
28.         method(arg);  
29.     }  
30.       
31.     //5看下利用枚举是怎么解决这个问题的  
32.     public void method2(Argument1 arg)  
33.     {  
34.         System.out.println("枚举举例");  
35.     }  
36.       
37.     //6看枚举类，就知道很简单了，不做赘述  
38.     @Test  
39.     public void testMethod2()  
40.     {  
41.         Argument1 arg=Argument1.A;  
42.         method2(arg);  
43.     }  
44.       
45.       
46. }  
47.   
48.         //4  
49.     class Argument{  
50.         //将Argument类进行私有化，防止外界创建对象  
51.         private Argument(){};  
52.   
53.         /* 
54.          * 如果外界想要Argument的对象怎么办？外界不能实例化但是自己可以实例话 
55.          * 所以在自己内部实例化几个公有的static的Argument的实例， 
56.          * 这样即可提供给外界使用 
57.          *  
58.          * */  
59.         public static final Argument A=new Argument();  
60.         public static final Argument B=new Argument();  
61.         public static final Argument C=new Argument();  
62.         public static final Argument D=new Argument();  
63.     }  
64.   
65.     enum Argument1{  
66.         A,B,C,D  
67.     }  

上的例子是说明枚举是怎么来的，下面具体看枚举的分析：

代码：（主要讲三点）

[java] view plain copy

1. public class EnumAbstract {  
2.     ////////////////////////////////第一点  
3.     public void method(Grade grade)  
4.     {  
5.         String value=grade.getValue();  
6.         System.out.println(value);  
7.     }  
8.       
9.     @Test  
10.     public void testMehod()  
11.     {  
12.         method(Grade.A);  
13.     }  
14.       
15.     /* 
16.       下面看具体的一个枚举实例：我们自定义了一个枚举，希望外界使用这个枚举中的某个值时，能获取这个值所代表的具体值，怎么做？看下面分析： 
17.      这个枚举中有5个枚举对象，有String类型的属性value(用于封装每个枚举值的数据)，私有的构造方法（注意这个构造方法必须是私有的， 
18.          如果是public，那么外界就可以修改枚举值了，所以定义成私有的），供外界获取枚举值的方法getValue；很明显这样设计一个枚举, 
19.          就可以在外界通过getValue获取每个枚举值所对应的具体值了。 
20.       
21.      小分析：通常可能看到的枚举是这样的:enum WeekDay{SUN,MON,THU,WED,THR,FRI,SAT;} 
22.      而下面的每个枚举对象都是形如这样的A("100-90")，如果不这样定义该怎么定义， 
23.      因为里面已经显示的写了一个带参数的构造方法了啊(WeekDay中没有写是因为有了默认的构造方法了，所以没有像A("100-90")这样写，而是SUN())， 
24.      A,B...都是枚举的一个个具体实例，既然有个带参数的构造方法，那么在定义一个个实例时，是不是要给它具体实例化(形如new Person(12)) 
25.       
26.      * */  
27.     enum Grade{  
28.         A("100-90"),B("89-80"),C("79-70"),D("69-60"),E("59-0");  
29.         private String value;  
30.         private Grade(String str)  
31.         {  
32.             this.value=str;  
33.         }  
34.           
35.         public String getValue()  
36.         {  
37.             return value;  
38.         }  
39.     }  
40.     ///////////////////////////////第二点  
41.     public void method2(Grade2 grade)  
42.     {  
43.         String value=grade.getlocalValue();  
44.         System.out.println(value);  
45.     }  
46.       
47.     @Test  
48.     public void testMethod2()  
49.     {  
50.         method2(Grade2.A);  
51.     }  
52.       
53.     /* 
54.      再看一种情况：带抽象的枚举。上面的枚举如果拿给另外一个程序员用， 
55.      他想要的成绩是这样的A-->优，B-->中，C-->良，D-->及格，E-->差，但是又想保留原来那中数字格式的 
56.       怎么做？这就用到了抽象方法了 
57.      * */  
58.     enum Grade2{  
59.         A("100-90"){  
60.             @Override  
61.             String getlocalValue() {  
62.                 return "优";  
63.             }  
64.         },  
65.         B("89-80"){  
66.             @Override  
67.             String getlocalValue() {  
68.                 return "中";  
69.             }  
70.         },  
71.         C("79-70"){  
72.             @Override  
73.             String getlocalValue() {  
74.                 return "良";  
75.             }  
76.         },  
77.         D("69-60"){  
78.             @Override  
79.             String getlocalValue() {  
80.                 return "及格";  
81.             }  
82.         },  
83.         E("59-0"){  
84.             @Override  
85.             String getlocalValue() {  
86.                 return "差";  
87.             }  
88.         };  
89.         private String value;  
90.         private Grade2(String str)  
91.         {  
92.             this.value=str;  
93.         }  
94.           
95.         public String getValue()  
96.         {  
97.             return value;  
98.         }  
99.           
100.         //在枚举中定义一个抽象方法，具体实例枚举的一个个对象时,实现这个方法即可  
101.         abstract String getlocalValue();  
102.     }  
103.   
104.          ///////////////////////////////////////////第三点  
105.     //Enum类的一般方法使用，所有的枚举类都是Enum类在子类，即使没有明确的写extends Enum  
106.     @Test  
107.     public void testGeneral()  
108.     {  
109.         //获取枚举中具体某个对象的值,结果是"100-90"  
110.         System.out.println(Grade.A.value);  
111.         //获取具体枚举对象的名称；结果是A  
112.         System.out.println(Grade.A.name());  
113.         //获取枚举对象的序数，结果是0  
114.         System.out.println(Grade.A.ordinal());  
115.           
116.         /* 
117.          枚举的valueOf方法，作用:将某个字符串转换成自定义的枚举对象 
118.          举个例子：在网页上我们可能填过表单(就是注册用户是要填写信息的表单，什么姓名、年龄，性别等) 
119.          就拿性别来说，我们填写好之后提交数据到服务器，服务器会将性别这个字符串中的值(男或女)，转换成服务器端自定义枚举的一个对象， 
120.          如果自定义枚举中有这个值，那么运行正常，如果没有就会报错，可能会提示用户没有选择性别这一项， 
121.          * */  
122.         //String str="K";//会报错，因为Grade中没有这个对象  
123.         String str="B";  
124.         Grade gg=Grade.valueOf(str);  
125.         System.out.println(gg.name());  
126.           
127.         //获取枚举中的对象，返回的是一个枚举数组，作用：我们通常不知道别人定义的枚举中有哪些对象时，  
128.         //就可以这样查看别人定义的枚举中有哪些枚举对象了  
129.         Grade[] grades=Grade.values();  
130.         for(Grade g:grades)  
131.         {  
132.             System.out.println(g.name());  
133.         }  
134.     }  
135. }  

总结：

枚举类也是一种特殊形式的Java类

枚举类中声明的每一个枚举值代表枚举类的一个实例对象

与java中的普通类一样，在声明枚举时，也可以声明属性、方法和构造方法，但枚举类的构造函数必须为私有

枚举也可以实现接口、或继承抽象类

Jdk5中扩展了switch语句，它除了可以接收int、byte、char、short这四种基本数据类型外，还可以接收一个枚举类型

如枚举类只有一个枚举值，测可以当做单例设计模式使用

知识点四：单例设计模式

解决一个类在内存中存在一个对象。

想要保证对象的唯一性：

1.为了避免其它程序过多建立该类对象，先禁止其它程序建立该对象(将构造函数私有化)

2.还为了让其它程序可以访问到该类对象，只有在本类中，自定义一个对象

3.为了方便其它程序对自定义的对象访问，可以对外提供一个方法

具体实现方式：

1.将构造函数私有化2.在类中创建一个本类对象3.提供一个方法可以获取该对象，以便提供出去给外界使用

饿汉式：

[java] view plain copy

1. public class Demo {  
2.     //将构造函数私有化，防止外界实例化对象  
3.     private Demo(){};  
4.     //在本类中定义一个Demo的实例  
5.     private static Demo demo=new Demo();  
6.     //外界如果想要得到Demo类在一个实例，只有通过下面这个方法，并且返回类型是Demo类型的  
7.     public static Demo getInstance()  
8.     {  
9.         return demo;  
10.     }  
11.       
12.     public static void main(String[] args)  
13.     {  
14.         Demo demo=Demo.getInstance();  
15.         //拿到Demo的一个实例以后，想对Ｄｅｍｏ做什么就做什么吧  
16.     }  
17. }  

懒汉式：对象是方法别调用是，才初始化，也叫做对象的延时加载。Demo1类进内存，对象还没有存在，只有调用了getInstance方法时才建立对象

[java] view plain copy

1. public class Demo1 {  
2.     private Demo1(){};  
3.     private static Demo1 demo=null;  
4.     public static Demo1 getInstance()  
5.     {  
6.         if(demo==null)  
7.         {  
8.             synchronized(Demo1.class)  
9.             {  
10.                 //双重判断为了消除安全隐患，没有将synchronized方法方法上是因为双重判断可以  
11.                 //减少读锁的次数。  
12.                 if(demo==null)  
13.                     demo=new Demo1();  
14.             }  
15.         }  
16.         return demo;  
17.     }  
18.       
19.     public static void main(String[] args)  
20.     {  
21.         Demo1 demo=Demo1.getInstance();  
22.           
23.     }  
24. }