泛型定义:指在对象创建时不指定类中属性具体类型,而由外部在对象声明及实例化时指定具体类型。
作用:解决数据类型安全性问题,避免类转换异常(ClassCastException)。——原理:在类声明时通过标识符表示类中属性类型或方法返回值及参数类型。
定义格式:
泛型类的定义:
[修饰符] class 类名<标识符1,标识符2,…>{
[访问权限] 泛型标识符 变量名称;
[访问权限] 泛型标识符 方法名称(){};
[访问权限] 返回值类型声明 方法名称 方法名称(泛型类型标识 变量名称){};
}
泛型对象声明:
类名称<具体类> 对象名称=new 类名称<具体类>();
1、泛型的简单使用:
public class GenericsDemo01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Point<String> p=new Point<String>(); //外部觉得泛型类型
p.setName("张三"); //填写与泛型类型相同数据
p.print();
}
}
class Point<T>{ //泛型定义类
private T name; //属性类型由外部决定
public T getName() { //方法返回值类型由外部觉得
return name;
}
public void setName(T name) { //泛型定义方法参数类型
this.name = name;
}
public void print() {
System.out.println("姓名是:"+this.name);
}
}
<>标识符里面可以填写任何字母,常用T-type,K-key,E-Element。
泛型在指定中是无法指定基本数据类型,因此必须使用包装类。
2、泛型应用中的构造方法:
如果通过泛型指定类中的属性,又需要通过构造方法为属性赋值,就可以将泛型应用到构造方法中。
public class GenericsDemo01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Point<String> p=new Point<String>("李四"); //外部觉得泛型类型
p.print();
}
}
class Point<T>{ //泛型定义类
private T name; //属性类型由外部决定
public Point(T name) {
//this.name=name;
this.setName(name);
}
public T getName() { //方法返回值类型由外部觉得
return name;
}
public void setName(T name) { //泛型定义方法参数类型
this.name = name;
}
public void print() {
System.out.println("姓名是:"+this.name);
}
}
3、指定多个泛型类型
public class GenericsDemo01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Point<String,Integer> p=new Point<>("李四",18); //外部觉得泛型类型
p.print();
}
}
class Point<T,K>{ //泛型定义类
private T name; //属性类型由外部决定
private K age;
public Point(T name,K age) {
this.setName(name); //1种
this.age=age; //2种
}
public T getName() { //方法返回值类型由外部觉得
return name;
}
public void setName(T name) { //泛型定义方法参数类型
this.name = name;
}
public K getAge() {
return age;
}
public void setAge(K age) {
this.age = age;
}
public void print() {
System.out.println("姓名是:"+this.name+",年龄是:"+this.age);
}
}
4、泛型使用的安全警告:
在泛型应用中,最好在声明类对象时指定好内部数据类型,否则会提示警告信息,但也不会报错。
public class GenericsDemo01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Point p=new Point("李四"); //外部觉得泛型类型
p.print();
}
}
class Point<T>{ //泛型定义类
private T name; //属性类型由外部决定
public Point(T name) {
this.setName(name);
}
public T getName() { //方法返回值类型由外部觉得
return name;
}
public void setName(T name) { //泛型定义方法参数类型
this.name = name;
}
public void print() {
System.out.println("姓名是:"+this.name);
}
}
警告信息:
Multiple markers at this line
- Point is a raw type. References to generic type Point<T> should be parameterized
- Type safety: The constructor Point(Object) belongs to the raw type Point. References to
generic type Point<T> should be parameterized
- Point is a raw type. References to generic type Point<T> should be parameterized
在使用类时没指定泛型类型,程序在编译时并未报错,是因为所有的类型全部用Object接受了。
上面代码相当于这样了:
Point<Object> p=new Point<Object>();
5、通配符:
在泛型类的操作中,进行对象的引用传递时,泛型类型必须匹配。
即使使用Object接收指定了泛型的对象,这样也是错误的——>
public class GenericsDemo01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Point<String> p=new Point<>();
p.setName("张三");
fun(p); //错误,无法传递
}
static void fun(Point<Object> name) {
System.out.println("姓名是:"+name);
}
}
class Point<T>{ //泛型定义类
private T name; //属性类型由外部决定
public T getName() {
return name;
}
public void setName(T name) {
this.name = name;
}
public String toString() {
return this.name.toString();
}
}
通配符“?”,可以接收此类型的任何泛型对象。
public class GenericsDemo01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Point<String> p=new Point<>();
p.setName("张三");
fun(p); //正确了,可以传递
}
static void fun(Point<?> name) {
System.out.println("姓名是:"+name);
}
}
如果通配符用在泛型指定的地方,也是错的。
public class GenericsDemo01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Point<?> p=new Point<>();
p.setName("张三");
fun(p); //正确了,可以传递
}
static void fun(Point<?> name) {
System.out.println("姓名是:"+name);
}
}
错误信息:
The method setName(capture#1-of ?) in the type Point<capture#1-of ?> is not applicable for the
arguments (String)
6、泛型的上限与下限:
范围的下限:使用super关键字进行声明,表示泛型的类型可以是指定的类型或此类型的父类,或是Object类。
范围的上限:使用extends关键字进行声明,表示泛型的类型可以是指定的类型或此类型的子类。
格式:
声明对象:对象名称<? extends/super 类> 对象名称
定义类:[访问权限] 类名称<泛型标识 extends 类>{};
public class GenericsDemo02 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Info<Integer> info=new Info<>(16);
Person<String> per=new Person<>("张三");
//声明对象时进行泛型的下限
Person<? super String> per2=new Person("李四");
info.print();
Person.print(per); //对象的引用传递
Person.print(per2);
}
}
class Info<T extends Number>{ //对类进行泛型的上限
private T age;
public Info(T age) {
this.age=age;
}
public T getAge() {
return age;
}
public void setAge(T age) {
this.age = age;
}
public void print() {
System.out.println("年龄为:"+this.age);
}
}
class Person<T>{
private T name;
public Person(T name) {
this.name=name;
}
public T getName() {
return name;
}
public void setName(T name) {
this.name = name;
}
public String toString() {
return this.name.toString();
}
//对对象进行泛型下限操作
public static void print(Person<? super String> temp) {
System.out.println("姓名是:"+temp);
}
}
7、泛型与子类继承的限制
在泛型操作中,子类的泛型类型是无法用父类的泛型接收——如果这样做,会扩大子类的内容
//这样是错的
Info<String> info1=new Info<>();
Info<Object> info2=info1;
8、泛型接口
定义格式:
[访问权限] interface 接口名称<泛型标识>{}
泛型接口实现的两种方式:
1、在子类的定义上声明泛型类型
public class GenericsDemo03 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Inter<String> info=new Infor<>("张三");
info.print();
}
}
interface Inter<T>{
public abstract void print();
}
class Infor<T> implements Inter<T>{
private T name;
public Infor(T name) {
this.setName(name);
}
public T getName() {
return name;
}
public void setName(T name) {
this.name = name;
}
public void print() {
System.out.println("姓名是:"+this.getName());
}
}
2、直接在子类实现的接口中给出泛型类型
public class GenericsDemo03 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Inter<String> info=new Infor<>("张三");
info.print();
}
}
interface Inter<T>{
public abstract void print();
}
class Infor<String> implements Inter<String>{
private String name;
public Infor(String name) {
this.setName(name);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void print() {
System.out.println("姓名是:"+this.getName());
}
}
9、泛型方法
格式:
[访问权限] <泛型标识> 泛型标识 方法名称(泛型标识 参数名称){}
1、通过泛型方法返回泛型类的实例化对象。
public class GenericsDemo04 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//传递整数到fun()
//Information<Integer> info=fun(30);
Information<Integer> info=new Information<>();
info=fun(30);
System.out.println(info.getInfo());
}
//被main()调用,需static修饰
//<T extends Number>表示方法传入或返回的数据类型由外部决定
static <T extends Number> Information<T> fun(T num) {
//根据传入的数据,实例化Information对象
Information<T> info=new Information<>();
//将传入的数据设置到Information的info属性之中
info.setInfo(num);
//返回实例化对象
return info;
}
}
//使用泛型下限的方式限制Information只能接收数字类型
class Information<T extends Number>{
private T info; //属性类型又外部决定
public T getInfo() {
return info;
}
public void setInfo(T info) {
this.info = info;
}
//覆写toString()
public String toString() {
return this.info.toString();
}
}
2、使用泛型统一传入的类型
public class GenericsDemo05 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Info<String> info1=new Info<>();
Info<String> info2=new Info<>();
info1.setInfo("四川");
info2.setInfo("熊猫");
add(info1,info2);
}
static <T> void add(Info<T> num1, Info<T> num2) {
System.out.println(num1.getInfo()+"有:"+num2.getInfo());
}
}
class Info<T>{
private T info;
public T getInfo() {
return info;
}
public void setInfo(T info) {
this.info = info;
}
public String toString() {
return this.info.toString();
}
}
10、泛型数组
使用泛型时,也可以传递或返回一个泛型数组。
public class GenericsDemo06 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Integer[] i=fun1(1,2,3,4,5,6);
fun2(i);
}
//返回泛型数组的方法
static <T> T[] fun1(T...arg) { //接收可变参数,返回泛型数组
return arg;
}
//接收泛型数组并遍历数组的方法
static <T> void fun2(T num[]) {
System.out.print("接收泛型数组:");
for (T n : num) {
System.out.print(n+"、");
}
}
}