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

ゞ浴缸里的玫瑰 2021-06-24 16:10 338阅读 0赞

**包含内容：** 泛型、枚举、静态导入、自动拆装箱、增强for循环、可变参数。反射。

## 泛型 ##

*  为什么要使用泛型？
    
    一般使用在集合上。比如我们现在把一个字符串类型的值放入到集合里面，这个时候，这个值放入到集合之中，就会失去本身的类型，会变成object类型。这个时候对这个值进行类型转换，很容易出现类型转换错误。为了解决这个问题，我们可以使用泛型来解决。
 *  在集合上如何使用泛型？
    
    常用的集合：list、set、map  
    泛型语法：`集合<String>`比如：`list<String>`
    
        List<String> list = new ArrayList<String>();
        list.add("aaa");
        list.add("bbb");
 *  在泛型里面写的是一个对象，比如String，但是不能写基本的数据类型，比如int、float。所以要使用基本数据类型时，要写基本数据类型的包装类。
    
        byte--Byte
        short--Short
        int--Integer
        long--Long
        
        float--Float
        double--Double
        char--Character
        boolean--Boolean

### 泛型在集合上的使用 ###

*  在list上的使用泛型  
    list的三种实现：`ArrayList`、`LinkedList`、`Vector`
    
        public static 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 str = list.get(i);
        		System.out.println(str);
        	}
        
        	// 增强for循环
        	for (String string : list) { 
        		System.out.println(string);
        	}
        
        	// 使用迭代器来遍历
        	Iterator<String> it = list.iterator();
        	while (it.hasNext()) { 
        		System.out.println(it.next());
        	}
        }
 *  在set上的使用泛型
    
        public static void testSet() { 
        	Set<String> set = new HashSet<String>();
        	set.add("www");
        	set.add("qqq");
        	set.add("zzz");
        
        	// 遍历set 有两种方式：迭代器、增强for
        
        	// 增强for
        	for (String string : set) { 
        		System.out.println(string);
        	}
        
        	// 迭代器
        	Iterator<String> it = set.iterator();
        	while (it.hasNext()) { 
        		System.out.println(it.next());
        	}
        }
 *  在map上使用泛型
    
        public static 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的关系
        
        	// 1. 获取所有的key，通过key得到value，使用get方法
        	Set<String> sets = map.keySet();
        	for (String key : sets) { 
        		String value = map.get(key);
        		System.out.println(key + " " + value);
        	}
        
        	// 2.获取key和value的关系
        	Set<Entry<String, String>> entrySet = map.entrySet();
        	for (Entry<String, String> entry : entrySet) { 
        		// entry是key和value的关系
        		String keyv = entry.getKey();
        		String valuev = entry.getValue();
        		System.out.println(keyv + " " + valuev);
        	}
        }

### 泛型方法 ###

定义几个数组，实现指定位置的数组元素交换。  
这个数组的数据类型可以是整形，可以是字符串，等等等等。我们可以使用函数的重载来完成这些功能。  
**但是我们发现，这些方法的逻辑都相同，只是数据类型不同，这个时候我们可以泛型方法。**

使用泛型方法，需要定义一个类型，使用大写字母表示，T：这个T表示任意的类型。  
写在返回值void之前，表示定义了一个类型，这个类型是T，在下面就可以使用这个类型T了。

public static void testInt() { 
    	// 创建一个整数数组
    	Integer[] arr = {  66, 82, 55, 34, 75 };
    	System.out.println(Arrays.toString(arr));
    	// 交换66和55的位置
    	swap(arr, 0, 2);
    	// 查看结果
    	System.out.println(Arrays.toString(arr));
    }
    
    public static void testString() { 
    	// 创建一个字符串数组
    	String[] arr2 = {  "aaa", "bbb", "ccc", "ddd", "eee" };
    	System.out.println(Arrays.toString(arr2));
    	// 交换aaa和ccc的位置
    	swap(arr2, 0, 2);
    	// 查看结果
    	System.out.println(Arrays.toString(arr2));
    }
    
    public static <T> void swap(T[] arr, int i, int j) { 
    	// 三变量交换法
    	T temp = arr[i];
    	arr[i] = arr[j];
    	arr[j] = temp;
    }

### 泛型在类上的使用 ###

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

public class TestDemo04<T> { 
    	// 在类里面就可以直接使用T的类型
    	T aa;
    	public void test(T aaa) { 
    	}
    	
    	// 写一个静态方法在类上面定义的泛型，不能在静态方法里面使用
    	public static T void test2(){ 
    		// 这样是不可以的！
    		// 报错：Syntax error on token "T", transient expected
    	}
    }

## 枚举 ##

什么是枚举？

*  需要在一定范围内取值，这个值只能是这个范围内中的一个。
 *  现实场景：交通信号灯，有三种颜色，每次只能亮其中一个。

枚举格式：

enum 枚举类型名称 { 
    	枚举对象1名称,
    	枚举对象2名称,
    	...
    	枚举对象n名称;
    }

枚举的构造方法也是私有的。

### 特殊枚举的操作 ###

*  **在枚举类里面有构造方法**
    
        enum Color { 
        	RED("red"), GREEN("green"), YELLOW("yellow");
        	private Color(String name) { }
        }
 *  **在枚举类里面有抽象方法**  
    当在枚举类里面写了抽象方法之后，需要在每个实例上面都实现抽象方法
    
        enum Color { 
        	RED { 
        		@Override
        		public void print1() { 
        			System.out.println("red");
        		}
        	},
        	GREEN { 
        		@Override
        		public void print1() { 
        			System.out.println("green");
        		}
        	},
        	YELLOW { 
        		@Override
        		public void print1() { 
        			System.out.println("yellow");
        		}
        	};
        	// 抽象方法
        	// 当在枚举类里面写了抽象方法之后，需要在每个实例上面都实现抽象方法
        	public abstract void print1();
        }

### 枚举api的使用 ###

`name()`：返回此枚举常量的名称，在其枚举声明中对其进行声明。  
`ordinal()`：返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。  
`valueOf(Class<T> enumType, String name)`：返回带指定名称的指定枚举类型的枚举常量。  
还有两个方法，但是这两个方法不在api里面，编译的时候生成这两个方法：  
`valueof(String name)`：转换枚举对象  
`value()`：获得所有枚举对象数组

#### 练习 ####

**枚举对象、枚举对象下标、枚举对象名称表示之间的转换**

*  知道枚举的对象，得到枚举名称和下标
    
        // 知道枚举的对象，得到枚举名称和下标
        @Test
        public void test1() { 
        	// 得到枚举对象
        	Color c = Color.RED;
        	// 得到枚举的名称
        	String name = c.name();
        	System.out.println(name);
        	// 得到枚举的下标
        	int index = c.ordinal();
        	System.out.println(index);
        }
 *  知道枚举的名称，得到枚举的对象和下标
    
        // 知道枚举的名称，得到枚举的对象和下标
        @Test
        public void test2(){ 
        	String name = "GREEN";
        	// 得到对象
        	Color c = Color.valueOf(name);
        	// 得到枚举下标
        	int index = c.ordinal();
        	System.out.println(index);
        }
 *  知道枚举的下标，得到枚举的对象和名称
    
        // 知道枚举的下标，得到枚举的对象和名称
        @Test
        public void test3() { 
        	int index = 2;
        	// 得到枚举的对象
        	Color[] c = Color.values();
        	// 根据下标得到对象
        	Color color = c[index];
        	// 得到枚举的名称
        	String name = color.name();
        	System.out.println(name);
        }

## 静态导入 ##

可以在代码里面，直接使用静态导入的方式，导入静态的方法或者常量。

import static XX.XX.xxx

**示例：**

import static java.lang.System.out;
    public class TestDemo01 { 
    	public static void main(String[] args) { 
    		out.println("hello world!");
    	}
    }

## 自动拆装箱 ##

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

public static void main(String[] args) { 
    	// 自动装箱
    	Integer i = 10;
    	// 自动拆箱
    	int m = i;
    }

**在jdk1.4中怎么实现拆装箱**

// 装箱
    Integer m = new Integer(10);
    // 拆箱
    int a = m.intValue();

*jdk是向下兼容的，在1.4里面写的代码。在5.0里面也是可以运行的。但是5.0里面写的代码，在1.4中不一定能运行。*

**问题：**  
在如下的代码中，输出的结果是什么？

public class TestDemo1 { 
    	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......");
    	}
    }

**结果**  
执行的结果是"double…"。  
会调用`dosomething(double m)`方法。在jdk1.4中肯定会调用这个方法，因为如果调用下面的方法，需要类型转换，但是jdk1.4中不能进行自动拆装箱。  
由于jdk是向下兼容的，所以在jdk1.4中调用这个方法，在jdk5.0中还是会调用这个方法。

## 增强for循环 ##

语法：`for （遍历出来的值：要遍历的集合）{}`  
数组以及实现了Iterable接口的类可以使用增强for循环。

在集合上使用增强for循环：  
List、Set实现了Iterator接口，所以可以使用增强for循环。  
Map没有实现，所以不可以使用。

**示例**

public class TestDemo1 { 
    	public static void main(String[] args) { 
    
    		List<String> list = new ArrayList<String>();
    		list.add("aaa");
    		list.add("bbb");
    
    		// 增强for循环
    		for (String string : list) { 
    			System.out.println(string);
    		}
    
    		System.out.println("------------------------");
    
    		// 使用迭代器实现
    		Iterator<String> it = list.iterator();
    		while (it.hasNext()) { 
    			System.out.println(it.next());
    		}
    	}
    }

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

### 泛型内容补充 ###

1.  泛型的擦除  
    首先泛型只是出现在源代码阶段，当编译之后泛型就不存在了。
2.  实现一个泛型方法，接受任意类型的数组，颠倒数组中所有元素。
    
        public static void main(String[] args) { 
        	Integer[] arr1 = {  10, 12, 13, 14, 20 };
        	System.out.println(Arrays.toString(arr1));
        	// 写方法实现
        	reverses(arr1);
        	System.out.println(Arrays.toString(arr1));
        }
        
        private static <T> void reverses(T[] arr1) { 
        	for (int i = 0; i < arr1.length / 2; i++) { 
        		T temp = arr1[i];
        		arr1[i] = arr1[arr1.length - i - 1];
        		arr1[arr1.length - i - 1] = temp;
        	}
        }

## 可变参数 ##

如果实现的多个方法，这些方法里面的逻辑基本相同，唯一不同的是传递的参数的个数，可以使用可变参数来实现。

**语法：**  
可变参数的定义方法，`数据类型...数组的名称`  
数组用于存储传递过来的参数。

**注意：**

1.  可变参数需要写在方法的参数列表中，不能单独定义。
2.  在方法的参数列表中只能有一个可变的参数。
3.  方法的参数列表中，可变参数必须写在最后

**示例：**  
用一个方法实现多个数的相加。

public static void main(String[] args) { 
    	add(1, 2);
    	add(1, 2, 3);
    	add(1, 2, 3, 4);
    }
    
    private static void add(int... nums) { 
    	// nums可以理解为一个数组，这个数组存储传递过来的参数
    	int sum = 0;
    	for (int i = 0; i < nums.length; i++) { 
    		sum += nums[i];
    	}
    	System.out.println(sum);
    }

--------------------

end.