java笔记20 JDK1.5新特性

1.      静态导入

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

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

 

         import staticjava.lang.Math.*;//导入Math类下所有的静态方法。
public class StaticImport
{
         public static voidmain(String[] args)
         {       
                       System.out.println(max(3, 6));//直接使用Math中的方法
                       System.out.println(abs(3-6));
              }
     }

        

2.      可变参数

         特点：

1、  只能出现在参数列表的最后

2、  …位于变量类型和变量名之间，前后有无空格均可。

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

4、  使用的时候 类型后面加三个点号加数组名

5、  public static int add(int ... args)//前面可以定义别的参数

 

public class VariableParameter {
    public static void main(String[] args) {
        int sum=add(2,3,4,5,6,7,8,8,7);
        System.out.println(sum);
    }
    public static int add(int ... args)
    {
        int sum=0;
/*      for(int i=0;i<args.length;i++)
        {
            sum+=args[i];
        }*/
        for(int x:args)
        {
            sum+=x;
        }      
        return sum;
    }
}

3.      增强for循环        

         语法：for(变量类型变量名：集合/数组名)

{
         具体操作；

}

变量类型可以加修饰符，集合必须是实现了Iterator接口的集合类

                   只能获取元素，不能对集合做修改

         

迭代器除了遍历，还可以进行remove操作集合中的元素

如果使用ListIterator 还可以在遍历过程中进行增删改查

       

高级for循环有一个局限性，必须有被遍历的目标。

建议在遍历数组的时候，还是用传统for循环

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
 
public class H_18ForEach {
    public static void main(String[] args) {
        ArrayList<String> al=new ArrayList<String>();
        al.add("add1");
        al.add("add2");
        al.add("add3");
        al.add("add4");
        for(String s:al)//s的指向在变化 不能对元素做修改
        {
            System.out.println(s);
        }
        for(Iterator<String> it=al.iterator();it.hasNext();)
        {
            System.out.println(it.next());
        }
       
        HashMap<Integer,String> hm=new HashMap<Integer,String>();
        hm.put(1, "set1");
        hm.put(2, "set2");
        hm.put(3, "set3");
        hm.put(4, "set4");
       
        //必须先获得set集合
        Set<Integer> keySet=hm.keySet();
        for(Integer i:keySet)
        {
            System.out.println(i+","+hm.get(i)+"  ");
        }
        //Set<Map.Entry<Integer, String>> entrySet=hm.entrySet();
        for(Map.Entry<Integer, String> me: hm.entrySet())
        {
            System.out.println(me.getKey()+"_"+me.getValue());
        }
    }
}

 

4.      自动拆箱与装箱

         //自动装箱

         Integer num1=12;//自动装成包装类

         //自动拆箱

         System.out.println(num1+12);//num1被拆成整数

         Integer num2=11;

         Integer num3=11;

         System.out.println(num2==num3);//true 小于一个字节的数据会被存在在一个池子中

         //经常被调用

         Integer num4=128;

         Integer num5=128;

         //大于一个字节则分开存放

         System.out.println(num4==num5);//false 

         如果是手动装箱使用valueOf方法也是一样。

 

         享元模式（英语：Flyweight Pattern）是一种软件设计模式。它使用共享物件，用来尽可能减少内存使用量以及分享资讯给尽可能多的相似物件；它适合用于只是因重复而导致使用无法令人接受的大量内存的大量物件。通常物件中的部分状态是可以分享。常见做法是把它们放在外部数据结构，当需要使用时再将它们传递给享元。

                  

例如：英语单词很多，只要定义26个字母对象，出现重复字母只要添加位置参数即可。

         这里面字母对象是很小很细的对象，属性相同，定义成一个对象，不同的东西定义成外部参数传入。

再例如,如果发现某个对象的生成了大量细粒度的实例，并且这些实例除了几个参数外基本是相同的，如果把那些共享参数移到类外面，在方法调用时将他们传递进来，就可以通过共享大幅度单个实例的数目。

 

16、枚举

         为什么要有枚举：

                   让某个类型的变量取值只能是若干个固定值中的一个，某则，编译就会报错。

枚举可以让编译器在编译时就可以控制源程序中填写的非法值。

         枚举的表示：  

public class EnumTest
{
    public static void main(String[] args)
    {      
           Week week2=Week.SUN;
        System.out.println(week2);//直接打印
        System.out.println(week2.name());//和直接打印相同
        System.out.println(week2.ordinal());//打印角标，从0开始
        System.out.println(week2.valueOf("SUN"));//与字符串对应的枚举
        System.out.println(week2.values().length);//数组长度
    }
    public enum Week// 枚举需要创建类，返回类型为枚举
    {
        SUN(1),MON,TUE,WED,THU,FRI,SAT;//枚举的具体内容,必须在类中的第一行
        //构造方法只能是私有的
        private Week(){}
        private Week(int x){System.out.println(2);}      
    }
    public enum TrafficLamp
    {
        RED (30)//TrafficLamp有一个抽象方法，RED是其一个子类，那么要复写其抽象方法    
        {
            public TrafficLamp nextLamp()
            {              
                return GREEN;
            }
        },//这里仍然是逗号
        GREEN(45)
        {          
            public TrafficLamp nextLamp()
            {
                return YELLOW;
            }
        },
        YELLOW (5)
        {
            public TrafficLamp nextLamp() {
                return RED;
            }
        };  //最后是分号
        public abstract TrafficLamp  nextLamp();
        private int time;
        private TrafficLamp(){}//私有化构造函数
        private TrafficLamp(int time)
        {
            this.time=time;
        }      
    }  
}

结果

2

SUN

SUN

0

SUN

7