泛型使用
1.在类名后面 <泛型名>
2.在类中直接使用 泛型名 来定义变量类型
3.在新建对象的时候,泛型名变成一个具体的类型
package top.itcourse.genericity;
/*
* 1.在类名后面 <泛型名>
* 2.在类中直接使用 泛型名 来定义变量类型
* 3.在新建对象的时候,泛型名变成一个具体的类型
*/
public class Genericity<AnyType> {
private AnyType storedValue;
public AnyType read() {
return storedValue;
}
public void write(AnyType x) {
storedValue = x;
}
public static void main(String[] args) {
// 新建对象的时候,泛型名 被具体化
Genericity<String> genericity = new Genericity<>();
genericity.write("JavaWeb架构师");
System.out.println(genericity.read());
}
}
结果是:
JavaWeb架构师
自动拆箱装箱
基本数据类型和它们的包装类之间可以直接的相互赋值,这就是自动拆箱装箱。
package top.itcourse.genericity;
public class Genericity<AnyType> {
private AnyType storedValue;
public AnyType read() {
return storedValue;
}
public void write(AnyType x) {
storedValue = x;
}
public static void main(String[] args) {
// 泛型具体化的时候使用的是包装类
Genericity<Integer> genericity = new Genericity<>();
// 在传递参数的时候,直接传int这种基本数据类型(自动装箱)
genericity.write(56);
// 自动拆箱
int read = genericity.read();
System.out.println(read);
}
}
结果是:
56
通配符
对集合中元素进行互转的限制:? extends Father,表示Father及其子类可以使用。
package top.itcourse.genericity;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
public class Genericity<AnyType> {
// 1.Collection<? extends Shape>:表示这个Collection集合可以是Shape及其子类
public static int totalArea(Collection<? extends Shape> shapes) {
int totalArea = 0;
for (Shape shape : shapes) {
totalArea += shape.getArea();
}
return totalArea;
}
public static void main(String[] args) {
// 2.传Collection<Circle extends Shape>
System.out.println(totalArea(Arrays.asList(new Circle[]{new Circle(),new Circle(),new Circle()})));
// 3.传Collection<Square extends Shape>
System.out.println(totalArea(Arrays.asList(new Square[]{new Square(),new Square(),new Square()})));
}
}
class Shape {
public int getArea() {
return 1;
}
}
class Square extends Shape {
public int getArea() {
return 2;
}
}
class Circle extends Shape {
public int getArea() {
return 3;
}
}
结果:
9
6
泛型方法
为什么使用泛型方法:
1. 该特定类型用做返回类型;
2. 该类型用在多于一个的参数类型中;
3. 该类型用于声明一个局部变量。
package top.itcourse.generivity;
public class TestGenerivityMethod {
/*
* 泛型方法:
* 修饰符 <T> 返回类型 方法名(形参){ 局部变量; }
*
* 1.该特定类型用做返回类型;
* 2.该类型用在多于一个的参数类型中;
* 3.该类型用于声明一个局部变量。
*/
/**
*
* @Title: indexAnyNums
* @Description: 查询target在anyNums中的位置,不存在返回-1
* @param @param anyNums:数据源数组
* @param @param target:目标对象
* @param @return 返回目标对象在数据源数组中的位置
*/
public static <AnyNum> int indexAnyNums(AnyNum[] anyNums,AnyNum target) {
for (int i = 0; i < anyNums.length; i++) {
if (target.equals(anyNums[i])) {
return i;
}
}
return -1;
}
public static void main(String[] args) {
int indexAnyNums = indexAnyNums(new String[] {"PHP" ,"Java","C++"},"Java");
System.out.println(indexAnyNums);
}
}
结果是:
1
类型界限
当我们对泛型对象使用一些特定类才有的操作时,编译是不会被通过的。这时候我们可以使用泛型界限来解决这个问题。
public class TestGenerivityBounds {
/*
* 在指定泛型的时候,说明这个泛型将会从什么类过来(如过这个类还有泛型,就一直指定下去),
* 在后面使用这个泛型对象的时候,就可以直接调用相关的方法。
*
* <AnyNum extends Shape>:这个泛型的父类是Shape(如果Shape也有泛型的话,可以继续指定下去)
*/
public static <AnyNum extends Shape> int getArea(AnyNum anyNum) {
// 就可以调用这个泛型的 getArea方法了
return anyNum.getArea();
}
public static void main(String[] args) {
System.out.println(getArea(new Square()));
}
}
interface Shape {
public int getArea();
}
class Circle implements Shape {
@Override
public int getArea() {
return 1;
}
}
class Square implements Shape {
@Override
public int getArea() {
return 2;
}
}
结果是:
2
类型擦除
编译器生成的bytecode是不包涵泛型信息的,泛型类型信息将在编译处理时被擦除,这个过程即类型擦除。类型变量由类型界限来代替。
记住:
1.虚拟机中没有泛型,只有普通类和普通方法
2.所有泛型类的类型参数在编译时都会被擦除
3.创建泛型对象时请指明类型,让编译器尽早的做参数检查(Effective Java,第23条:请不要在新代码中使用原生态类型)
4.不要忽略编译器的警告信息,那意味着潜在的ClassCastException等着你。
限制:
1. 基本类型不能做类型参数。
2. instanceof检测:只对原始类型转换工作进行检测。不同的泛型参数之间可以相互强制转换[通过object](因为泛型擦除),通过编译,但是运行的时候会出现类型转换异常。
3. 因为类型擦除,实际上只有一个原始类,所以不同的类型参数的对象之间的静态部分是共享的
4. 不能创建泛型对象、数组(根据泛型参数创建类型变量)。如:T t = new T();T[] t = new T[10];
public class TestTypeErasure<T> {
public static void main(String[] args) {
// 1. 基本类型不能做类型参数。
// Test<int> test1 = new Test<>();
// 2. instanceof检测:只对原始类型转换工作进行检测。不同的泛型参数之间可以相互强制转换[通过object](因为泛型擦除),通过编译,但是运行的时候会出现类型转换异常。
Test<Integer> test2 = new Test();
test2.write(12);
Object object = test2;
Test<String> test3 = (Test<String>)object;
// java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
String read = test3.read();
System.out.println(read);
//3. 因为类型擦除,实际上只有一个原始类,所以不同的类型参数的对象之间的静态部分是共享的
test2.setStr("灰灰");
System.out.println(new Test().getStr()); //灰灰
}
}
class Test<AnyType> {
// 静态部分
private static String str;
public static String getStr() {
return str;
}
public static void setStr(String string) {
str = string;
}
//4. 不能创建泛型对象、数组(根据泛型参数创建类型变量)。如:T t = new T();T[] t = new T[10];
// AnyType anyType2 = new AnyType();
// AnyType[] anyTypes = new AnyType[10];
private AnyType anyType;
public AnyType read() {
return anyType;
}
public void write(AnyType anyType) {
this.anyType = anyType;
}
}
结果:
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
灰灰
函数对象
当我需要使用特定的方法去完成不同的功能时,我们可以创建一个类,这个类中有一个方法,然后把这个类的对象传递进去。这个类的实例就是函数对象。
public class TestFuncClass {
/*
* 2. 把函数对象传进去,调用相关的方法
*/
public static int choose(int a, int b,MaxMin<Integer> mm) {
return mm.compare(a, b);
}
public static void main(String[] args) {
/*
* 3. 具体调用的时候,去具体实现这个函数对象中的方法
*/
int max = choose(10, 20, (a, b) ->
a > b ? a : b);
System.out.println("max: " + max);
int min = choose(10, 20, (a, b) ->
a>b?b:a);
System.out.println("min: " + min);
}
}
/*
* 1. 定义函数对象: 使用泛型、接口
*/
interface MaxMin<AnyType> {
public int compare(AnyType a, AnyType b);
}
结果:
max:20
min:10
其它
关注下方微信公众号,
回复:
DS-AA-Java.code
欢迎加入交流群:451826376
更多信息:www.itcourse.top