Java基础加强_JDK1.5新特性

JDK1.5新特性 静态导入

静态导入和非静态导入的区别 ： 顾名思义 import语句可以导入一个类或某个包中的所有类

import static语句导入一个类中的某个静态方法或所有静态方法，另外静态导入比非静态导入更加简化了代码的书写

静态导入的范围不同，那么导入的静态方法的范围也不同 例如： import static java.lang.*;此处导入的是lang包中的所有静态方法 import static java.lang.math.*;此处导入的是math类下的所有静态方法

代码示例：

package com.learn;
import static java.lang.Math.*;
public class Demo
{

	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		int a = 5;
		int b = 9;
		System.out.println(max(a,b));
	}

}
           

可变参数 可变参数用于解决一个方法中传入相同类型的不同参数的问题 可变参数的变量是数组类型，如果要使用可变参数中的值，需要遍历其中的元素

可变参数的特点：

只能出现在参数列表的最后；这个要记住

...位于变量类型和变量名之间，前后有无空格都可以;

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

package com.learn;

public class Demo2
{

	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		System.out.println(sum(1,2,3,4,5));
	}
	public static int sum(int...a)
	{
		int b = 0;
		for (int i = 0; i < a.length; i++)
		{
			b +=a[i];
		} 
		return b;
	}

}
           

增强for循环

语法：

for ( type 变量名：集合变量名 )  { … } 

注意事项：

迭代变量必须在( )中定义！

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

增强for循环和普通for循环的区别：

1.定义格式不同：增强for循环中，定义一个变量用于存储每次遍历到的元素 普通for循环中，可以定义一个循环增量，来记录循环的次数 2.增强for循环必须有遍历的目标 普通for循环相对灵活一些

包装类（将基本数据类型封装成对象）

JAVA语言是一门面向对象的语言，这里一切都是对象，所以这里的基本数据类型也包装成了对象，方便程序员的操作

基本数据类型和包装类之间的转换：

基本类型变量-->包装类对象：通过new WrapperClass(primitive)创建 包装类对象-->基本类型变量：通过WrapperInstance.xxxvalue()方法

基本数据类型的自动拆箱与装箱

自动装箱： Integer num1 = 12; 自动拆箱： System.out.println(num1 + 12);

基本数据类型的对象缓存：

Integer num1 = 12;

Integer num2 = 12;

System.out.println(num1 == num2); 这块相等，<=127都是真的

Integer num3 = 129;              

Integer num4 = 129;

System.out.println(num3 == num4); 当Integer的实例对象大于127时，将会重新创建一个Integer实例，所以不相等

枚举

枚举类概述：

java5新增了一个enum关键字（它与class，interface关键字的地位相同，作用相似），用以定义枚举类。枚举是一个特殊的类，它的内部一样可以定义Filed、方法、构造函数，可以实现一个或者多个接口。一个java源文件中最多只能定义一个public访问权限的模具类，且该java源文件也必须和该枚举类的类名相同。

枚举类和普通类的区别：

1.枚举类可以实现一个或多个接口，使用enum定义的枚举类默认继承了java.lang.Enum类，普通类是直接继承Object类的。同时Enum类实现了Serializable和Comparable两个接口，也就是说，enum类可以调用Enum中的方法和复写Serizlizable和Comparable接口中的抽象方法； 2.使用enum定义、非抽象的枚举类默认会使用final修饰，因此枚举类不能被继承，也就是没有子类。 3.枚举类的构造器只能使用private修饰符，如果省略了构造器的访问控制符，则默认使用private修饰。 4.枚举类的所有实例必须在枚举类的第一行显示列出，否则这个枚举类永远不能产生实例。列出这些实例时，系统会自动添加public static final修饰，无需程序员显示添加。

枚举的作用：

枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。 枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

普通类实现枚举功能步骤：

1.私有的构造函数 2.每个元素分别用一个公有的静态成员变量表示 public static final 3.可以有若干公有方法或抽象方法。

代码示例：

package com.learn;


public class SeasonTest
{
	/**
	 * @param args
	 * 1.私有的构造函数
	 * 2.每个元素分别用一个公有的静态成员变量表示 public static final
	 * 3.可以有若干公有方法或抽象方法。
	 * 定义季节的枚举类
	 */
	public SeasonTest(Season s)
	{
		//创建该类的构造函数
		System.out.println("季节："+s.getName());
	}
	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		//创建对象，传入Season类中的静态常量
		new SeasonTest(Season.AUTUMN);
	}
}
class Season
{
	private String name;
	//因为季节对象是固定的四个季节，所以使用final分别定义四个季节常量
	public static final Season SPRING = new Season("春天");
	public static final Season SUMMER = new Season("夏天");
	public static final Season AUTUMN = new Season("秋天");
	public static final Season WINTER = new Season("冬天");
	//用private将构造函数隐藏
	private Season(String name)
	{
		// TODO Auto-generated constructor stub
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}
           

使用枚举类升级上面程序

package com.learn;
//此处enum类如果修饰符是public，必须单独写一个类文件
enum Season1
{
	//枚举类的素有示例必须写在该类的第一行
	//SPRING("春天")是这样写法的简写：
	//publi static final SPRING = new Season("春天");
	SPRING("春天"),SUMMER("夏天"),AUTUMN("秋天"),WINTER("冬天");
	private String name;
	private Season1(String name)//使用private隐藏枚举中的构造方法
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}
public class SeasonTest2
{
	SeasonTest2(Season s)
	{
		System.out.println("季节："+s.getName());
	}
	public static void main(String[] args)
	{
		new SeasonTest2(Season.AUTUMN);
	}
	
}
           

Java.lang.Enum类中常用的方法

Enum  values()：返回枚举类中的元素 int  ordinal()：返回枚举值在类中的索引值，其实就是角标，从零开始 public static<Textends Enum<T>> T  valueOf(Class<T> enum Type,String name)：返回指定枚举类中的指定枚举值

枚举中的抽象方法

package com.learn;


public class TrafficLamp
{


	/**
	 * @param args
	 */
	public TrafficLamp(Lamp l)
	{
		System.out.println(l);
	}
	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		new TrafficLamp(Lamp.GREEN);
	}
	public enum Lamp
	{
		//枚举类的抽象方法
		/*相当于
		public static final RED = new Lamp的子类(40)
		{
			public Lamp returnLamp()
			{
				return YELLOW;
			}
		}
		简写
		*/
		RED(40)
		{
			public Lamp returnLamp()
			{
				return YELLOW;
			}
		},
		GREEN(60)
		{
			public Lamp returnLamp()
			{
				return RED;
			}
		},
		YELLOW(3)
		{
			public Lamp returnLamp()
			{
				return GREEN;
			}
		};
		private int time;
		//每个实例实现该抽象方法
		public abstract Lamp returnLamp();
		private Lamp(int time)
		{
			this.time = time;
		}
	}


}
           

总结： 1.枚举类中的实例变量都是静态的，因此都可以使用枚举类名直接调用。 RED完整形式： public static final RED = new Lamp(int time);

2.编译上面的程序，可以看到生成了TrifficLamp$Lamp$1.class，TrifficLamp$Lamp$2.class，TrifficLamp$Lamp$3.class，TrifficLamp$Lamp.class四个文件，这说明RED，YELLOW，GREEN三个类是Lamp的匿名子类的实例

3.枚举只有一个成员时，可以用单例设计模式实现。