老张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.享元模式

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

11.普通类实现枚举

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

public class Week {
    private Week(){
        
    }
    /*
     * 为了节省时间只写了这两个
     */
    public static final Week sun = new Week();
    public static final Week mon = new Week();
    
    public Week nextDay() {
        if(this==sun) {
            return mon;
        }else {
            return sun;
        }
    }
    
    public String toString() {
        return this==sun?"Sunday":"Monday";
    }
    
}

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

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

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

public abstract class Week {
    private Week(){
        
    }
    
    //由于是abstract不可以直接new对象，但是可以经由子类，此处采用内部类
    public static final Week sun = new Week() {

        @Override
        public Week nextDay() {
            // TODO Auto-generated method stub
            return mon;
        }
        
        
    };//必须加分号
    
    public static final Week mon = new Week() {

        @Override
        public Week nextDay() {
            // TODO Auto-generated method stub
            return sun;
        }
        
    };
    
    public abstract Week nextDay();//必须加上abstract，否则总提示需要返回值
    
    //抽象类中可以有非抽象方法,子类实现该类的时候可以不重写该方法
    public String toString() {
        return this==sun?"Sunday":"Monday";
    }
    
}

public class Test {
    public static void main(String[] args) {
        
        Week w = Week.mon;
        
        System.out.println(w);//Monday
        System.out.println(w.nextDay());//Sunday
        
        System.out.println("------ok--------");
    }
}
/*下面的编译出错，因为Week的构造方法是private的，在类外不能new，这就是单例模式
class MyWeek extends Week {

    @Override
    public Week nextDay() {
        // TODO Auto-generated method stub
        return Week.mon;
    }
    
}
*/

14.enum

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

}

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

public class TestEnum {////枚举类型的构造方法必须写在元素下，且必须是private
    //MyColor是一种类型，所以首字母大写，定义的颜色很像静态变量，因为可以用类型名点访问
    public enum MyColor {
        red(1), green(), blue;
        
        private MyColor() {
            System.out.println("first");
        }
        
        private MyColor(int day) {
            System.out.println("second");
            
        }
            
    };
    
    public static void main(String[] args) {
        MyColor m = MyColor.red;//定义的颜色很像静态变量
        System.out.println(m);//打印red，说明已经重写了toString()方法
        System.out.println(m.name());
        System.out.println(m.ordinal());//返回编号
        System.out.println(MyColor.valueOf("red").toString());//从浏览器得到的是字符串，一定会用到该方法
        System.out.println(MyColor.values().length);//先转为数组
    }

}
//由结果看出,元素生成的时候自动调用的是无参数的构造方法，在元素后加上参数就调用有参的，只加一对括号还是无参
/*
 * second
first
first
red
red
0
red
3
*/

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

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

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

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

19.hashCode

package b;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

public class Reflect {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
         * new ArrayList()的话不论是否重写hashCode和equals都输出5；
         * new HashSet()重写前是4，后是3
         */
        //Collection coll = new ArrayList();
        Collection coll = new HashSet();
        Pointer p1 = new Pointer(1, 1);
        Pointer p2 = new Pointer(1, 1);
        Pointer p3 = new Pointer(3, 3);
        Pointer p4 = new Pointer(4, 4);
        
        coll.add(p1);
        coll.add(p2);
        coll.add(p3);
        coll.add(p4);
        coll.add(p4);
        
        /*
         * 参与hashCode运算的值，在加载后就不应该再改动，否则删除的话是删不掉的（不会报错），这就是内存泄露
         */
        System.out.println(coll.size());
        
    }

}

class Pointer {
    public int x = 0;
    public int y = 0;
    
    public Pointer(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + x;
        result = prime * result + y;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Pointer other = (Pointer) obj;
        if (x != other.x)
            return false;
        if (y != other.y)
            return false;
        return true;
    }
    
    
}

20.