java复习第十七天

一、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、定义一个枚举，枚举值是课程，每个枚举值有个教师姓名的属性