黑马程序员---Java基础加强---JDK1.5新特性

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

JDK1.5新特性

一、静态导入

1.import 

import语句导入的是一个包下的某一个类或者是某一个包下的所有的类

import java.util.*;//导入包util中的所有的类

import java.util.ArrayList;//导入包util中的某一个类

2.import static

import static导入的是一个类的某一个静态方法或者是导入一个类的所有的静态方法

import static java.lang.Math.max;//导入一个类中的某一个静态方法

import static java.lang.Math.*;//导入一个类中的所有的静态方法

示例：

//静态导入System里的所有静态方法
import static java.lang.System.*;
public class StaticImportDemo
{

	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		out.println("尊敬的张老师"); //这里可以不用写System
	}
}

二、可变参数

1.可变参数的使用

当一个方法接收的参数个数不固定的时候就可以使用可变参数，如：add(1,2);add(1,2,5);等等

如果在函数中直接利用重载来写这个函数是很麻烦的事情。所以可以用可变参数

2.可变参数的特点
（1）可变参数只能放在函数参数列表的最后。

（2）...位于变量类型和变量名之间，前后有无空格都是可以的。

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

例子：

public class VaribleParameterTest 
{
	public static void main(String[] args)
	{
		System.out.println(add(2,3));
		System.out.println(add(2,3,5));		
	}
	//定义一个方法来实现不同参数列表的加法运算
	public static int add(int x,int...args)
	{
		int sum=x;
		//通过数组对此可变参数进行操作
		/*for (int i = 0; i < args.length; i++) 
		 * {
				sum+=args[i];
			
		   }*/
		//高级for循环进行遍历
		for(int arg:args)
		{
			sum+=arg;	
		}
		return sum;		
	}
}

三、增强for循环

1.语法格式：

for (type 变量名:集合变量名)
{
}
2.注意事项：

（1）迭代变量必须在（）中定义

（2）集合变量可以是数组或是实现了Iterable接口的集合类

例子：

public class ForEachDemo
{
	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		//定义一个字符串数组
		String[] names = {"zhangsan", "lisi", "wangwu", "zhaoliu", "zhouqi"};
		
		//用于迭代的变量name必须和数组里的元素是同一类型
		for(String name : names)
		{
			System.out.println(name);
		}
	}
}

四、基本数据的自动拆装箱及享元设计模式

1.自动拆箱和装箱

（1）装箱： Integer i1=12;//将12自动装箱为Integer对象

（2）拆箱：System.out.println(i1+2);//将i1又拆箱为基本数据类型进行加法运算

2.享元模式

对于很多很小的对象，当他们有很多相同的属性时，则在内存中只封装为一个对象，将不同的属性作为方法的参数，

称为外部状态；而相同的属性称为内部状态。

如：integer 这个单词中有两个相同的字母e，只是他们的位置不同（c（char,x,y））则在内存中只有一个这样的e

对象,并把表示位置的两个属性（x和y）作为方法的参数传入 如 display（x，y）。x和y成为外部状态，而char称为

内部状态。电脑中的文件也是利用的享元模式。

例子：

        Integer i2=13;
	Integer i3=13;
	System.out.println(i2==i3);//结果为true

	Integer i2=137;
	Integer i3=137;
	System.out.println(i2==i3);//结果为false
	即当数值范围为一个字节，即为-128~127时，则此对象直接缓存在内存中，当再有创建跟此对象的值一样的其他对
	象时，则直接不再创建，而是直接指向此对象。即为享元模式。

	Integer i2=Integer.valueOf(13);//这个不是自动装箱，是通过valueOf来转化的，但是否想等的原理和自动拆箱和装箱一样。
	Integer i2=Integer.valueOf(13);
	System.out.println(i2==i3);//结果为true

	Integer i2=Integer.valueOf(137);//这个不是自动装箱，是通过valueOf来转化的
	Integer i2=Integer.valueOf(137);
	System.out.println(i2==i3);//结果为false

五、枚举

1.枚举的作用介绍
（1）为什么要有枚举

枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错，枚举可以让编译器在编

译时就可以控制源程序中填写的非法值。

2.用普通类模拟枚举的实现原理

步骤：

（1）将构造方法私有化

（2）每个元素分别用一个公有的静态成员变量来表示。

（3）可以有若干个公有方法或抽象方法，例如，要提供nextDay方法必须是抽象的。采用抽象定义它，就将大量的

if else语句转移成了一个个独立的类。

例子：

public class EnumTest 
{  
    public static void main(String[] args) 
    {  
        // TODO Auto-generated method stub  
        WeekDay weekDay=WeekDay.MON;  
        WeekDay weekDay2=WeekDay.SUN;  
        System.out.println(weekDay);  
        System.out.println(weekDay.nextDay());  
    }  
}  

public abstract class WeekDay
{  
    //将构造函数私有化  
    private WeekDay(){}  
    //定义此类的对象，即定义此类的对象取值范围，是公有的  
    /*public static final WeekDay SUN=new WeekDay(); 
    public static final WeekDay MON=new WeekDay();*/  
      
    /*public String nextDay(){ 
        if (this==SUN) { 
            return "MON";    
        } else { 
            return "SUN"; 
        } 
    }*/  
      
    //将上述方法中的if else方法变成一个个的类来实现  
    public static final WeekDay SUN=new WeekDay(){  
        @Override  
        public WeekDay nextDay() {  
            // TODO Auto-generated method stub  
            return MON;  
        }     
    };  
    public static final WeekDay MON=new WeekDay(){  
        @Override  
        public WeekDay nextDay() {  
            // TODO Auto-generated method stub  
            return SUN;  
        }     
    };  
    //将它定义为抽象的方法  是为了在具体对象中具体实现它  
    public abstract WeekDay nextDay();  
    //通过实现toString来达到想要打印的对象的值  
    public String toString(){  
        return this==SUN?"SUN":"MON";  
    }  
}  

3.枚举的基本应用

（1）枚举类是一个特殊的类，其中的每个元素都是该类的一个实例对象。

（2）定义格式如下：

//枚举的基本应用
public enum WeekDay

{

SUN,MON,TUS,THS,WEN,FID,STA;//此处可加分号，可不加，当下面有内容时必须加上

}
（3）枚举类的几种方法如下以及具体应用：

public class EnumTest 
{
	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		WeekDay w1=WeekDay.SUN;
		System.out.println(w1);//结果为SUN，即此枚举类自身实现了toString方法
		System.out.println(w1.name());//打印结果为SUN
		System.out.println(w1.ordinal());//打印此对象在此类中对应第几个
		
		//此枚举类的静态方法
		//1、此方法是将SUN变为WeekDay的实例对象，并调用类中的方法toString（）
		//来得到相应的值，注意此传来的字符串应该是枚举类中具有的元素。
		System.out.println(WeekDay.valueOf("SUN"));
		//2、此方法为WeekDay[] arr=WeekDay.values();即得到此枚举类的元素
		System.out.println(WeekDay.values().length);	
	}
	//枚举的基本应用
	public enum WeekDay
	{
		//元素列表放在所有语句的前面，此元素列表的所有元素都是静态的，因为要被类直接调用。
		SUN,MON,TUS,THS,WEN,FID,STA;//此处可加分号，可不加，当下面有内容时
		                           //必须加上。
	}
}

4.实现带有构造方法的枚举

枚举类的特点：

（1）元素列表必须放在所有语句之前，若元素列表有下面有内容，则元素列表后面必须加

（2）构造方法必须私有化，当枚举中没写构造方法时，默认的构造方法也是私有的。

（3）每个元素调用的构造函数为无参构造方法

（4）指定使用有参的构造函数，在为SUN(与构造方法相对应类型的值)

（5）枚举只有一个成员时，就可以作为一种单例的实现方式。

代码：

//枚举的基本应用
public class EnumTest 
{
	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub	
		WeekDay w1=WeekDay.SUN;
		System.out.println(w1);//结果为SUN，即此枚举类自身实现了toString方法
		System.out.println(w1.name());//打印结果为SUN
		System.out.println(w1.ordinal());//打印此对象在此类中对应第几个
		
		//此枚举类的静态方法
		//1、此方法是将SUN变为WeekDay的实例对象，并调用类中的方法toString（）
		//来得到相应的值，注意此传来的字符串应该是枚举类中具有的元素。
		System.out.println(WeekDay.valueOf("SUN"));
		//2、此方法为WeekDay[] arr=WeekDay.values();即得到此枚举类的元素
		System.out.println(WeekDay.values().length);
	}
//枚举的基本应用
	public enum WeekDay
	{
		//元素列表必须放在所有语句前面
		SUN,MON,TUS,THS,WEN,FID,STA;//此处可加分号，可不加，当下面有内容时
		                           //必须加上。
		
		//构造方法必须私有化,上面的元素默认的调用的构造函数为无参的构造函数
		private WeekDay()
		{
			System.out.println("first");
		}
		//若要想调用此构造函数，则元素列表中的元素应该写成SUN(1)
		private WeekDay(int day)
		{
			System.out.println("second");	
		}	
	}
}

5.实现带有抽象方法的枚举

public class EnumTest 
{
	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		TrafficLamp tl=TrafficLamp.RED;
		System.out.println(tl);
		System.out.println(tl.nextLamp());	
	}
	//交通灯的枚举类，并且里面有抽象方法
	public enum TrafficLamp
	{
		/*
		 * //由于此类为抽象的，所以没办法直接创建对象，所以利用匿名子类来创建子类对象
		//以下是使用无参的构造方法来创建的
		RED{

			@Override
			public TrafficLamp nextLamp() {
				// TODO Auto-generated method stub
				return GREEN;
			}	
		},
		GREEN{
			@Override
			public TrafficLamp nextLamp() {
				// TODO Auto-generated method stub
				return YELLOW;
			}	
		},
		YELLOW{
			@Override
			public TrafficLamp nextLamp() {
				// TODO Auto-generated method stub
				return RED;
			}	
		};
		*/
		//利用有参的构造方法
		RED(100){

			@Override
			public TrafficLamp nextLamp() 
			{
				// TODO Auto-generated method stub
				//System.out.println(time);
				return GREEN;
			}	
		},
		GREEN(50){
			@Override
			public TrafficLamp nextLamp() 
			{
				// TODO Auto-generated method stub
				return YELLOW;
			}	
		},
		YELLOW(10){
			@Override
			public TrafficLamp nextLamp() 
			{
				// TODO Auto-generated method stub
				return RED;
			}	
		};
		//抽象方法
		public abstract TrafficLamp nextLamp();
		//构造函数私有化
		private TrafficLamp(){}
		private int time;
		private TrafficLamp(int time)
		{
			this.time=time;
		}	
	}
}