老张Java加强

 1 public class Test {
 2     /*
 3      * 享元模式（flyweight）:很多小的对象有许多相同的属性，
 4      * 则把他们看成一个对象，不同的属性通过不同的函数参数实现(26个字符)
 5      */
 6     public static void main(String[] args) {
 7         
 8         //s和d若是在-128到127那么打印true（用的频率高），否则false；同样适用于Integer.valueOf()
 9         Integer s = 134;//自动打包
10         Integer d = 134;
11         System.out.println(s==d);
12         
13     }
14 }

 1 public class Week {
 2     private Week(){
 3         
 4     }
 5     /*
 6      * 为了节省时间只写了这两个
 7      */
 8     public static final Week sun = new Week();
 9     public static final Week mon = new Week();
10     
11     public Week nextDay() {
12         if(this==sun) {
13             return mon;
14         }else {
15             return sun;
16         }
17     }
18     
19     public String toString() {
20         return this==sun?"Sunday":"Monday";
21     }
22     
23 }

1 //调用的时候使用
2 Week w = Week.mon;

 1 public abstract class Week {
 2     private Week(){
 3         
 4     }
 5     
 6     //由于是abstract不可以直接new对象，但是可以经由子类，此处采用内部类
 7     public static final Week sun = new Week() {
 8 
 9         @Override
10         public Week nextDay() {
11             // TODO Auto-generated method stub
12             return mon;
13         }
14         
15         
16     };//必须加分号
17     
18     public static final Week mon = new Week() {
19 
20         @Override
21         public Week nextDay() {
22             // TODO Auto-generated method stub
23             return sun;
24         }
25         
26     };
27     
28     public abstract Week nextDay();//必须加上abstract，否则总提示需要返回值
29     
30     //抽象类中可以有非抽象方法,子类实现该类的时候可以不重写该方法
31     public String toString() {
32         return this==sun?"Sunday":"Monday";
33     }
34     
35 }

 1 public class Test {
 2     public static void main(String[] args) {
 3         
 4         Week w = Week.mon;
 5         
 6         System.out.println(w);//Monday
 7         System.out.println(w.nextDay());//Sunday
 8         
 9         System.out.println("------ok--------");
10     }
11 }
12 /*下面的编译出错，因为Week的构造方法是private的，在类外不能new，这就是单例模式
13 class MyWeek extends Week {
14 
15     @Override
16     public Week nextDay() {
17         // TODO Auto-generated method stub
18         return Week.mon;
19     }
20     
21 }
22 */

 1 /*
 2  * 枚举类型（java1.5才有）：Java.lang.Enum，
 3  * 例子：假设一个宝箱只能由两个人开启；
 4  * 只能取特定值中的一个，也就是只可以取特定值之一。
 5  * 和C/.C++的枚举类型不同的是必须使用枚举类型名点访问某一值，
 6  * 类似静态变量，C/.C++中是下标从0开始可以分别指定表示什么。
 7  * 写游戏时物体只可以朝四个方向运动当然可以使用int类型1、2、3、4，
 8  * 但是下面写时谁知道会不会写成5，编译时难以发现错误，
 9  * 但是使用枚举类型就可以发现错误。
10  */
11 public class TestEnum {
12     //MyColor是一种类型，所以首字母大写，定义的颜色很像静态变量，因为可以用类型名点访问
13     public enum MyColor {
14         red, green, blue
15     };
16     
17     public static void main(String[] args) {
18         MyColor m = MyColor.red;//定义的颜色很像静态变量
19         switch(m) {
20             case red:
21                 System.out.println("red");
22                 break;
23             case green:
24                 System.out.println("green");
25                 break;
26             case blue:
27                 System.out.println("blue");
28                 break;
29             default:
30                 System.out.println("没有该颜色！");
31         }
32         System.out.println(m);//打印red，说明已经重写了toString()方法
33         System.out.println(m.name());
34         System.out.println(m.ordinal());//返回编号
35         System.out.println(MyColor.valueOf("red").toString());//从浏览器得到的是字符串，一定会用到该方法
36         System.out.println(MyColor.values().length);//先转为数组
37     }
38 
39 }

 1 public class TestEnum {////枚举类型的构造方法必须写在元素下，且必须是private
 2     //MyColor是一种类型，所以首字母大写，定义的颜色很像静态变量，因为可以用类型名点访问
 3     public enum MyColor {
 4         red(1), green(), blue;
 5         
 6         private MyColor() {
 7             System.out.println("first");
 8         }
 9         
10         private MyColor(int day) {
11             System.out.println("second");
12             
13         }
14             
15     };
16     
17     public static void main(String[] args) {
18         MyColor m = MyColor.red;//定义的颜色很像静态变量
19         System.out.println(m);//打印red，说明已经重写了toString()方法
20         System.out.println(m.name());
21         System.out.println(m.ordinal());//返回编号
22         System.out.println(MyColor.valueOf("red").toString());//从浏览器得到的是字符串，一定会用到该方法
23         System.out.println(MyColor.values().length);//先转为数组
24     }
25 
26 }
27 //由结果看出,元素生成的时候自动调用的是无参数的构造方法，在元素后加上参数就调用有参的，只加一对括号还是无参
28 /*
29  * second
30 first
31 first
32 red
33 red
34 0
35 red
36 3
37 */

 1 public class TestMain{    
 2     public static void main(String args[]){        
 3         
 4         System.out.println("这是真正的主方法");        
 5         main("Hello World!");    
 6     }    
 7     public static void main(String str){        
 8         
 9         System.out.println(str);    
10     }
11 }
12 //源文件的名字：TestMain.java编译通过，执行结果：D:\MyPro>javac TestMain.javaD:\MyPro>java TestMain这是真正的主方法Hello World!