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.
作者：火星十一郎
本文版权归作者火星十一郎所有，欢迎转载和商用，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利.
