Java基础之Java1.5重要新特性

Java 5新特性
   1、静态导入（开发中不推荐使用）
      import static 类的全限定名.静态成员（相当于将今天类定义为全局变量）
      
      例子
         public class Test{
             public static void mian(String[] args){
                  System.out.println(Math.PI);
                  System.out.println(Math.Max(1,2));
                  System.out.println(Math.Min(1,2));
             } //每次都需要写Math静态类获取成员变量和方法
         }
         //使用静态导入
         import static java.lang.Math.PI;//单独导入PI
         import static java.lang.Math.*;//全部一次性导入
         public class Test{
             public static void mian(String[] args){
                  System.out.println(PI);
                  System.out.println(max(1,2));
                  System.out.println(min(1,2));//直接写方法既可以
             } //每次都需要写Math静态类获取成员变量和方法
         }
   2、 可变参数（本质上就是数组）
         例子
         public class Test{
             public static void main(String[] args){
                  Sax p1=new Sax("张三",10,10);
                  Sax p2=new Sax("李四",20,10);
                  Sax p3=new Sax("王五",30,10);
                  //System.out.println(sum(new Sax[]{p1,p2,p3}));
                  System.out.println(sum(p1,p2,p3));
             } 
             //普通方式传参
             public static double sum(Sax[] saxs){
                  double sum=0;
                  for(int i=0;i<saxs.length;i++){
                      Sax sax=saxs[i];
                      sum+=sax.getA()*sax.getB();
                  }
                  return sum;
             }
             //可变参数传参（编译器级别特性）
             public static double count(Sax ...saxs){
                  double sum=0;
                  for(int i=0;i<saxs.length;i++){
                      Sax sax=saxs[i];
                      sum+=sax.getA()*sax.getB();
                  }
                  return sum;
             }
         }
         *两个方法其实效果是一样的，本质都是以数组方式传参。
         *如果有多个参数，则可变参数需要放在最后一个参数。
              (double count,Sax ...saxs)
         *StringUtils工具类
              //分割字符串方法
              public static String join(String separate,String ...data){
                     if(data==null || data.length==0){//data==null：判空必须的放在前面
                          return "";
                     } 
                     if(hasLength){
                          separate=",";
                     }
                     StringBuilder sb=new StringBuilder(data.length*2);//定义字符串设置长度
                     for(int i=0;i<data.length;i++){
                         sb.append(data[i]);
                         //不是最后一个字符则拼接一个分隔符
                         if(!i=data.length-1){
                             sb.append(separate);
                         }
                     } 
                     return sb.toString();
              }
              //判断字符串是否为空
              public static boolean hasLength(String str){
                   return str!=null && "".equals(str.trim());
              }
   3、增强for循环(就是foreach，可以循环数组(底层就是for循环遍历)和List(底层就是lterator遍历))
             public static double count(Sax ...saxs){
                  double sum=0;
                  for(Sax sax:saxs){
                      sum+=sax.getA()*sax.getB();
                  }
                  return sum;
             }


             public static double count(List saxs){
                  double sum=0;
                  for(Object o:saxs){
                      Sax sax=(Sac)o;
                      sum+=sax.getA()*sax.getB();
                  }
                  return sum;
             }
             *使用foreach循环时，要删除列表（List）元素，需要使用iterator的remove方法。


   4、自动装箱拆箱和缓存设计
      装箱：把对应的基本数据类型转化成包装类对象。
      拆箱：把基本类型的包装类对象转化为基本数据类型。
      *以前的装箱操作都只能使用手动。
          手动装箱
              int num=2;
              Integer nums=Integer.valueOf(num);
          手动拆箱
              int num=nums.intValue();
          自动装箱(底层还是和手动装箱一样，编译器级别（javac）)
              Integer num=7;  //java1.5以前不支持 
              int nums=num;
    *区别int和Integer类型是否相同：可以使用重载方法，一个参数是int一个是Integer
    *引用类型缓存：Byte/Integer/Long/Short缓存了【-127-127】
           Character:缓存了【0-127】
     即在-127-127定义的数值都会缓存
        Integer a=127;
        Integer b=127;
        System.out.println(a==b);//两个都为引用类型，值相同所指向的地址也相同所以结果为true(基本类型的等于是赋值，引用类型的等于是判断两个引用的地址是否一样)
   5、泛型的使用
        *泛型解决(强转)和(集合元素类型不一致)问题
        *泛型的参数E(Element元素)、T(Type类型)、K(Key:键一般用于map)、V(Value:值一般用于map)
        *泛型的种类
             自定义：
                List<map<String,List<Object>>> list=new ArrayList<map<String,List<Object>>>();
             集合：
        例子
             //1、定义一个包装类型---泛型类
             public class General<T>{
                 private T  value;
                 public void setValue(T value){
                       this.value=value;
                 }
                 public T setValue(){
                       return value;
                 }
             }
             //测试泛型类
             General<Integer> gen=new General<Integer>();
             gen.setValue(Integer.valueOf(12));
             //2、泛型方法(泛型转化)
                 //方法1
             public List<User> getUser(List<Employee> list){
                  List<User> user=new ArrayList<User>();
                  for(Employee emp:list){
                      user.add(emp);
                  }
                  return user;
             } 
                  //方法2
             public List<User> getUser(List<Employee> list){
                  //把带泛型的集合赋值给不带泛型的集合，泛型就会丢失（手动擦出泛型，类型必须一样）
                  List user=list;
                  return user;
             } 
   6、枚举类型的使用（Ennm）
      *枚举就是限定数据的范围。
      *注意
           1、枚举类不能实例化,构造器默认是私有的 。 
           2、枚举类型必须定义在其他成员之前。
           3、枚举类不能被继承。  
           4、枚举常量后面可以加()，前提是有无参构造器（默认）
           5、枚举常量后面可以加{},变成匿名内部类。
           6、枚举类的抽象方法只能又自己的匿名内部类实现。（调用抽象方法会自动调用匿名内部类的实现方法）
           7、switch支持枚举类型，底层是通过ordinal方法返回索引。
       常用方法：
           values() ==>Week[] week=Week.values();//返回枚举常量的数组
           valueOf()==>//Week week=Week.valueOf("MONDAY");返回一个枚举对象（把字符串转化为枚举对象）
       常用父类的方法（java.lang.Enum）
           week.name();//返回枚举对象声明的文字
           week.ordinal();//返回枚举对象的序号、索引
       //定义枚举类
       public enum Week{
           MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY;
       }//MONDAY表示常量（枚举常量），Week枚举类中有且仅有7个常量。
       //枚举类相当于
        public static class Week{
           private static final Week MONDAY=new Week();
           private static final Week TUESDAY=new Week();
           private static final Week WEDNESDAY=new Week();
           private static final Week THURSDAY=new Week();
           private static final Week FRIDAY=new Week();
           private static final Week SATURDAY=new Week();
           private static final Week SUNDAY=new Week();
           private Week(){}
       }
       例子
         //输出中文
         public enum Week{
             MONDAY("周一"),TUESDAY("周2"),WEDNESDAY("周3"),THURSDAY("周4"),FRIDAY("周5"),SATURDAY("周6"),SUNDAY("周7");
             private String chineseName;
             private Week(String chinsesName){ //复写空构造器
                  this.chineseName=chineseName;
             }
             //输出中文复写toString()方法
             public String toString(){
                 return this.chineseName;
             }
         }