黑马程序员-Java高新技术(一)

------- android培训、 java培训、期待与您交流！ ----------

Eclipse的使用技术
工欲善其事，必先利其器

 

MyEclipse和Eclipse的区别
  MyEclipse是Eclipse的插件，我们先安装上Eclipse，而MyEclipse就是在Eclipse基础上加一个插件，扩展了
Eclipse的功能，让它可以开发J2EE的程序，就是WEB项目。每次我们都要下载Eclipse，安装Eclipse，再下载
MyEclipse插件再安装MyEclipse插件，于是MyEclipse厂商想到能不能把它们打包成一体化？你下载一个东西，
打包的工具，下载下来再安装，就连Eclipse以及MyEclipse插件都安装好了，就免得你再分步骤安装了。

Workspace与project-工作空间与工程
一个Workspace可以包含多个project，一个workspace保留了eclipse的一套环境选项的配置，例如，所使用的
javac和java命令，等等。细节查看window-->Preferences。如果要为eclipse再配制一套环境选项，可以再创
建一个workspace。Package explorer视图窗口中的files菜单项。

IDE开发工具都支持使用工程化方式管理一个项目的程序开发过程，一般来说一个相对独立的项目就是一个工程，
一个项目中涉及的多个java文件，资源文件等用一个工程进行管理。

Perspective与View-透视图和视图
一个Perspective代表了若干个view的集合，如何显示各种view。

设置单个工程的javac与java
  |--高版本的java能否运行低版本的javac编译程序？能
  |--低版本的java能否运行高版本的javac编译程序？不能
工作空间设置：
  编译版本的设置：window -- Preferences -- java -- Compiler
  运行版本的设置：window -- Preferences -- java -- Installed JREs
单个工程：
   编译版本的设置：右击工程 -- Properties -- java Compiler
   运行版本的设置：右击工程 -- Run As -- Run Configurations -- JRE
多想一想：
   eclipse工作空间中的所有工程继承工作空间的配置，其中某个工程也可以
   覆盖工作空间的配置！这是不是java面向对象的思想啊？

代码模板
  添加新模板
window -- Preferences -- Java -- Editor -- Content Assist -- Templates -- New 
  原来的内容：line_selection
  光标位置：cursor
使用模板
  选中内容 -- 右击 -- Surround With -- 模板

 
知识点加强-JDK1.5新特性
1.静态导入
  import语句可以导入一个类或某个包中的所有类
  import static语句导入一个类中的某个静态方法或所有静态方法
  语法举例：
  import static java.lang.Math.sin;
  import static java.lang.Math.*;
2.可变参数
可变参数的特点：
只能出现在参数列表的最后
...位于变量类型和变量名之间，前后有无空格都可以;
调用可变参数的方法时，编译器为该可变参数隐含创建
一个数组，在方法体中以数组的形式访问可变参数。
例：

public static void main(String[] args)  {  
    System.out.println(add(1,2));  
    System.out.println(add(2,3,4));  
}  
public static int add(int x,int ... args)  {  
    int sum = x;  
    for(int i = 0; i < args.length; i++)  {  
        sum += args[i];  
    }  
    return sum;  
}  

增强for循环
语法：
for(type 变量名:集合变量名)
{...}
迭代，如上面add方法for循环：
for(int arg : args){
sum += arg;
}
注意：
迭代变量必须在()中定义！
集合变量可以是数组或实现了Iterable接口的集合类

基本数据类型的自动拆箱与装箱
Inter num1 = 12;
装箱：自动把一个基本数据类型装成了Integer对象，再赋给了引用变量。
System.out.println(num1 + 3);
拆箱：把一个引用类型变量拆箱成一个基本类型数据。
Integer i1 = 5; 
Integer i2 = 5; 
System.out.println(i1 == i2);//true 
 
Integer i1 = 136; 
Integer i2 = 136; 
System.out.println(i1 == i2);//false 

byte常量池
对于这些基本数据整数要装箱成Integer对象的时候，如果这
个数据在1字节(-128 ~ 127)的数字，就缓存起来，在一个池
里，叫byte常量池，如果把一个整数装成Integer对象，是一
个字节以内的话，先看池子里面有没有，如果有直接从池子里
面拿来个。这样节省了内存空间。
这是一种设计模式
叫做享元模式。(flyweight)
什么叫享模式：
就是有很多个小的对象，他们有很多属性相同，把他们
    变成一个对象，那些不同的属性，把它们变为方法的参数，
    称之为外部状态，那些相同的属性的称之为这个对象的内部
    状态。
应用：
1.word中输入英文字母，可创建26对象，每个对象值是出现的位置不同（坐标），所以可用一个对象调用位置的方法：
如，字母i：i.display(intx,int y)，将高度重复使用的char类型的字母i封装成一个对象使用。
2.图标：window下的文件夹图标，只哟名称这个属性不同，包含了很多其他相同的属性，那么可以应用享元模式。

枚举(1.5新特性)
1.通过enum定义枚举类，在其中列出所有同类的元素常量值作为子类的实例对象使用。枚举类是一个特殊的类，
每个元素都是该类的一个实例对象。
2.用枚举类规定值，WeekDay类。以后用此类型定义的值只能是这个类中规定好的那些值，若不是这些值，编译器不会通过。
3.如果调用者想打印枚举类中元素的信息，需由编写此类的人定义toString方法。
4.采用抽象方法定义的nextDay可将大量的if else语句转换成了一个个独立的类。
5.如果想在一个类中编写完每个枚举类和测试调用类，那么可将枚举类定义成调用类的内部类。

实例：

public abstract class WeekDayTest {    
    public WeekDayTest(){}    
    public final static WeekDayTest SUN = new WeekDayTest(){    
        public WeekDayTest nextDay(){    
            return MON;    
    	}  
    };    
    public final static WeekDayTest MON = new WeekDayTest(){    
        public WeekDayTest nextDay() {    
            return SUN;    
    	}  
    };    
    public abstract WeekDayTest nextDay();    
    public String toString(){    
        return this==SUN ? "SUN" : "MON";    
    }  
}  

好处：在编译时期就会发现错误，表明值不符合，减少了运行时期的错误。

 

枚举类
是一个class，而且是一个不可被继承的final类，其中的元素都是类静态常量。

 

枚举的特征及用法示例：

public class EnumText {    
    public static void main(String[] args) {    
        WeekDayTest weekDay = WeekDayTest.MON;      
        System.out.println(weekDay.nextDay());      
            
        WeekDay weekDay2 = WeekDay.FRI;    
        System.out.println("获取此对象：" + weekDay2);    
        System.out.println("获取对象名称：" + weekDay2.name());    
        System.out.println("获取排行：" + weekDay2.ordinal());    
        System.out.println("获取类名：" + weekDay2.getClass());    
        //静态方法：    
        System.out.println("通过字符串获取对象："+WeekDay.valueOf("SUN"));    
        System.out.println("将元素存入数组："+WeekDay.values().length);    
            
    }    
    //定义星期枚举类    
    public enum WeekDay{    
        SUN(1),MON,TUE,WED,THI,FRI,SAT;    
        private WeekDay(){    
            System.out.println("first");    
        }    
        private WeekDay(int x){    
            System.out.println("second");    
        }    
    }    
    //定义交通灯    
    public enum TrafficLamp{    
        //定义3个元素，即此类的子类，覆写抽象方法    
        RED(30){    
            public TrafficLamp nextLamp() {    
                return GREEN;    
        }  
    },    
        GREEN(45){    
            public TrafficLamp nextLamp() {    
                return YELLOW;    
        }  
    },    
        YELLOW(5) {    
            public TrafficLamp nextLamp() {    
                return RED;    
        }  
    };    
        private int time;    
        //构造方法    
        private TrafficLamp(int time){this.time = time;}    
        //抽象方法，转为下个灯    
        public abstract TrafficLamp nextLamp();    
    }    
}    

构造器：
1.构造器只是在构造枚举值的时候被调用。
2.构造器只有私有private，绝不允许有public构造器。这样可以保证外部代码无法重新构造枚举类的实例，这样是合情合理的，因为枚举值是public static final的常量，但是枚举类的方法和数据域是可以被外部访问的。
3.构造器可以有多个，调用哪个即初始化相应的值。

所有的枚举类都继承了Enum方法，方法如下：
1.toString() ---> 返回枚举量的名称
2.ordina() ---> 返回枚举值在枚举类中的顺序，按定义的顺序排
3.getClass() ---> 获取对应的类名

 

静态方法：
1.valueOf(String e) ---> 转为类中对应的对象，即将字符串转为对象
2.values() ---> 获取数组，将元素放入一个数组中。

注意：
1.元素列表即所有的元素项目，必须放在整个类的最前面。
2.元素列表后要有分号
3.枚举类中的方法为private
4.在元素后跟上()，就可指定要使用的构造方法，含参数。
5:枚举类中的每个元素都是它的一个子类对象，当枚举类中存在abstract方法，须在子类后加{}，并在其中实现此方法。

 

总结：
1.匿名内部类比较常用
2.类的方法返回的类型可以是类的类型
3.类中可定义静态常量，常量的结果就是自己这个类型的实例对象
4.如果枚举只有一个成员，就可以作为一种单利的实现方式，对象只有一个。