day17

一、Java5.0新特性                        
1、编译器的功能更加强大，JVM变化不大 
2、Java在逐渐与C++融合 
3、五小点，四大点 

二、五小点 
1、自动封箱AutoBoxing/自动解封 
   自动封箱和自动拆箱，它实现了简单类型和封装类型的相互转化时，实现了自动转化。  
    byte b     -128~127 
    Byte b     在以上数量的基础上多一个null 

   简单类型和封装类型之间的差别 
   封装类可以等于null  ，避免数字得0时的二义性。 
   Integer i=null； 
   int ii=i；  //会抛出NullException 异常。相当于 int ii=i.intValue(); 
   Integer i=1； //相当于Integer i=new Integer(1); 
   i++;    // i = new Integer(i.intValue()+1); 

   在基本数据类型和封装类之间的自动转换 
   5.0之前 
   Integer i=new Integer（4）； 
   int  ii= i.intValue(); 

   5.0之后 
   Integer i=4； 
   Long l=4.3; 
   
   public void m(int i){......} 
   public void m(Integer i){......} 
   以上两个函数也叫方法重载 
   自动封箱解箱只在必要的时候才进行。能不封箱找到匹配的就不封箱。 
   
2、静态引入 StaticImport 
   使用类中静态方法时不用写类名 
   
   System.out.println(Math.round(PI)); 
   可以用以下代码实现： 
   import static java.lang.System.*;  //注意，要写" 类名.* " 
   import static java.lang.Math.*; 
   out.println(round(PI)); 
   
   注意：静态引入的方法不能重名 
   
3、for-each 
   统一了遍历数组和遍历集合的方式   
   for(Object o:list){     //Object o 表示每个元素的类型 ，list 表示要遍历的数组或集合的名字 
       System.out.println(o);  //打印集合或数组中的每个元素 
   } 
   
4、可变长参数 
   处理方法重载中，参数类型相同，个数不同的情况      
   public void m(int... is){.....} 
   
   int... is 相当于一个 int[] is 
   编译器会把给定的参数封装到一个数组中，再传给方法 
   在一个方法中只能有一个可变长参数，而且，必须放在最后一个参数的位置 
   
5、格式化输入/输出 
   java.util.Formatter类 对格式的描述 
   System.out.printf("Hello %s",str);  //打印字符串类型的变量，用一个占位符   
   
   格式化I/O(Formatted I/O) 
   java.util.Sacner类可以进行格式化的输入，可以使用控制台输入，结合了BufferedReader和StringTokener的功能。 
   
三、四大点   
1、枚举 
  枚举是一个类，并且这个类的对象是现成的，在定义类的时候，即定义好了对象 
  程序员要使用的时候，只能从中选择，无权创建 
  enum 枚举名{ 
枚举值1(..)，枚举值2(..)，.....; 
  } 
  
（1） 在5.0之前使用模式做出一个面向对象的枚举 
    final class Season{ 
public static final Season SPRING=new Season(); 
public static final Season WINTER=new Season(); 
public static final Season SUMMER=new Season(); 
        public static final Season AUTUMN=new Season(); 
        private Season(){} 
    } 
    完全等价于 
    enum Season2{ 
SPRING(..),//枚举值 
SUMMER(..), 
AUTUMN(..), 
WINTER(..) 
    }      
  
    枚举本质上也是一个类，Enum是枚举的父类。 
    这个类编译以后生成一个.class类 
    这个类有构造方法，但是是私有的 
  
    枚举中的values()方法会返回枚举中的所有枚举值 
    枚举中可以定义方法和属性，最后的一个枚举值要以分号和类定义分开，枚举中可以定义的构造方法。 
    枚举不能继承类（本身有父类），但可以实现接口，枚举不能有子类也就是final的，枚举的构造方法是private（私有的）。 
    枚举中可以定义抽象方法，可以在枚举值的值中实现抽象方法。 
    枚举值就是枚举的对象，枚举默认是final，枚举值可以隐含的匿名内部类来实现枚举中定义抽象方法。 
  
（2）枚举类(Enumeration Classes)和类一样，具有类所有特性。Season2的父类是java.lang.Enum; 
    隐含方法： 每个枚举类型都有的方法。 
    Season2[] ss=Season2.values();     ----获得所有的枚举值  
    for(Season2 s:ss){ 
      System.out.println(s.name());   ----- 打印枚举值 
      System.out.println(s.ordinal()); ----- 打印枚举值的编号 
    } 
  
  
（3）  enum可以switch中使用（不加类名）。 
  switch( s ){ 
case SPRING: 
……………. 
case SUMMER: 
……………. 
………….. 
  } 


（4）枚举的有参构造 
  enum Season2{ 
SPRING(“春”),-------------------------------逗号 
SUMMER(“夏”),-------------------------------逗号 
AUTUMN(“秋”),-------------------------------逗号 
WINTER(“冬”);-------------------------------分号 
private String name; 
Season2(String name){    //构造方法必须是私有的,可以不写private,默认就是私有的 
this.name=name; 
        } 
        String getName(){ 
        return name; 
        } 

  } 
  Season2.SPRING.getName()         ---------------------春 
  

（5）枚举中定义的抽象方法，由枚举值实现： 
  enum Operation{ 
ADD('+'){ 
public double calculate(double s1,double s2){ 
return s1+s2; 
} 
}, 
SUBSTRACT('-'){ 
public double calculate(double s1,double s2){ 
return s1-s2; 
} 
}, 
MULTIPLY('*'){ 
public double calculate(double s1,double s2){ 
return s1*s2; 
} 
}， 
DIVIDE('/'){ 
public double calculate(double s1,double s2){ 
return s1/s2; 
} 
}； 
char name; 
public char getName(){ 
return this.name; 
} 
Operation(char name){ 
this.name=name; 
} 
public abstract double calculate(double s1 ,double s2); 
  } 
  有抽象方法枚举元素必须实现该方法。 
  
  Operator[] os = Operator.values(); 
  for(Operator o:os){ 
     System.out.println("8 "+o.name()+" 2="+o.calculate(8,2)); 
  } 
  for(Operator o:os){ 
     System.out.println("8 "+o.getName()+" 2="+o.calculate(8,2)); 
  }  
  
  运行结果： 
  8 ADD 2=10.0 
  8 SUBSTRACT 2=6.0 
  8 MULTIPLY 2=16.0 
  8 DIVIDE 2=4.0 
  8 + 2=10.0 
  8 - 2=6.0 
  8 * 2=16.0 
  8 / 2=4.0 
  
  
2、泛型  
(1)增强了java的类型安全，可以在编译期间对容器内的对象进行类型检查，在运行期不必进行类型的转换。 
   而在java se5.0之前必须在运行期动态进行容器内对象的检查及转换，泛型是编译时概念，运行时没有泛型 

   减少含糊的容器，可以定义什么类型的数据放入容器 
   
(2)List<Integer> aList = new ArrayList<Integer>(); 
   aList.add(new Integer(1)); 
   // ... 
   Integer myInteger = aList.get(0);  //从集合中得到的元素不必强制类型转换 
   支持泛型的集合，只能存放制定的类型，或者是指定类型的子类型。   

   HashMap<String,Float> hm = new HashMap<String,Float>(); 
   
   不能使用原始类型 
   GenList<int> nList = new GenList<int>(); //编译错误 
   
   编译类型的泛型和运行时类型的泛型一定要一致。没有多态。 
   List<Dog> as = new ArrayList<Dog>(); 
   List<Animal> l = as;  //error  Animal与Dog的父子关系不能推导出List<Animal> 与 List<Dog> 之间的父子类关系 
   
（3）泛型的通配符"?"   
   ?   是可以用任意类型替代。 
   <?> 泛型通配符表示任意类型 
   <? extends 类型>  表示这个类型是某个类型或接口的子类型。 
   <? super 类型>    表示这个类型是某个类型的父类型。 

  import java.util.*; 
  import static java.lang.System.*; 
  public class TestTemplate { 
public static void main(String[] args) { 
List<Object> l1=new ArrayList<Object>(); 
List<String> l2=new ArrayList<String>(); 
List<Number> l3=new ArrayList<Number>();  //Number --- Object的子类，所有封装类的父类 
List<Integer> l4=new ArrayList<Integer>(); 
List<Double> l5=new ArrayList<Double>(); 

print(l1); 
print(l2); 
print(l3); 
print(l4); 
print(l5); 
} 
       static void print(List<? extends Number> l){    //所有Number及其子类 l3,l4,l5通过 
for(Number o:l){ 
out.println(o); 
} 
} 
       static void print(List<? extends Comparable> l){……}    //任何一个实现Comparable接口的类 l2,l4,l5通过 
       static void print(List<? super Number> l){……}          //所有Number及其父类 l1,l3通过 
      // "?"可以用来代替任何类型, 例如使用通配符来实现print方法。 
       public static void print(GenList<?> list){……} //表示任何一种泛型 

  } 

（4）泛型方法的定义 --- 相当于方法的模版 
  把数组拷贝到集合时，数组的类型一定要和集合的泛型相同。 
  <...>定义泛型，其中的"..."一般用大写字母来代替，也就是泛型的命名，其实，在运行时会根据实际类型替换掉那个泛型。 
  在方法的修饰符和返回值之间定义泛型 
  <E> void copyArrayToList(E[] os,List<E> lst){……} 
  static <E extends Number & Comparable> void copyArrayToList(E[] os,List<E> lst){……}   //定义泛型的范围 类在前接口在后 
  static<E , V extends E> void copyArrayToList(E[] os,List<E> lst){……} //定义多个泛型 
  "super"只能用在泛型的通配符上，不能用在泛型的定义上 
  
  import java.util.*; 
  public class TestGenerics3 { 
public static void main(String[] args) { 
List<String> l1=new ArrayList<String>(); 
List<Number> l2=new ArrayList<Number>(); 
List<Integer> l3=new ArrayList<Integer>(); 
List<Double> l4=new ArrayList<Double>(); 
List<Object> l5=new ArrayList<Object>(); 
String[] s1=new String[10]; 
Number[] s2=new Number[10]; 
Integer[] s3=new Integer[10]; 
Double[] s4=new Double[10]; 
Object[] s5=new Object[10]; 
copyFromArray(l1,s1); 
copyFromArray(l2,s2); 
copyFromArray(l3,s3); 
copyFromArray(l4,s4); 
copyFromArray(l5,s5); 

} 
//把数组的数据导入到集合中 
public static <T extends Number&Comparable> void copyFromArray(List<T> l,T[] os){ 
for(T o:os){ 
l.add(o); 
} 
} 
  } 
  
  受限泛型是指类型参数的取值范围是受到限制的. extends关键字不仅仅可以用来声明类的继承关系, 也可以用来声明类型参数(type parameter)的受限关系. 
  泛型定义的时候，只能使用extends不能使用 super，只能向下，不能向上。 
  调用时用<?>定义时用 <E> 
  
（5）泛型类的定义 
  类的静态方法不能使用泛型，因为泛型类是在创建对象的时候产生的。 
  class MyClass<E>{ 
public void show(E a){ 
System.out.println(a); 
} 
public E get(){ 
return null; 
} 

  } 

  受限泛型 
  class MyClass <E extends Number>{ 
public void show(E a){ 

} 
  }  
  
3、注释 
4、并发 


四、反射 reflect 
  反射，在运行时，动态分析或使用一个类进行工作。 
  反射是一套API，是一种对底层的对象操作技术 
1、类加载 
  类加载，生成.class文件，保存类的信息  
  类对象，是一个描述这个类信息的对象，对虚拟机加载类的时候，就会创建这个类的类对象并加载该对象。 
  Class，是类对象的类。称为类类。只有对象才会被加载到虚拟机中。一个类只会被加载一次。  
  
2、获得类对象的三种方式：（类对象不用new的方法得到的） 
1)也可以用 类名.Class,获得这个类的类对象。 
2)用一类的对象掉用a.getClass()，得到这个对象的类型的类对象。 
3)也可以使用Class.forName(类名)（Class类中的静态方法），也可以得到这个类的类对象， 
  （注意，这里写的类名必须是全限定名（全名），是包名加类名，XXX.XXX.XXXX）。强制类加载，这种方法是经常使用的。 
  
  一个类的类对象是唯一的。 
  在使用Class.forName(类名)时，如果使用时写的类名的类，还没有被加载，则会加载这个类。 
  
  Class c; 
  c.getName(); 返回类名 
  c.getSuperclass(); 这个方法是获得这个类的父类的类对象。 
  c.getInterfaces(); 会获得这个类所实现的接口，这个方法返回是一个类对象的数组。 
  
  方法对象是类中的方法的信息的描述。java.lang.reflect.Method,方法类的对象可以通过类对象的getMethods() 方法获得， 
  获得的是一个方法对象的数组，获得类中的定义的所有方法对象，除了构造方法。 

  构造方法对象，是用来描述构造方法的信息。java.lang.reflect.Constructor构造方法类的对象可以通过类对象的getConstructors()方法获得， 
  获得这个类的所有构造方法对象。 

  属性对象，使用来描述属性的信息。java.lang.reflect.Field属性类的对象对象可以通过类对象getFields() 这个方法是获得所有属性的属性对象。 

作业： 
1、通过运行时命令行参数输入一个类名，类出类中所有的方法 
2、实现一个带泛型的堆栈，用来存放Number 
3、实现一个栈，用来存放任意类型 
  方法：遍历,pop,push,从数组拷贝 
4、定义一个枚举，枚举值是课程，每个枚举值有个教师姓名的属性