老张Java加强

1.javaw是java的图形虚拟机，结束其便可结束Eclipse，不过我没在taskmgr发现有。
2.必须设置断点后才可以debug，否则debug后无法查看变量也无法下一步，此时选择变量才可以右键watch。
3.高版本的java可以运行低版本的javac，相反就不行了。
4.选择工程点右键preference下的javacompiler必须和window下的preference里的javaJDK一个版本。
5.也就是说具体某工程的配置和工作台的配置可以不一样，这就是继承与覆盖。
6.配置模板：window --perferences--java--editor--Template；通过右键surround with调用；也是要先选择代码，或者alt+shift+z。
比如定义了sysout代替System.out.println()且光标定位在括号里，那么输入sysout并按alt+?即可，不是在surround with里找。
7.jdk里可以静态导入(import static)，导入一个类里的所有静态方法(import导入所有类)，那么使用的时候便不必加上类名。
8.被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写；不能通过访问权限、返回类型、抛出的异常进行重载；对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。
子类方法不能缩小父类方法的访问权限；子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
9.增强型for循环:for(type 变量名 : 集合变量名)，迭代变量必须在for内定义，集合变量是数组或者实现了iterator接口的集合类。

10.享元模式

 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 }

11.普通类实现枚举

　　一定要是对象，枚举类型的每个对象都可以调用getClass和getName等。

 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;

12.枚举类型也是后来才加入的，原来以为用不到；这就像我们的学习过程，不同的阶段对知识的需求不同。
13.抽象类中可以有非抽象方法，比如toString，子类实现该类的时候可以不重写该方法，看下面的例子。

　　采用内部类把本来需要在nextDay写很多代码转移到了各个子类里。

 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 */

14.enum

 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 }

15.枚举类型使用构造方法

 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 */

16.外部类的修饰符为public或者默认；内部类和方法是平级的，可以有四个访问控制符；声明数组要int[] array不要int array[],前一种一看就知道是一种类型。

17.在java中main方法也可以重载，也就是说在一个源程序里只有一个main是错误的；在不同的类里可以有相同的public static void main(String args),主类是public类。　　

 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!

18.反射的作用：实现框架功能。

19.hashCode

View Code

 1 package b;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collection;
 5 import java.util.HashSet;
 6 
 7 public class Reflect {
 8 
 9     public static void main(String[] args) {
10         // TODO Auto-generated method stub
11         /*
12          * new ArrayList()的话不论是否重写hashCode和equals都输出5；
13          * new HashSet()重写前是4，后是3
14          */
15         //Collection coll = new ArrayList();
16         Collection coll = new HashSet();
17         Pointer p1 = new Pointer(1, 1);
18         Pointer p2 = new Pointer(1, 1);
19         Pointer p3 = new Pointer(3, 3);
20         Pointer p4 = new Pointer(4, 4);
21         
22         coll.add(p1);
23         coll.add(p2);
24         coll.add(p3);
25         coll.add(p4);
26         coll.add(p4);
27         
28         /*
29          * 参与hashCode运算的值，在加载后就不应该再改动，否则删除的话是删不掉的（不会报错），这就是内存泄露
30          */
31         System.out.println(coll.size());
32         
33     }
34 
35 }
36 
37 class Pointer {
38     public int x = 0;
39     public int y = 0;
40     
41     public Pointer(int x, int y) {
42         super();
43         this.x = x;
44         this.y = y;
45     }
46 
47     @Override
48     public int hashCode() {
49         final int prime = 31;
50         int result = 1;
51         result = prime * result + x;
52         result = prime * result + y;
53         return result;
54     }
55 
56     @Override
57     public boolean equals(Object obj) {
58         if (this == obj)
59             return true;
60         if (obj == null)
61             return false;
62         if (getClass() != obj.getClass())
63             return false;
64         Pointer other = (Pointer) obj;
65         if (x != other.x)
66             return false;
67         if (y != other.y)
68             return false;
69         return true;
70     }
71     
72     
73 }

20.