创建集合的时候，集合后面的尖括号填一个泛型，那么这个泛型是必须存在的类吗？

Posted 2023-05-17

创建集合的时候，集合后面的尖括号填一个泛型，那么这个泛型是必须存在的类吗？同时，经常会在后面的小括号中写上这个泛型的class文件，这样到底代表什么意思呢?
例如在jdbc中经常会用到这样的一个方法
public User findUsernameAndPassowrd(String username, String password)
try
String sql= "select * from user where username = ? and password = ?";
return template.queryForObject(sql,new BeanPropertyRowMapper<User>(User.class),username,password);
catch (DataAccessException e)
return null;



那么这个User是一定要存在的吗？ 求大神解答，刚学编程，快被搞晕了

1. 设计泛型的初衷：

1) 主要是为了解决Java容器无法记忆元素类型的问题：

i. 由于Java设计之初并不知道会往容器中存放什么类型的元素，因此元素类型都设定为Object，这样就什么东西都能放了！

ii. 但是这样设计有明显的缺点：

a. 取出元素的时候必须进行强制类型转换（尽管集合在运行时里面元素的“运行时类型”不变，即元素的getClass返回的还是最初自己的类型而不是Object）；

b. 如果不小心往集合里加了不相同类型的元素可能会导致类型异常（进行equals、compare比较的时候尤为明显）；

c. 由于没有类型就需要在很多地方进行强制类型转换，但是这样做增加了编程的复杂度，并且代码也不美观（臃肿），维护起来也更加困难；

2) 泛型的概念定义：

i. 从Java 5开始，引入了参数化类型（Parameterized Type）的概念，改造了所有的Java集合，使之都实现泛型，允许程序在创建集合时就可以指定集合元素的类型，比如List<String>就表名这是一个只能存放String类型的List；

ii. 泛型（Generic）：就是指参数化类型，上面的List<String>就是参数化类型，因此就是泛型，而String就是该List<String>泛型的类型参数；追问

其实我现在最大的疑惑是填的这个泛型是必须存在的吗 例如是 List arr = new ArryList() 其中这个User类是已经创建好的吗（不管是我自己创建的还是java中本身就有的类）

参考技术A 有点赖皮，但符合要求 import java.util.Vector; class Conllection2 extends Vector @Override public boolean add(T element) System.out.println("say a word"); return super.add(element); public class TestF public static void main(String[] args) Conllection2 c=new Conllection2(); c.add(0); 追问

看不懂了 兄弟

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

泛型

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;
}