jdk5.0新特性（泛型、枚举、静态导入、自动拆装箱、增强for、可变参数）

最新推荐文章于 2024-02-20 11:31:05 发布

qq_26676207

最新推荐文章于 2024-02-20 11:31:05 发布

阅读量439

点赞数

分类专栏： java

java 专栏收录该内容

120 篇文章 0 订阅

订阅专栏

1.泛型的简介

* 为什么要使用泛型？
- 一般使用在集合上
** 比如现在把一个字符串类型的值放入到集合里面，这个时候，这个值放入到集合之后，失去本事的类型，只能是object类型，
这个时候，比如想要对这个值进行类型转换，很容易出现类型转换错误，怎么解决这个问题，可以使用泛型来解决

* 在集合上如何使用泛型
- 常用集合 list set map
- 泛型语法集合<String> 比如 List<String>
* 在泛型里面写是一个对象，String 不能写基本的数据类型比如int (****)
** 写基本的数据类型对应包装类
byte -- Byte
short -- Short

int -- Integer

long -- Long

float -- Float
double -- Double

char -- Character

boolean -- Boolean

* 在list上使用泛型
list的三种实现 ArrayList linkedList Vector
代码：

@Test
		public void testList() {
			List<String> list = new ArrayList<String>();
			list.add("aaa");
			list.add("bbb");
			list.add("ccc");


			//遍历list集合 有几种方式  三种
			//普通for循环  迭代器  增强for


			//普通for循环
			for(int i=0;i<list.size();i++) {
				String s = list.get(i);
				System.out.println(s);
			}


			System.out.println("=================");
			//使用增强for
			for (String s1 : list) {
				System.out.println(s1);
			}


			System.out.println("=================");
			//使用迭代器遍历
			Iterator<String> it = list.iterator();
			while(it.hasNext()) {
				System.out.println(it.next());
			}

* 作业1： ArrayList linkedList Vector 这三个区别

* 在set上使用泛型
代码：
//泛型使用set集合上

@Test
		public void testSet() {
			Set<String> set = new HashSet<String>();
			set.add("www");
			set.add("qqq");
			set.add("zzz");
			//set.add("qqq");
			//遍历set 有几种方式  两种
			//迭代器  增强for
			//使用增强for遍历
			for (String s2 : set) {
				System.out.println(s2);
			}
			System.out.println("=================");
			//使用迭代器遍历
			Iterator<String> it1 = set.iterator();
			while(it1.hasNext()) {
				System.out.println(it1.next());
			}
		}

* 在map上面使用泛型
- map结构：key-valu形式
代码：
//在map上使用泛型

	@Test
		public void testMap() {
			Map<String,String> map = new HashMap<String,String>();
			map.put("aaa", "111");
			map.put("bbb", "222");
			map.put("ccc", "333");
			//遍历map 有几种遍历方式 两种
			// 1、获取所有的key，通过key得到value 使用get方法
			// 2、获取key和value的关系
			//使用第一种方式遍历
			//获取所有的key
			Set<String> sets = map.keySet();
			//遍历所有key返回的set
			for (String key : sets) {
				//通过key得到value
				String value = map.get(key);
				System.out.println(key+" : "+value);
			}
			
			System.out.println("==============");
			//得到key和value的关系
			Set<Entry<String, String>> sets1 = map.entrySet();
			//遍历sets1
			for (Entry<String, String> entry : sets1) {
				//entry是key和value关系
				String keyv = entry.getKey();
				String valuev = entry.getValue();
				System.out.println(keyv+" : "+valuev);
			}
		}

1.1、泛型使用在方法上

* 定义一个数组，实现指定位置上数组元素的交换
* 方法逻辑相同，只是数据类型不同，这个时候使用泛型方法
* /*
* 使用泛型方法需要定义一个类型使用大写字母表示 T :这个T表示任意的类型
* 写在返回值之前 void之前 <T>
* =======表示定义了一个类型这个类型是 T
* 在下面就可以使用这个类型了 T
* */

public static <T> void swap1(T[] arr ,int a,int b) {
		T temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}

（2）练习：实现一个泛型方法，接受任意类型的数组，颠倒数组中所有元素
代码

public static <T> void reverses(T[] arr1) {
		/*
		 * 基本思想：把第一个元素和最后一个元素交换位置，把第二个元素和倒数第二个元素交换位置。。。。
		 * 交换 长度/2
		 * */
		//遍历数组
		for(int i=0;i<arr1.length/2;i++) {
			/*int temp = arr1[0];
			arr1[0] = arr1[arr1.length-1];*/
			T temp = arr1[i];
			arr1[i] = arr1[arr1.length-i-1];
			arr1[arr1.length-i-1] = temp;
		}
		
	}

.泛型擦除

* 首先泛型只是出现在源代码阶段，当编译之后泛型不存在了

1.2、泛型在类上的使用（了解）

* 在一个类上定义一个类型，这个类型可以在类里面直接使用

	* public class TestDemo04<T> {
	
	//在类里面可以直接使用T的类型
	T aa;
	public void test11(T bb) {}
	
	//写一个静态方法 在类上面定义的泛型，不能再静态方法里面使用
	public static <A> void test12(A cc) {}
	}

2、枚举的简介

* 什么是枚举？
** 需要在一定的范围内取值，这个值只能是这个范围内中的任意一个。
** 现实场景：交通信号灯，有三种颜色，但是每次只能亮三种颜色里面的任意一个

* 使用一个关键字 enum
** enum Color3 {
RED,GREEN,YELLOW;
}
* 枚举的构造方法也是私有的

* 特殊枚举的操作（了解）
** 在枚举类里面有构造方法
** 构造方法里面有参数，需要在每个实例上面都写参数
** 在枚举类里面有抽象方法
** 在枚举的每个实例里面都重写这个抽象方法

2.1、枚举的api的操作

** name() ：返回枚举的名称
** ordinal() ：枚举的下标，下标从0开始
** valueOf(Class<T> enumType, String name) ：得到枚举的对象

** 还有两个方法，都是这两个方法不在api里面，编译的时候生成两个方法
*** valueof(String name) 转换枚举对象
*** values() 获得所有枚举对象数组

* 练习：枚举对象、枚举对象下标、枚举对象名称表示之间的转换
- //知道枚举的对象，得到枚举名称和下标

@Test
	public void test1() {
		//得到枚举对象
		Color100 c100 = Color100.RED;
		//枚举名称
		String name = c100.name();
		//枚举的下标
		int idx = c100.ordinal();
		System.out.println(name+" "+idx);
	}

- //知道枚举的名称，得到枚举的对象和下标

	@Test
	public void test2() {
		String name1 = "GREEN";
		//得到对象
		Color100 c1 = Color100.valueOf(name1);
		//枚举下标
		int idx1 = c1.ordinal();
		System.out.println(idx1);
	}

- //知道枚举的下标，得到枚举的对象和名称

@Test
	public void test3() {
		int idx2 = 2;
		//得到枚举的对象
		Color100[] cs = Color100.values();
		//根据下标得到对象
		Color100 c12 = cs[idx2];
		//得到枚举的名称
		String name = c12.name();
		System.out.println(name);
	}

3.、静态导入(了解)

* 可以在代码里面，直接使用静态导入方式，导入静态方法或者常量
* import static XX.XX.xxx

* import static java.lang.System.out;
import static java.util.Arrays.sort;

** 比如现在实现一个计算器在Math类里面

4、自动拆装箱

* 装箱
** 把基本的数据类型转换成包装类
* 拆箱
** 把包装类转换成基本的数据类型

** //自动装箱
Integer i = 10;

//自动拆箱
int m = i;

** 在jdk1.4里面如何实现装箱和拆箱
- //在jdk1.4里面实现拆装箱
public void test1() {
//装箱
Integer m = new Integer(10);
//拆箱
int a = m.intValue();
}
** jdk是会向下兼容
- 比如 jdk1.4里面写的代码，这个时候到5.0里面也可以运行

** 练习：向下兼容
== 执行的结果是会调用 doSomething(double m)
== 首先在jdk1.4里面肯定调用这个方法，如果调用下面的方法，需要类型转换，但是jdk1.4不能实现自动拆装箱
== 由于jdk是向下兼容，所以，在jdk1.4调用这个方法，在jdk5.0里面还是会调用这个方法
public static void main(String[] args) {
doSomething(10);

}

public static void doSomething(double m) {
System.out.println("double......");
}

public static void doSomething(Integer a){
System.out.println("integer.....");
}
** 记住：八种基本的数据类型对应的包装类
* int --- Integer
* char--- Character

5、增强for循环（*****）

* 语法 for(遍历出来的值 : 要遍历的集合) {}
- for(String s : list) {
System.out.println(s);
}
* 使用场景：数组；实现Iterable接口的集合可以使用增强for循环

* 在集合上使用增强for循环遍历
list set 实现了Iterator接口，所以可以使用增强for循环
map不能使用增强for循环，没有实现Iterator接口，所以不能使用增强for循环

* 增强for循环出现目的：为了替代迭代器
** 增强for底层就是迭代器实现的

6、可变参数

* 可变参数可以应用在什么场景：
** 实现两个数的相加，实现三个数的相加四个数的相加
-- 如果实现的多个方法，这些方法里面逻辑基本相同，唯一不同的是传递的参数的个数，可以使用可变参数

* 可变参数的定义方法数据类型...数组的名称
* 理解为一个数组，这个数组存储传递过来的参数
- 代码

/**
 * 演示可变参数
 * @author asus
 *
 */
public class TestDemo1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//int..num;
		add1(10,20);
		add1(10,20,30);
		add1(10,20,30,40);
	}
	
	public static void add1(int a,int...nums) {
		//nums理解为一个数组，这个数组存储传递过来的参数
		//System.out.println(nums.length);
		int sum = 0;
		//遍历数组
		for(int i=0;i<nums.length;i++) {
			sum += nums[i];
		}
		System.out.println(sum);
	}
	
	/*//实现两个数的相加
	public void add1(int a,int b) {
		int sum = a+b;
		System.out.println(sum);
	}
	
	//实现三个数的相加
	public void add1(int a,int b ,int c) {
		int sum = a+b+c;
		System.out.println(sum);
	}
	
	//实现四个数的相加
	public void add1(int a,int b ,int c,int d) {
		int sum = a+b+c+d;
		System.out.println(sum);
	}*/
}

* 注意的地方
（1）可变参数需要写在方法的参数列表中，不能单独定义
（2）在方法的参数列表中只能有一个可变参数
（3）方法的参数列表中的可变参数，必须放在参数最后
- add1(int a,int...nums)