目录
1.java泛型
Java泛型是一种编程语言特性，它可以让程序员在编写代码时不指定数据类型，而是允许类型在运行时动态确定。使用泛型可以提高代码的重用性、可读性和类型安全性。
Java泛型的特点：
- 可以在编译时检查类型的安全性。
- 可以减少类型转换的代码量。
- 可以让程序员编写更加通用的代码，减少代码的重复。
- 可以提高代码的可读性和可维护性。
在Java中，泛型是通过使用尖括号（<>）来指定类型，例如：
List<String> list = new ArrayList<>();
这个例子创建了一个List对象，其中元素类型为String。泛型可以用在类、接口、方法中，例如：
public class MyClass<T> {
private T myField;
public T getMyField() {
return myField;
}
public void setMyField(T myField) {
this.myField = myField;
}
}
// 使用泛型的方法
public <T> void myMethod(T t) {
// do something
}
在上面的例子中，MyClass是一个泛型类，它的类型参数为T，而myMethod是一个泛型方法，它的类型参数也为T。这些类型参数可以在实例化或调用方法时动态指定。
2. 正文
1. 什么是泛型? 2. 为什么使用泛型? 3. 如何使用泛型? 4. 泛型通配符?
3. 什么是泛型?
List<E>：这里的<E>就是泛型标志，Map<K,V>这里<K,V>也是泛型标记。
泛型:就是类再定义时无法确认类中成员的类型(属性，方法)，而是类再创建时指定具体的数据类型。
4. 为什么使用泛型
例子: 定义一个Point 点类，要求如下
它的坐标值可以是整数。x=15,y=25
它的坐标值也可以都是小数: x=15.5 y=25.5
它的坐标值也可以都是字符串类型: x="北纬15度" y="东经258度"
package demo01;
public class Point {
private Object x;
private Object y;//因为Object是所有类的父类，而且多态，子类类型可以自动向父类类型转化。
public Point(Object x, Object y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return "Point{" +
"x=" + x +
", y=" + y +
'}';
}
public Object getX() {
return x;
}
public void setX(Object x) {
this.x = x;
}
public Object getY() {
return y;
}
public void setY(Object y) {
this.y = y;
}
}
package demo01;
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
//整型坐标
Point p1=new Point(25,36);
//小数类型
Point p2=new Point(25.5,36.6);
//字符串类型
Point p3=new Point("北纬25度","东经36度");
//字符串和整型
Point p4=new Point("北纬36度",15);
String x = (String) p4.getX();
//java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
//如果使用Object定义类中属性类型，那么可能再后期会出现数据类型安全问题。
String y = (String) p4.getY();
}
}
上面使用Object接受任意参数，可能会出现数据类型安全问题。如何解决上述问题，由于我们无法再类定义时确定类中成员的数据类型，所以我们可以使用泛型来解决数据类型安全问题。
5. 如何使用泛型
泛型可以解决数据类型的安全性问题，其主要原理是在类声明时通过一个==标识==表示类中某个属性的数据类型或者是某个方法的返回值及参数类型。这样在类声明或者实例化时只要指定好需要的类型即可。
语法:
public class 类名<T,E,B>{ private T a; public T getA(){} public void setA(T t){} }
使用泛型来解决Point类的安全问题
package demo02;
//T可以是任意的名称： T英文Type
public class Point<T> {
private T x;
private T y;//因为Object是所有类的父类，而且多态，子类类型可以自动向父类类型转化。
public Point(T x, T y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return "Point{" +
"x=" + x +
", y=" + y +
'}';
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
}
package demo02;
import java.util.ArrayList;
import java.util.List;
/**
* @program: qy165-Fanxing-Annotation
* @description:
* @author: 闫克起2
* @create: 2023-06-06 08:58
**/
public class Test {
public static void main(String[] args) {
Point<Integer> p1=new Point<>(15,25);
Point<Double> p2=new Point<>(25.5,36.6);
Point<String> p3=new Point<>("东经150度","北纬36度");
String x = p3.getX();
Integer x1 = p1.getX();//不会出现数据类型安全问题。
// 注意: 泛型的类型必须指定为引用类型，不能使用基本类型【byte short int long float double boolean char】。--->包装类：Byte Short ...Integer .......Character
//我们我们在创建泛型类对象时没有指定泛型：--它就是Object类型
}
}
6.泛型通配符
在开发中==对象的引用传递==是最常见的，但是如果在泛型类的操作中，在进行引用传递时泛型类型必须匹配才可以传递，否则是无法传递的。
对象的引用传递和值传递。
package demo04;
public class Test04 {
public static void main(String[] args) {
Info<Integer> a=new Info<>(15);
Info<String> b=new Info<>("Hello");
fun(a);
fun(b);//泛型的引用传递，要求数据类型匹配而且泛型也要匹配。
}
//任意的泛型都可以传递过来。 使用泛型通配符。?
public static void fun(Info<?> info){
info.show();
}
}
class Info<T>{
private T var;
public Info(T var) {
this.var = var;
}
public void show(){
System.out.println("var==============="+var);
}
public T getVar() {
return var;
}
public void setVar(T var) {
this.var = var;
}
}
7. 泛型的限制
在引用传递中，在泛型操作中也可以设置一个泛型对象的==范围上限==和==范围下限==。范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型或者是此类型的子类，而范围下限使用super进行声明，表示参数化的类型可能是所指定的类型或者此类型的父类型。
语法:
public void 方法名(Info<? extends Number> info){ //传递参数的泛型必须是Number或者Number的子类 }
public void 方法名(Info<? super Number> info){ //传递参数的泛型必须是Number或者Number的父类 }
package demo04;
import java.util.stream.Collectors;
public class Test04 {
public static void main(String[] args) {
// Info<Integer> a=new Info<>(15);
// Info<String> b=new Info<>("Hello");
// Info<Number> c=new Info<>(25.5);
// fun2(a);
// fun2(b);//泛型的引用传递，要求数据类型匹配而且泛型也要匹配。
//
// fun2(c);
//
// Info<Object> d=new Info<>(258);
// fun3(c);
// fun3(a);
// fun3(b);
// fun3(d);
}
//限定泛型的上线:泛型的限制使用在方法的引用传递中。
public static void fun2(Info<? extends Number> info){
info.show();
}
//限定泛型的下限
public static void fun3(Info<? super Number> info){
info.show();
}
//任意的泛型都可以传递过来。 使用泛型通配符。?
public static void fun(Info<?> info){
info.show();
}
}
class Info<T>{
private T var;
public Info(T var) {
this.var = var;
}
public void show(){
System.out.println("var==============="+var);
}
public T getVar() {
return var;
}
public void setVar(T var) {
this.var = var;
}
}8. 泛型接口
List<E> ArrayList<E>
在JDK1.5之后，不仅可以声明泛型类，也可以声明泛型接口，声明泛型接口和声明泛型类的语法类似，也是在接口名称后面加上<T>, 格式如下:
[访问权限] interface 接口名称<泛型标识>{
}
泛型接口的实现类的方式有两种:
(1)在创建类时也声明泛型而且该泛型的标识必须和接口的标识一致。
(2)在类实现泛型接口时，指明该泛型的数据类型。
package demo05;
import java.util.concurrent.Callable;
public class Test05 {
}
interface USB<T>{
public void show(T t);
}
//在创建类时，也指定泛型要求必须和接口的泛型标志一致
class Upan<T> implements USB<T>{
@Override
public void show(T t) {
}
}
class Shu implements USB<String>{
@Override
public void show(String s) {
}
}
9. 泛型方法
前面学习的所有泛型操作都是将整个类进行泛型化，但同样也可以在类中定义泛型化的方法。泛型方法的定义与其所在的类是否是泛型类是没有任何关系的，所在的类可以是泛型类，也可以不是泛型类。
public class Test05 {
public static void main(String[] args) {
Test05 t=new Test05();
String hello = t.fun("hello");
Integer fun = t.fun(15);
}
//泛型方法: <T>在方法的返回值前面多了个泛型标志
public <T> T fun(T t){
System.out.println("结果为:"+t);
return t;
}
}
泛型类: public class 类名<标志,标志.....>{}
通配符: ?
限制泛型类型: ? super Number ? extends Number 引用传递
泛型接口: public interface 接口<标志,标志.....>{}
泛型方法: public <标志> 返回值 方法名(参数列表){}
1194
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
