黑马程序员--JAVA高新技术之eclipse开发工具相关知识、JDK1.5新特性

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

一、eclipse开发工具简介

1,概述

eclipse是开发JAVA程序很好的一个IDE

2,名词解析

1）IDE：ItegrityDevelopment Enviroment，集成开发环境

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

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数据库连接。

3Myeclipse和eclipse的区别:

1）Myeclipse：是elipse的插件，用于开发javaEE的平台，为其打补丁，扩展其功能，可以开发JavaEE程序即web项目，但是现在Myeclipse也集成了eclipse的功能，可直接使用Myeclipse。

2）eclipse：是开发java的一款专业的IDE（集成开发环境），以前需要Myeclipse才能开发JavaEE程序，现在的eclipse的版本也可以不用再安装Myeclipse插件，直接可以开发JavaEE项目。

二、eclipse开发工具介绍

1、project（工程）：

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

2）将一个工程的所有源文件用一个工程来组织，开发工具能对所有源文件集中管理，记住每个源文件的位置和相互关系，配置信息等都在工程中有记录。

2、preferences（首选项）：

在workspace（工作间）中配置，将会影响到它下面所有的工程，一个工作间包含多个工程，不同透视图就是几个小窗口的集合。

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

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

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

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

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

5、导入已有工程：

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

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

6、配置JDK环境：

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

注：

Add JARs是增加打个Jar包，

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

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

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

三、JDK1.5新特性

总的来说1.5新特性可以总结为：4（for）静可拆枚泛注

1，静态倒入importstatic

a)静态导入类的静态属性

import static java.lang.System.out;
out.println("haha");

b)导入类的静态方法

import static java.lang.Math.*; // 导入Math类的所有静态成员
int num = abs(-10);

2,可变参数

特点：

1、只能出现在参数列表的最后。

2、用…这三个点表示参数可以有很多，且这三个点位于变量类型和变量名之间，前后有无空格皆可。

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

public class VarableParameter {
public static void main(String [] args){
System.out.println(add(2, 3));
System.out.println(add(2, 3, 5));
}
public static int add(int x,int... args){
int sum = x;
/*for(int i=0;i<args.length;i++){
sum += args[i];
}*/

for(int arg : args){
sum += arg;
}
return sum;
}
}

3,增强for循环

a),语法格式:

for(type变量名 ： 集合变量名)
{
Statements;.
}

b)注意事项:

i. 迭代变量必须在( )中定义；

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

范例:

public static int add(int x, int... args)
{
int sum = x;
//使用传统for循环遍历
for (int i = 0; i < args.length; i++)
{
sum += args[i];
}
//使用增强for循环
for (int arg : args)
{
sum += arg;
}
return sum;
}

4,基本数据类型的自动拆箱和装箱

在Java中，所有的事物都会被看作对象，包括一个数字，基本的Java类型与对应的类之间的关系如下所示：



除此之外关键字void也表示为Class对象。

装箱：自动把一个基本数据类型的数据装箱成一个该类型数据的对象引用；

拆箱：自动把一个基本数据类型的对象引用拆箱成一个基本数据类型的数据，再参与运算。

5,枚举

a)概述:

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

b)枚举特点

1）枚举类可以实现一个或多个接口，使用enum定义的枚举类默认继承了java.lang.Enum类，而不是继承Object类。其中java.lang.Enum类实现了Serializable和Comparable接口，格式如下所示：

public abstract class Enum<E extends Enum<E>>
extends Object
implements Comparable<E>, Serializable

（2）使用enum定义、非抽象的枚举类默认会使用final修饰，因此枚举类不能派生出子类；

（3）枚举类的构造器只能使用private访问控制符，如果省略了构造器的访问控制符，则默认使用的是private修饰。

（4）枚举类的所有实例必须在枚举类的第一行显式列出，否则这个枚举类永远都不能产生实例。列举这些实例时，系统会自动添加public static final修饰，无须显式添加。

c)枚举细节

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

2、用枚举类规定值，如上面的WeekDay类。以后用此类型定义的值只能是这个类中规定好的那些值，若不是这些值，编译器不会通过。

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

4、如果调用者想打印枚举类中元素的信息，需由编写此类的人定义toString方法。

5、采用抽象方法定义的nextDay可将大量的if else语句转换成了一个个独立的类。

6、如果想在一个类中编写完每个枚举类和测试调用类，那么可将枚举类定义成调用类的内部类。

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

d)枚举基本应用

使用基本类实现枚举类，需要实现以下三步:

（1）通过private将构造器隐藏起来；

（2）把这个类所有可能实例都使用public static final修饰的类变量来保存；

（3）如果有必要，可以提供一些静态方法，允许其它程序根据特定参数获取与值匹配的实例。

示例代码：定义季节类，这个类只能产生4个对象，将该Season类定义成枚举类；代码如下所示：

public class Season
{
//把Season类定义成不可变的，将其属性也定义成final
private final String name;
private final String desc;
//将构造器定义成private访问权限
private Season(String name, String desc)
{
this.name = name;
this.desc = desc;
}
public static final Season SPRING = new Season("春天","趁春踏青");
public static final Season SUMMER = new Season("夏天","夏日炎炎");
public static final Season FALL = new Season("秋天","秋高气爽");
public static final Season WINTER = new Season("冬天","围炉赏雪");
public String getName()
{
return name;
}
public String getDesc()
{
return desc;
}
}

public class SeasonTest
{
public SeasonTest(Season s)
{
System.out.println(s.getName() + ",这真是一个" + s.getDesc() + "的季节");
}
public static void main(String[] args)
{
new SeasonTest(Season.FALL);
}
}

所有的枚举类都提供了values方法，通过该方法可以遍历获得所有的枚举值；使用枚举实现季节代码如下所示:

public class EnumTest
{
public static void main(String[] args)
{
//所有的枚举类都有一个values方法，返回该枚举类的所有实例
for(SeasonEnum s : SeasonEnum.values())
{
System.out.println(s);
}
new EnumTest().judge(SeasonEnum.SPRING);
}
private void judge(SeasonEnum s)
{
//switch语句中的表达式可以是枚举值
switch (s)
{
case SPRING:
System.out.println("面朝大海，春暖花开");
break;
case SUMMER:
System.out.println("夏日炎炎，适合游泳");
break;
case FALL:
System.out.println("秋高气爽，进补及时");
break;
case WINTER:
System.out.println("冬雪飘飘，适合赏雪");
break;
}
}
}

e)枚举的高级应用:

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

示例代码：当为枚举类显式定义了带参数的构造器是，列出枚举值时必须对应的传入参数，关于性别的枚举类如下所示：

public enum Gender implements GenderDesc
{
MALE("男"), FEMALE("女");
// 定义一个public修饰的实例变量
public String name;
private Gender(String name)
{
this.name = name;
}
public String getName()
{
return this.name;
}
}

相等于

public static final Gender MALE = new Gender("男");
public static final Gender FEMALE = new Gender("女");

范例

public enum Operation
{
PLUS
{
@Override
public double eval(double x, double y)
{
return x + y;
}
},
MINUS
{
@Override
public double eval(double x, double y)
{
return x - y;
}
},
TIMES
{
@Override
public double eval(double x, double y)
{
return x * y;
}
},
DIVIDE
{
@Override
public double eval(double x, double y)
{
return x / y;
}
};
//为枚举类定义一个抽象方法，这个抽象方法由不同的枚举值提供不同的实现
public abstract double eval(double x, double y);
public static void main(String[] args)
{
System.out.println(Operation2.PLUS.eval(34, 34));
System.out.println(Operation2.MINUS.eval(34, 34));
System.out.println(Operation2.TIMES.eval(34, 34));
System.out.println(Operation2.DIVIDE.eval(34, 34));
}
}

范例交通灯:

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、类的方法返回的类型可以是类的类型

3、类中可定义静态常量，常量的结果就是自己这个类型的实例对象

4、如果枚举只有一个成员，就可以作为一种单利的实现方式，对象只有一个。

模式之一:享元模式

代码示例:

Integer num1 = 12;
Integer num2 = 12;
System.out.println(num1 == num2);//打印true

Integer num5 = Integer.valueOf(12);
Integer num6 = Integer.valueOf(12);
System.out.println(num5 == num6);//打印true

Integer num3 = 129;
Integer num4 = 129;
System.out.println(num3 == num4);//打印false

为什么前面的返回true，而后面的运算是返回false呢？

对于基本数据类型的整数，装箱成Integer对象时，如果该数值在一个字节内（-128~127），一旦装箱成Integer对象后，就把它缓存在磁里面，当下次，又把该数值封装成Integer对象的时候，先会看看磁里面有没有该对象，有就直接拿出来使用，这样就节省了内存空间。因为比较小的整数，使用的频率比较高，就没有必要对每个对象都分配一个内存空间；这就是享元模式！比如还有26个英文字母。

定义:

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

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------
详情请查看：http://edu.csdn.net/heima