【从零开始的Java开发】1-6-2 泛型：概述、泛型作为方法参数、自定义泛型、自定义泛型方法

最新推荐文章于 2023-01-15 22:44:57 发布

karshey

最新推荐文章于 2023-01-15 22:44:57 发布

阅读量440

点赞数

分类专栏：从零开始的Java开发文章标签： java 开发语言 jvm

本文链接：https://blog.csdn.net/karshey/article/details/126227068

版权

从零开始的Java开发专栏收录该内容

31 篇文章 4 订阅

订阅专栏

文章目录

泛型概述

为什么要有泛型
在Java增加泛型之前，泛型程序设计使用继承来实现。

坏处：

需要强制转换
可向集合中添加任意类型的对象，存在风险

泛型的使用：如，在尖括号里，限制在list中只能添加String内容
List<String>list=new ArrayList<String>();

Java SE7及以后的版本中，构造方法中可以省略泛型类型。即：List<String>list=new ArrayList<>();

多态与泛型
变量声明的类型必须匹配传递给实际对象的类型，即前后尖括号内的要一致，如下例是错的：

class Aniaml{}
class Cat extends Animal{}
List<Animal>list=new ArrayList<Cat>();

下例也是错的：

List<Object>list=new ArrayList<String>();
List<Number>numbers=new ArrayList<Integer>();

泛型作为方法参数

案例：

定义一个抽象类Goods，包含抽象方法sell()
分别定义类Book，Clothes，Shoes继承Goods，并实现sell()，输出一句话
定义一个商品销售类GoodsSeller，模拟销售，包括方法public void sellGoods(List<Goods>goods)，循环调用List对象的sell方法
测试

Goods类：

public abstract class Goods {
	public abstract void sell();
}

Book类：

public class Book extends Goods {

	@Override
	public void sell() {
		System.out.println("Book sell");
	}

}

Clothes类：

public class Clothes extends Goods {

	@Override
	public void sell() {
		System.out.println("Clothes sell");

	}

}

Shoes类：

public class Shoes extends Goods {
	@Override
	public void sell() {
		System.out.println("Shoes sell");
	}
}

GoodsSeller类：

public class GoodsSeller {
	// 参数是Goods或其子类都可以
	public void sellGoods(List<? extends Goods> goods) {
		// 调用集合中的sell方法
		for (Goods g : goods) {
			g.sell();
		}
	}

}

测试类：

public class GoodsTest {

	public static void main(String[] args) {

		// 定义Book相关的List:参数类型一定要一致，不然会报错
		List<Book> book = new ArrayList<Book>();
		book.add(new Book());
		book.add(new Book());

		// 定义Clothes相关的List
		List<Clothes> clothes = new ArrayList<Clothes>();
		clothes.add(new Clothes());
		clothes.add(new Clothes());

		// 定义Shoes相关的List
		List<Shoes> shoes = new ArrayList<Shoes>();
		shoes.add(new Shoes());
		shoes.add(new Shoes());

		GoodsSeller goodsSeller = new GoodsSeller();
		goodsSeller.sellGoods(book);
		goodsSeller.sellGoods(clothes);
		goodsSeller.sellGoods(shoes);
	}

}

输出：

Book sell
Book sell
Clothes sell
Clothes sell
Shoes sell
Shoes sell

注意：public void sellGoods(List<? extends Goods> goods)表示参数是Goods或其子类都可以。

自定义泛型

一个参数

举个例子：

//自定义泛型类
public class NumGeneric<T> {
	private T num;

	public T getNum() {
		return num;
	}

	public void setNum(T num) {
		this.num = num;
	}

	// 测试
	public static void main(String[] args) {
		NumGeneric<Integer> intNum = new NumGeneric<>();
		intNum.setNum(100);
		System.out.println(intNum.getNum());

		NumGeneric<Float> floatNum = new NumGeneric<>();
		floatNum.setNum(10.2f);
		System.out.println(floatNum.getNum());
	}
}

输出：

100
10.2

两个参数

public class TwoNumGeneric<T, X> {
	private T num1;
	private X num2;

	public void setNum(T num1, X num2) {
		this.num1 = num1;
		this.num2 = num2;
	}

	public T getNum1() {
		return num1;
	}

	public X getNum2() {
		return num2;
	}

	public void setNum1(T num1) {
		this.num1 = num1;
	}

	public void setNum2(X num2) {
		this.num2 = num2;
	}

	// 测试
	public static void main(String[] args) {
		TwoNumGeneric<Integer, Double> num = new TwoNumGeneric<>();
		num.setNum(1, 20.0);
		System.out.println(num.getNum1() + " " + num.getNum2());

	}
}

输出：1 20.0

跟上一个差不多。

自定义泛型方法

泛型方法不一定要写到泛型类中

类似C++的模板：

public class GenericMethod {
	public <T> void printValue(T t) {
		System.out.println(t);
	}

	public static void main(String[] agrs) {
		GenericMethod gm = new GenericMethod();
		gm.printValue("hello,world!");
		gm.printValue(123);
		gm.printValue(12.34);
	}
}

输出：

hello,world!
123
12.34

如果只想要Number和它的子类：

public class GenericMethod {
	public <T extends Number> void printValue(T t) {
		System.out.println(t);
	}

	public static void main(String[] agrs) {
		GenericMethod gm = new GenericMethod();
		gm.printValue(123);
		gm.printValue(12.34);
	}
}