黑马程序员_JDK1.5的新特性和MyEclipse的使用

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

一、    MyEclipse的使用技巧

1. 你用的编译器的版本不能高于运行器。否则的话会出现Bad version number in class file 这样的错误。

2. 改变工程的运行环境：工程àpropertiesàJava Build path

3. 导入工程：

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

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

4.  在eclipse下查看变量值：

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

5. MyEclipse的一些快捷键

Alt+/:内容提示

Ctrl+Shift+L:查看所有快捷键

Ctrl+ Shift+O:导包

Ctrl+ Shift+F：格式化代码块

Ctrl+ Shift+/:添加注释

Ctrl+ Shift+\:除去注释

Ctrl+ T:查看类的继承关系；

6. 享元设计模式：

1) 概述：实际上就是有好多小的对象，他们有很多相同的属性，然后就把他变成一个对象使用，还有些不同的属性，作为方法参数传递，这种只创建对象的模式，就叫享元模式。

2) 例子：比如说-128~127，在一个字节内，一旦装箱后就会把它缓存起来，下次就可以直接从缓存中拿，这样就节省了空间，因为这些整数比较小，并且使用的频率比较高，这就是一种享元模式。

例如：Integer a=23；

     Integer b=23；

     a==b  true

     Integer a=137；

     Integer b=137；

     a==b  false；

二、    JDK1.5的新特性

1. 增强for循环

语法：for(type 变量名 : 集合变量名){代码}

        注意：用增强for循环时，必须实现Iterable接口或

2.  可变参数

注意：只能出现在参数列表的最后，实际上可变参数里面封装了一个数组

3. 自动装箱拆箱

自动装箱：例如：Integer a=5；这就是自动装箱，把5装成了一个Integer对象

自动拆箱：例如：a+4;这就是把a自动拆成了整数进行运算

注意：对于整数在-128~127之间的数，包装成Integer类型的对象，会存入常量池中的缓存，在创建同一个对象的时候，会直接使用前一个已有的值，因为这些整数使用的频率很高，这样可以优化内存。

4. 枚举 enum

1) 枚举中的每个元素都是该类的一个实例对象。

2) 最大的作用是保证了对象的唯一性。它只能用规定好了的值，其他值不能用。

例如下面代码模拟了一个枚举类：

public abstract class WeekDay1 {
    private WeekDay1(){}
    public static final WeekDay1 SUN =new WeekDay1(){
        @Override
        public WeekDay1nextDay() {
            // TODO Auto-generated method stub
            return MON;
        }  
    };
    public static final WeekDay1 MON =new WeekDay1(){
        @Override
        public WeekDay1 nextDay(){
            // TODO Auto-generated method stub
            return SUN;
        }
    };
    public abstract WeekDay1 nextDay();
        public StringtoString()
        {
            return this==SUN?"SUM":"MON";
        }
}

  总结：这段代码最大的特点是，把构造函数进行了私有化，所以外界你不能new对象了，然后我自己在里面new对象，所以你只能用我已经new好了的对象。

枚举类中的一些常用方法：

   ordinary()返回枚举值在枚举中的顺序

   getClass()获取对应的类名

   下面例子是说明了枚举类的构造方法等的一些运用  

public class EnumDemo1 {
    public static void main(String[] args)
    {
         WeekDay1 weekday=WeekDay1.SUN;
         System.out.println(weekday.nextDay());
         System.out.println(trafficLamp.RED.nextLamp());
    }
    public enum WeekDay
    {
        SUN,MON,TUE,WED,THI,FRI,STA;//调用无参的构造方法
        privateWeekDay(){System.out.println("first");}
        private WeekDay(int x){System.out.println("second");}
    }
   
    public enum trafficLamp
    {
        RED(30){
        public  trafficLamp nextLamp(){
            return GREEN;
        }
        },
        GREEN(45){//调用有参的构造方法
            public  trafficLamp nextLamp()
        {
            return YELLOW;
        }  
        },
        YELLOW(10){
            public  trafficLamp nextLamp()
        {
            return RED;
        }};
        public abstract trafficLamp nextLamp();
        private int time;
        privatetrafficLamp(int time)
        {
            this.time=time;
        }
    }
}

5.静态导入：

实际上就是导入类中的方法：例如：import static  java.lang.String.*;

6.泛型：

    可以限定集合中的输入类型，让编译器挡住源程序的非法输入。

注意：定义的泛型当编译器编译完后就把泛型去掉了

      例如：ArrayList <String> al1=new ArrayList<String>();

           ArrayList <String> al2=new ArrayList<String>();

           al1.getClass()==al2.getClass();//true

可以用反射技术来越过泛型的约束如下代码：

       Al2.getClass().getMethod(“add”,Object.class).invoke(al2,”sdfedf”);

参数化类型和原始类型的兼容性：

参数化类型可以引用一个原始类型的对象，例如：Collection<String>c=newVector();

原始类型可以引用一个参数化类型的对象. 例如：Collectionc=newVector<String>();

参数化类型不考虑类型的继承关系：

Vector<String> v=newVector<Object>r();//错误

Vector<Object> v=newVector<String>r();//错误

编译去不允许创建泛型变量的数组：

例如：Vector <Interger>arr[]=newVector<Integer>[10];//错误

通配符：？表示任意类型。

       不能调用与参数有关的方法。

        例如：public static voidprintCollection(Collection<?> collection)

{

      collection.add();//不能使用这个方法，因为不知道添加什么类型的

      collection.size();//可以。

                     }

              限定通配符的上边界：

              <? extends Number>//表示只要出入Number或Number的子类都可以

              限定通配符的下边界：

              <? super Number>//表示只要出入Number或Number的父类都可以

      自定义泛型：private static <T> int add(T x,T y)

{

                             return null;

}

      定义泛型的类型：在类身上定义泛型,主要的目的是方法的类型是一样的。

                      例如：public class GenericDao<T>{

                               public void add(Tx){

}

                               public T findById(int id){

  return null;

}

}

        注意：当一个变量被声明为泛型时，只能被实例变量和方法调用，不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享，所以静态成员不应该有类级别的类型参数。

   通过反射获得泛型的类型

           例如：Vector<Date>v1=new Vector<Date>();

              MethodapplyMethod=GenericTest.class.getMethod(“applyVector”,Vector.class)

              Type[] type= applyMethod.getGenericParameterTypes();

                ParameteredType pType=(ParameteredType)type;

                pType.getActualTypeArgments()[0].getName();

                 Public static voidapplyVector(Vector<Date> v1)

 {

}

有关泛型的一些练习题

1. 编写一个泛型方法，自动将Object类型的对象转换成其他类型

Public static <T>T autoChage(Objectobj)

{

  return (T)obj

}

2. 采用自定义泛型的方法的方式打印出任意参数化类型的集合中的所有内容。

public static <E>voidprint(Collection<E> c)

{

      For(E obj : c)

{

   System.out.println(obj);

}

 

}

3. 定义一个方法，把任意类型的集合中的数据添加到任意参数类型的数组中。

privatestatic <T> void fillArray(T[] a,T obj){

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

            a[i] = obj;

        }

    }

4.   定义一个方法，把任意类型的数组中的数据添加到任意参数类型的集合中。

privatestatic <T> void fillArray(T[] a,T obj){

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

            obj.add(a[i]);

        }

    }

5.类型参数的类型推断：

编译器判断范型方法的实际类型参数的过程称为类型推断，类型推断是相对于知觉推断的，其实现方法是一种非常复杂的过程。

根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下:

1.当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型

2.当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型来确定，这很容易凭着感觉推断出来

3.当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型，

4.当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，并且使用返回值，这时候优先考虑返回值的类型

5.参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型

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