什么是泛型？Java基础之泛型详细知识点总结
Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参，对于参数化类型的理解：
顾名思义：就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型
这种参数类型可以用在类，方法和接口中，分别被称为泛型类，分型方法，泛型接口。
假定我们有这样一个需求：写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？
答案是可以使用 Java 泛型。
使用 Java 泛型的概念，我们可以写一个泛型方法来对一个对象数组排序。然后，调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序。
- <类型>：指定一种类型格式。这里的类型可以是形参
- <类型1，类型2…>：指定多种类型的格式，多种类型之间的用逗号隔开。这里的类型可以看成是形参
- 将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型
要求：collection集合存储字符串并遍历
import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; //要求： public class Demo { public static void main(String[] args) { //创建集合对象 //Collection c = new ArrayList();//先不使用泛型 //使用泛型 Collection<String> c = new ArrayList<String>(); //添加元素： c.add("hello");//向上转型 c.add("world"); c.add("java"); //c.add(100);//自动封装为Integer类型，使用泛型可以将编译器出现的问题提前 //遍历集合（迭代器） //Iterator t = c.iterator(); Iterator<String> t = c.iterator();//使用泛型不需要强制转换 while(t.hasNext()) { //Object obj = t.next(); //String obj = (String)t.next();//向下转型，变为String类型 String s = t.next(); // ClassCastException System.out.println(s); } } }
在未指定集合中元素类型的时候，默认是Object类型，因为泛型默认是引用类型，而Object可以代表所有的引用类型
因为添加的时候是Object类型，所以获取也是
泛型的好处：
- 把运行时期的问题提前到了编译时期
- 避免了强制类型转换
- E - Element (在集合中使用，因为集合中存放的是元素)
- T - Type（Java 类）
- K - Key（键）
- V - Value（值）
- N - Number（数值类型）
- ？ - 表示不确定的 java 类型
概述：
泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。
和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。
- 格式：修饰符class类名< 类型>{ }
- 范例：public class Generic< T> { }
此处T可以随便写为任意标识符，常见的如T，E，K，V等形式的参数常用与表示泛型
public class Generic <T>{ private T t; public T getT() { return t; } public void setT(T t) { this.t = t; } public static void main(String[] args) { Generic<String> g = new Generic<String>(); g.setT("张三"); System.out.println(g.getT()); Generic<Integer> g1 = new Generic<Integer>(); g1.setT(20); System.out.println(g1.getT()); } }
控制台输出：张三 20
- 格式：修饰符< 类型> 返回值类型 方法名(类型 变量名){ }
- 范例：public < T> void show(T t){ }
package com.ithmm_06; public class Generic <T> { // public void show(Integer i){ // System.out.println(i); // } // public void show(Double d){ // System.out.println(d); // } //使用泛型改进方法 // public void show(T t){ // System.out.println(t); // } //使用泛型方法改进 public <T> void show(T t){ System.out.println(t); } public static void main(String[] args){ // Generic t = new Generic(); // t.show("hello"); // t.show(1); // t.show(2.0); //t.show(true);//报错没有boolean类型方法 //使用泛型创建对象 // Generic<String> g1 = new Generic<String>(); // g1.show("hello"); // // Generic<Integer> g2 = new Generic<Integer>(); // g2.show(1); // // Generic<Double> g3 = new Generic<Double>(); // g3.show(2.0); Generic g = new Generic(); g.show("hello"); g.show(1); g.show(2.0); } }
控制台输出：hello 1 2.0
- 格式：修饰符 interface 接口名 < 类型>{ }
- 范例：public interface Generic< T> { }
package com.ithmm_07; public class Generic { public static void main(String[] args) { //测试类 GenericFace<String> g = new GenericImpl<String>(); g.show("Hello"); GenericFace<Integer> g2 = new GenericImpl<Integer>(); g2.show(100); } } interface GenericFace <T> { void show(T t); } class GenericImpl <T> implements GenericFace<T> { @Override public void show(T t) { System.out.println(t); } }
控制台输出：hello 100
为了表示各种泛型List的父类，可以使用类型通配符
- 类型通配符：<?>
- List<?>:表示元素类型未知的List，他的元素可以匹配任何的类型
- 这种带通配符的List仅仅表示它是个=各种泛型List的父类，并不能把元素添加到其中
如果我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限
- 类型通配符的上限：<?extends 类型>
- List<? extends Number>:它表示类型是Number或者其子类型
除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限
- 类型通配符：<?Super 类型>
package com.ithmm_07; import java.util.ArrayList; import java.util.List; public class GenericDemo { public static void main(String[] args) { //类型通配符 List<?> kist1 = new ArrayList<Object>(); List<?> kist2 = new ArrayList<Number>(); List<?> kist3 = new ArrayList<String>(); System.out.println("-------------------"); //类型通配符的上限 // List<? extends Number> lis = new ArrayList<Object>();//报错 List<?extends Number> list5 = new ArrayList<Integer>(); List<?extends String> list6 = new ArrayList<String>(); //类型通配符下限<? super 类型> List <? super Number> list7 = new ArrayList<Object>(); List <?super Number> list8 = new ArrayList<Number>(); // List<? super Number> list9 = new ArrayList<Integer>();报错 } }
注意：
可变参数又称个数可变，用作方法的形参出现，那么方法参数个数就是可变的
可变参数只能作为函数的最后一个参数，但其前面可以有也可以没有任何其他参数
由于可变参数必须是最后一个参数，所以一个函数最多只能有一个可变参数
Java的可变参数，会被编译器转型为一个数组
变长参数在编译为字节码后，在方法签名中就是以数组形态出现的。这两个方法的签名是一致的，不能作为方法的重载。如果同时出现，是不能编译通过的。可变参数可以兼容数组，反之则不成立
- 格式：修饰符 返回值类型 方法名 (数据类型…变量名){ }
- 范例：public static int sum (int …a){ }
可变参数注意事项
- 这里的可变参数是一个数组
- 如果一个方法有多个参数，包含可变参数，可变参数要放在最后面
package com.ithmm_07; public class ArgDemo01 { public static void main(String[] args) { System.out.println(sum(10,20,2,0,5,5)); System.out.println(sum(10,20)); System.out.println(sum(2,5,4,8,8,5,5,5)); } public static int sum(int ... a){ int sum =0; for(int i: a){ sum += i; } return sum; } }
查看3道真题和解析
投递奇安信等公司9个岗位