JDK5新特性

工具的使用：

Eclipse与MyEclipse的关系

MyEclipse是Eclipse的插件，是使Eclipse能够开发web项目的插件。MyEclipse集成了Eclipse和开发web的插件的功能。两者都是java语言开发出来的。都是IDE开发工具。

简写：

JavaEE：java Enterprize Environment   java企业级开发环境

IDE：intergrated developmentenvironment集成开发环境一般都是用工程化方式管理项目程序的开发过程。

JMS: Java Message Service java消息服务。

JMX: Java Management Extensions  Java管理扩展

JNDI: Java Naming and Directory Interface Java命名和目录接口

MyEclipse的使用：

1、  设置编译器的java版本  Windows->Reference->Java->Compiler选择存在的JDK

2、  设置运行时的java版本  Windows->Reference->Java->InstalledJREs选择存在的JRE

高版本的JDk兼容低版本的JDK，也就是说低版本的jdk编译过的class能够被高版本的Jdk执行，反之怎不能。

3、  工作空间：workspace。选择一个文件夹存放程序代码，目录不能用中文和空格。

切换工作间：File->Switch WorkSpace然后选择工作间。

Perspective：透视图，一组方便开发的视图的集合。View：视图。

4、  快捷键的配置（在整个workSpace内有效）：

Alt+/：自动补齐代码。Windows->Reference->General->keys->content assist接触其绑定然后重新绑定。

模板代码：Windows->Reference->Java->Editor->Templates设定模板代码。

5、  导入工程：首先将工程复制到你想导入的工作台的目录下，然后再导入。

6、  增加jar包，File->BuildPath->add jars选择你要导入的Jar包。增加library导入库。

7、  断点调试

         1)可以对程序进行调试

         在行的开头双击左键打断点，用debug方式来运行程序，程序就会停留在断点位置

         F5跳入(step into)跳入方法内部  F6跳过，让当前行运行  F7跳出返回上一层程序

         resume直接运行到下一个断点

         2)查看源代码建议使用断点调试的方式，注意当前运行环境需要包含源码

 

JDK5新特性：

1、  静态导入

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

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

1) 导入类的静态属性

import static java.lang.System.out;

out.println("haha");

2) 导入类的静态方法

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

int num= abs(-10);

2、  可变参数

方法的参数的个数是不固定的，就是可变参数。

System.out.println(countScore(2,3,5));
System.out.println(countScore(1,2,3,5)); 

可变参数的特点：

（1）只能出现在参数列表的最后；这个要记住

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

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

 Overload和override的区别。

方法的重写(Overriding)和重载(Overloading)是Java多态性的不同表现。重写(Overriding)是父类与子类之间多态性的一种表现，而重载(Overloading)是一个类中多态性的一种表现

Override(重写)：通常存在于子类和父类的继承关系之中，子类通过继承父类的方法并且对其进行重新以实现更丰富的功能。

重写的几个特点：（1）子类方法的方法名、参数、返回值必须与父类的相同。（2）子类方法不能缩小父类方法的访问权限。（3）子类方法不能抛出比父类更多的异常（子类方法也可以不抛出异常），即不能抛出新的异常，或者所抛出的异常为要么与父类方法一致，要么为父类所抛出异常的子类。（4）父类中被定义为final的方法不能被重写。（5）被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

Overload（重载）：通常存在于同一个类中，多个方法具有相同的名字，但具有不同的参数。

重载的几个特点：

1、  在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序都可以

2、  不能通过访问权限、返回值类型和抛出的异常的不同进行重载。

          3、方法的异常类型和数目不会对重载造成影响；

4、对于继承来说，重载可以存在于父类和子类中、同类中如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

 3、 增强for循环

语法：for ( type 变量名：集合变量名 )  { … }

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

 

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

String [] arr = {"a", "b","c"};   //数组的静态定义方式，只试用于数组首次定义的时候

// 传统方式

for(int i=0; i<arr.length; i++) {

    // i依次表示数组的角标

    String s =arr[i];

    System.out.println(s);

}

System.out.println("-------------------------------------");

// 在jdk5中我们可以使用增强for循环迭代

// 增强for循环括号里写两个参数，第一个是声明一个变量，变量类型必须是数组元素的类型

// 第二个就是需要迭代的容器

// for循环会循环容器的length次, 每次都将容器的第n-1个元素赋值给声明的变量

for(String s : arr) {

    // 循环体， 执行arr.length

    // 每次都将arr中的第n-1个元素给s

    System.out.println(s);   //

}

 

 

 

4、  自动装箱与拆箱

基本数据对象的包装类

int --> Integer      byte --> Byte       short --> Short    long --> Long  

char --> Character  double --> Double    float --> Float    boolean --> Boolean

 

Integer  i = 3;自动装箱Integer j= 5+i;先自动拆箱然后自动装箱。

为了优化，虚拟机为包装类提供了缓冲池，Integer池的大小为一个字节，即-128-127.

Java为了优化字符串操作 提供了一个缓冲池

String s = “abc” 和 String s = new String(“abc”) 的区别

String s = new String(“abc”) 创建了几个对象 

String s = “a” + “b” + “c” + “d” 创建了几个对象

String s1 = “a” String s2 = “b”  String s3 = s1 + s2;  s3==”ab”?

 

/*1. String s = "abc"， 虚拟机首先会检查String池里有没有"abc"对象(通过equals方法)

       // 如果有，直接返回引用，如果没有，会在池里创建一个“abc”对象，并返回引用

       Strings1 = "abc";

       Strings2 = "abc";

       System.out.println(s1==s2); // result: true

       */

       

       /* 2.String str = new String("abc");

不管缓冲池是否有"abc", 都会在堆内存创建一个"abc"对象，返回引用

       // 此时，负责检查并维护缓冲池，其实堆内存的对象是缓冲池中"abc"对象的一个拷贝

       Strings1 = new String("abc");

       Strings2 = new String("abc");

       System.out.println(s1==s2);// result: false

       */

       

       /* 3.String s = "a" + "b" + "c" + "d";  java编译器有个合并已知量的优化功能

        // 在编译阶段就把"a" + "b" +"c" + "d" 合并为 ”abcd“

       String s= "a" + "b" + "c" + "d"; 

    //  String s = "abcd"; 

       System.out.println(s=="abcd");//result: true

       */

       

       /*4.  String s1 = "a"; String s2= "b"; String s3 = s1 + s2;

       //String是常量，不能相加的，java如何实现的？

        StringBuilder sb = new StringBuidler(s1);

        sb.append(s2);

        s3 = sb.toString();

        

        也就是说实际上s3是方法返回的String对象

        凡是方法返回的字符串对象都是在堆内存的

       */

        String s1 = "a";

        String s2 = "b"; 

        String s3 = s1 + s2; // 堆内存的对象

        System.out.println(s3=="ab");// result:false

5、  枚举

作用：对象的值必须是固定的几个值中的其中一个，否则编译不通过。

实现枚举类的原理步骤：（1）私有化构造函数。（2）将类的成员变量设置为final static ,并且类型为本类类型。这样该类的对象的取值就只能为其内部规定的几个值。

publicabstractclass WeekDay {

   //WeekDay模拟枚举类的实现

   private WeekDay(){};

   publicfinalstatic WeekDaySUN = new WeekDay(){

 

      @Override

      public WeekDay nextDay() {

         //TODO Auto-generated method stub

         returnMON;

      }};

      

      //定义为抽象方法并将该类给位一个抽象类，

      //并在类的内部通过建立该类的匿名子类的方式建立该类的对象

      //这样可以简化代码

   publicabstract WeekDay nextDay();

   publicfinalstatic WeekDayMON = new WeekDay(){

      @Override

      public WeekDay nextDay() {

         //TODO Auto-generated method stub

         returnSUN;

      }

   };

   public String toString(){

      returnthis==SUN?"SUN":"MON";

   }

}

Jdk5定义了新的类型，专门用于解决此类问题。

枚举就是一个特殊的java类，可以定义属性、方法、构造函数、实现接口、继承类。

枚举元素必须位于枚举体中的最开始部分，枚举元素列表的后要有分号与其他成员分隔。把枚举中的成员方法或变量等放在枚举元素的前面，编译器报告错误。

带构造方法的枚举

构造方法必须定义成私有的

如果有多个构造方法，可以通过元素后面加（参数）来指定构造还元素所要用的构造方法

枚举元素MON和MON（）的效果一样，都是调用默认的构造方法。

带方法的枚举

定义枚举TrafficLamp

实现普通的next方法

实现抽象的next方法：每个元素分别是由枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义。增加上表示时间的构造方法

 

public enum TrafficLamp {

   

   GREEN(45) {

      @Override

      public TrafficLamp nextLamp() {

         returnYELLOW;

      }

   },YELLOW (10){

      @Override

      public TrafficLamp nextLamp() {

         returnRED;

      }

   },RED(30) {

      @Override

      public TrafficLamp nextLamp() {

         returnGREEN;

      }

   };

   privateinttime;

   private TrafficLamp(int time){

      this.time = time;

   }

   publicabstract TrafficLamp nextLamp();

}

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