javaAPI_集合基础_泛型以及JDK5部分特性

Posted 2021-01-31 德墨特尔

泛型

1.泛型的引入以及概述
(1).概述:
我们知道集合也是一种存储数据的工具，之前我们学习过StringBuffer和数组，这俩种在存储数据的时候都是明确了要存储什么类型的数据，如果
存储的数据类型和定义要存储的数据不一致的时候就会报错。那么集合为了数据存储的一致性，也提供了类似的机制，那么就是在创建集合对象
的时候要明确需要存储的数据类型是什么，这一个机制就叫做泛型。

(2).泛型定义:把类型明确的工作推迟到创建对象或者是调用方法的时候才去明确的特殊类型。参数化类型，把类型当做参数一样进行传递。

(3).格式:
<数据类型>
注意:数据类型只能够使引用类型。

(4).泛型的好处
A:把运行时间的错误提前到了编译期间(防止存储不同的数据类型在一个集合中)
B:避免了强制类型转化
C:优化了程序，解决了警告。
D:解决了部分安全问题

 

2.泛型的应用

(1).泛型类
A:什么是泛型类
所谓的泛型类是指把泛型定义在类上。
B:泛型类格式
public class 类名<泛型类型1.....>

C:注意事项:
泛型类型必须是引用类型

D:泛型类基本使用测试代码

//泛型类定义
public class ObjectTool<T> {

private T obj;

public T getObj() {
return obj;
}

public void setObj(T obj) {
this.obj = obj;
}
}

//使用测试
public static void main(String[] args) {
ObjectTool<String> ot = new ObjectTool<String>();

ot.setObj(new String("张三"));
String s = ot.getObj();
System.out.println(s);

System.out.println("------------");

ObjectTool<Integer> ot1 = new ObjectTool<Integer>();
ot1.setObj(new Integer(12));
Integer age = ot1.getObj();
System.out.println(age);
}

//由此可见泛型类的定义可以解决存储不同参数的问题。便于代码的复用，但是会加强代码之间的耦合。

(2).泛型方法
A:概述
所谓的泛型方法，就是把方法定义在泛型上。

B:格式
public <泛型类型> 返回类型 方法名(泛型类型...)

C:泛型方法基本使用

//泛型方法定义
public class ObjectTool {

public <T> void show(T t){
System.out.println("内容是:"+t);
}
}
//使用测试
public static void main(String[] args) {
ObjectTool ot = new ObjectTool();
ot.show("你好");
ot.show(12);
ot.show(true);
}

//由此可见泛型方法的好处是可以往参数里面传递不同的参数进去。


(3).泛型接口
A:概述
所谓的泛型接口就是把泛型定义在接口上。

B:格式
public interface 接口名<T>{}

C:代码测试

//定义泛型接口
public interface Inter<T> {
public abstract void show(T t);
}

//定义接口实现类
public class InterImpl <T> implements Inter<T>{
@Override
public void show(T t) {
System.out.println("impl show:"+t);
}
}

//定义泛型测试类
public static void main(String[] args) {
Inter<String> it = new InterImpl<String>();
it.show("年后");
Inter<Integer> lt1 = new InterImpl<Integer>();
lt1.show(12);
}

(4).泛型通配符
A：泛型通配符<?>
表示的是任意的类型，如果没有明确，那么就是Object以及其任意的java类
B: ? extends E
向下限定，E以及其子类
C: ? super E
向上限定，E以及其父类

//代码测试:
public static void main(String[] args) {
//测试？：表示可以匹配任意类型的数据
Collection<?> ct = new ArrayList<Animal>();
Collection<?> ct1 = new ArrayList<dog>();
Collection<?> ct2 = new ArrayList<cat>();
//测试 ? extends E
Collection<? extends Animal> ct3 = new ArrayList<Animal>();
Collection<? extends Animal> ct4 = new ArrayList<dog>();
Collection<? extends Animal> ct5 = new ArrayList<cat>();
//测试? super E
Collection<? super Animal> ct6 = new ArrayList<Animal>();
Collection<? super Animal> ct7 = new ArrayList<Object>();

}

//动物类
class Animal{}
//狗类
class dog extends Animal{}
//猫类
class cat extends Animal{}

3.JDK5新特性

(1).增强for
A:概述
所谓的增强for,其实就是for循环的一种，简化数组和Collection集合的遍历。

B:格式
for(元素数据类型 变量:数组或者是Collection集合){
使用变量即可，该变量就是元素
}

C:增强for的好处
简化遍历

D:增强for使用注意事项
增强for在使用之前需要判断目标是否为null;
增强for实质就是用来替代迭代器的。

E:增强for代码测试
public static void main(String[] args) {
List<String> lt = new ArrayList<String>();
lt.add("hello");
lt.add("world");
lt.add("java");
//普通for循环
for(int i = 0; i<lt.size();i++){
System.out.println(lt.get(i));
}

System.out.println("----------");

for(String str:lt){
System.out.println(str);
}
}

(2).静态导入
A:静态导入概述
所谓的静态导入就是可以通过导入，直接可以导入到方法级别。

B:格式
import static 包名....类名.方法名。
注意事项：这里面的导入直接是导入到了方法这一个级别

C:静态导入的注意事项:
a:该方法必须是静态的(因为我们在使用的时候直接需要通过方法名来实现该方法的功能)
b:如果有多个同名的静方法，就很容易不知道使用的是谁的，所以在使用的时候，必须需要添加前缀。由此可见意义不大。

D：静态导入测试
import static java.lang.Math.abs;
import static java.lang.Math.max;

public class InterDemo {
public static void main(String[] args) {
System.out.println(abs(-10));
System.out.println(max(1,2));
}
}

//注意:导入的级别是方法级别，同时这一个方法还是静态的。

(3).可变参数[*****]

A:概述
方法在定义的时候不知道有多少个参数。

B:格式
修饰符 返回值类型 方法名(数据类型... 变量名){}

C:注意事项
a:可变参数中的参数其实是一个数组。
b:如果说一个方法有可变参数，并且有多个参数，那么可变参数肯定是最后一个。(也就是说可变参数后面不允许还有参数)

D:代码测试
public static void main(String[] args) {
int result = sum(12,12,13,14);
System.out.println(result);
}

public static int sum(int... a){
int returnValue = 0;

//可见是一个数组
for(int x:a){
returnValue += x;
}

return returnValue;
}