老张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.