[黑马程序员](第16天)eclipse及知识点补充

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

一、Eclipse工具介

 

 1、Eclipse：Eclipse 是一个开放源代码的、基于Java的可扩展开发平台。MyEclipse基于Eclipse的基础上添加

 

      了一些插件，方便开发，提高开发效率。

 

 2、名词：

   （1）JavaEE：javaEnterprise Edition：java企业版开发工具。

    (2)IDE：ItegrityDevelopment Enviroment，集成开发环境

    (3)JMS：Java MessageService，Java消息服务，是一个Java平台中关于面向消息中间件的API，用于在两个应用程序间，或分布式系统中，发送消息，进行异步通信。

  (4)JMX：Java ManagementExtensions，Java管理扩展；是一个为应用程序、设备、系统植入管理功能的框架。

     (5)JNDI：Java Nameingand Directory Interface：Java命名和目录接口。

     (6)JDBC：Java DataBase Connectivity：Java数据库连接。

 

 3、Eclipse使用技巧 

     1、workspace（工作间）            

         一个workspace可以包含多个project，一个workspace保留了eclipse的一套环境选项的配置，

         例如，所使用的javac和java命令，等等，细节请查看window->preferences。

         如果要为eclispe再配置一套环境选项，可以再创建一个workspace。Package explorer视图窗口中的

         filters菜单项，可以显示空的父包（此功能默认是关闭的）。

     2、project（工程）：

        （1）一个工程包含有：包，jar包，资源文件，java源文件等内容。

        （2）将一个工程的所有源文件用一个工程来组织，开发工具能对所有源文件集中管理，记住每个源文件

            的位置和相互关系，配置信息等都在工程中有记录。

     3、preferences（首选项）：

         在workspace（工作间）中配置，将会影响到它下面所有的工程，一个工作间包含多个工程，

         不同透视图就是几个小窗口的集合。

     4、在eclipse下如何查看变量值：

         在变量处打个断点--->Debug透视图，调试运行--->选中变量，右键选watch（观察），就可以看到了。

     5、perspective（透视图）和view（视图）的关系：

        view：每一个小窗口就是一个视图。可通过window下的show view调出相应的视图。

        perspective：透视图就是若干个小窗口的集合。

     6、导入已有工程：

        1）将其他工作间中的工程拷贝到当前工作间所在的文件夹下。

        2）在eclipse中右击工程--->导入--->浏览选择当前工作间目录下拷贝过来的工程。

     7、配置JDK环境：

        右击工程--->BuildPath --->Libraries（库）--->移除导入的工程的JDK库，增加自己的库。

     8、快捷键使用技巧：快捷键的位置：General->keys，设置alt+/键（丁：content a 就会搜索出）进行内容

        提示时，要注意解除alt+/键原来的绑定关系，直接输入alt+/就可以找到它的绑定关系，删除绑定关系时

        也可以使用remove binding这个按钮。

     9、导入JAR包

            Add JARs是增加多个Jar包，

           如果Jar包不在当前工程文件夹中，用Add Exernd JARs

           如果Jar包在当前工程文件夹中，用Add JARs

           增加一个库相当于增加很多Jar，这是一个打包的过程。

     注：eclipse工作台中的所有工程继承工作台的配置，其中某个工程也可以覆盖工作台的配置！这和java面向对象

 

         的思想相似。

二、JAVA基础知识拓展

  1、静态导入（JDK1.5新特性）

         导入（import）和静态导入（import static）的区别       

                 import语句可以导入一个类或某个包中的所有类 

                 import static语句导入一个类中的某个静态方法或所有静态方法

  例：  

import static java.lang.Math.sin;  //导入Math类中的sin方法

import static java.lang.Math.*;  //导入Math类中的所有静态成员和静态方法

  2、可变参数（JDK1.5新特性）

       （1）需求：一个方法接受的参数个数不固定，如求和方法：

          add（2,3）;

         add(2,3,4);

这时可以将参数定义成可变的：add(int x, int... args);    具体代码：

[java]  view plain copy

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

    （2）可变参数的特点：

          只能出现在参数列表的最后；

          ...位于变量类型和变量名之间，前后有无空格都可以; 

          调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

     （3）overload：重载

          override：重写

  3、增强for（JDK1.5新特性）

     （1）格式：for ( type 变量名：集合变量名 )  { … } 

     （2）使用注意：迭代变量必须在( )中定义！

                    集合变量可以是数组或实现了Iterable接口的集合类

  4、基本数据类型的自动拆箱与装箱（JDK1.5新特性）

    （1）自动装箱：Integer num1 = 12; 

    （2）自动拆箱：System.out.println(num1 + 12); 

     注意：Integer num1 = 12; 

          Integer num2 = 12;       

          System.out.println(num1 == num2); //结果为true

 当自动装箱的数据在byte数据类型的范围内时，认为这种小范围数据使用概率高，所以将对象存储在一个数据池中，下次要用到的时候直接在数据池中取，不需要重新创建对象。这种设计方式称为享元设计模式。

    （3）valueOf(int x)：Integer中静态方法，讲一个整数转换为Integer，即把基本数据类型变为包装类。

    （4）享元模式（flyweight）：

1）概述：如果很多很小的对象，他们有很多相同的属性，那么就可变为一个对象使用，这些属性称为内部状态，还有些不同的属性，作为方法参数植入，这些称为外部状态。这种优化内存，只创建一个对象的模式，称之为享元模式。

       2）应用：

（a）word中输入英文字母，可创建26对象，每个对象值是出现的位置不同（坐标），所以可用一个对象调用位置的方法：如，字母i：i.display(intx,int y)，将高度重复使用的char类型的字母i封装成一个对象使用。

（b）图标：window下的文件夹图标，只哟名称这个属性不同，包含了很多其他相同的属性，那么可以应用享元模式。

 

三、枚举（JDK1.5新特性）

 

   1、  为什么要有枚举

枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

 下面用普通类定义一个Weekday的类来模拟枚举功能。

[java]  view plain copy

1. public abstract class WeekDay1 {  
2.     private WeekDay1(){};  
3.       
4.     public static final WeekDay1 SUN = new WeekDay1(){  
5.  public WeekDay1 nextDay(){  
6.      return MON;  
7.  }  
8.     };  
9.     public static final WeekDay1 MON = new WeekDay1(){  
10.  public WeekDay1 nextDay(){  
11.      return TUE;  
12.  }  
13.     };  
14.     public static final WeekDay1 TUE = new WeekDay1(){  
15.  public WeekDay1 nextDay(){  
16.      return WED;  
17.  }  
18.     };  
19.     public static final WeekDay1 WED = new WeekDay1(){  
20.  public WeekDay1 nextDay(){  
21.      return THU;  
22.  }  
23.     };  
24.     public static final WeekDay1 THU = new WeekDay1(){  
25.  public WeekDay1 nextDay(){  
26.      return FRI;  
27.  }  
28.     };  
29.     public static final WeekDay1 FRI = new WeekDay1(){  
30.  public WeekDay1 nextDay(){  
31.      return SAT;  
32.  }  
33.     };  
34.     public static final WeekDay1 SAT = new WeekDay1(){  
35.  public WeekDay1 nextDay(){  
36.      return SUN;  
37.  }  
38.     };  
39.       
40.    
41.     /*  可以有若干公有方法或抽象方法。采用抽象方法定义nextDay,并通过匿名内部类的方式， 
42. 就将大量的if.else语句转移成了一个个独立的类。*/  
43.     /*public WeekDay nextDay(){ 
44.  if(this==SUN) 
45.      return "MON"; 
46.  else if(this==MON) 
47.      return "TUE"; 
48.  else if(this==TUE) 
49.      return "WEN"; 
50.  else if(this==WED) 
51.      return "THU"; 
52.  else if(this==THU) 
53.      return "FRI"; 
54.  else if(this==FRI) 
55.      return "SAT"; 
56.  else 
57.      return "SUN"; 
58.     }*/  
59.     public abstract WeekDay1 nextDay();  
60.       
61.     public String toString(){  
62.  if(this==SUN)  
63.      return "Sunday";  
64.  else if(this==MON)  
65.      return "Monday";  
66.  else if(this==TUE)  
67.      return "Tuesday";  
68.  else if(this==WED)  
69.      return "Wednesday";  
70.  else if(this==THU)  
71.      return "Thursday";  
72.  else if(this==FRI)  
73.      return "Friday";  
74.  else  
75.      return "Saturday";  
76.     }  
77. }   

  2、枚举类的特征

（1）通过enum定义枚举类，在其中列出所有同类的元素常量值作为子类的实例对象使用。枚举类是一个特殊的类， 

     每个元素都是该类的一个实例对象。

（2）用枚举类规定值，如上面的WeekDay类。以后用此类型定义的值只能是这个类中规定好的那些值， 

     若不是这些值，编译器不会通过。

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

（4）构造方法只有私有private，绝不允许有public构造方法。这样可以保证外部代码无法创建枚举类的实例, 

 这样是合情合理的，因为枚举值是public static final的常量，但是枚举类的方法和数据域是 

    可以

被外部访问的。 

 构造方法可以有多个，调用哪个即初始化相应的值。

（5）所有的枚举类都继承了Enum方法，方法如下：

1）toString() ---> 返回枚举量的名称

2）ordina() ---> 返回枚举值在枚举类中的顺序，按定义的顺序排

3）getClass() ---> 获取对应的类名

静态方法：

1）valueOf(String e) ---> 转为类中对应的对象，即将字符串转为对象

2）values() ---> 获取数组，将元素放入一个数组中

   以下是一个带抽象方法和构造函数的枚举类

[java]  view plain copy

1. /*带抽象方法和构造函数的枚举， */  
2.     public enum TrafficLamp{  
3.    /*由子类创建的实例*/  
4.  RED(50){  
5.      public TrafficLamp nextLamp(){  
6.   return GREEN;  
7.      }  
8.  },  
9.  GREEN(35){  
10.      public TrafficLamp nextLamp(){  
11.   return YELLOW;  
12.      }  
13.  },  
14.  YELLOW(5){  
15.     public TrafficLamp nextLamp(){  
16.         return RED;  
17.     }  
18.  };  
19.  public abstract TrafficLamp nextLamp();  
20.  private int time;  
21.  TrafficLamp(int time){}  
22.     }   
23.    

  3、使用枚举类要注意： 

（1）元素列表即所有的元素项目，必须放在整个类的最前面。 

（2）元素列表后要有分号 

（3）枚举类中的方法为private 

（4）在元素后跟上()，就可指定要使用的构造方法，含参数。 

（5）枚举类中的每个元素都是它的一个子类对象，当枚举类中存在abstract方法， 

    须在子类后加{}，并在其中实现此方法。

总结：  

1、枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。

2、枚举构造方法必须定义成私有的 

3、枚举类中的成员方法定义成抽象方法，每个实例通过内部类的形式去复写，实现其具体功能。

4、枚举只有一个成员时，就可以作为一种单例的实现方式。