泛型

最新推荐文章于 2025-03-05 21:34:46 发布

liuwenqing11

最新推荐文章于 2025-03-05 21:34:46 发布

阅读量1.4k

点赞数

分类专栏： Java语言程序设计

本文链接：https://blog.youkuaiyun.com/liuwenqing11/article/details/112917808

版权

Java语言程序设计专栏收录该内容

45 篇文章

订阅专栏

一：什么是泛型

1.1泛型的本质是泛型的参数化是jdk5 中引入的一种新特性
泛型是提供了编译时类型安全监测机制，该机制允许我们在编译时监测到非法的类型数
据结构。泛型的本质就是参数化类型，也就是所操作的数据类型被指定为一个参数。

1.2泛型带来的好处

1）类型的安全
2）消除了强制类型的转换（因为我们创建的时候已经指定了数据类型）

3）代码健壮

二：泛型类、接口

2.1泛型类定义语法

class类名称<泛型标识，泛型标识，...>}

private 泛型标识变量名:

...

}

2.2常用的泛型标识：T 、E 、K、 V

2.3定义一个泛型类

package Four;

/**泛型类的定义
 * @author Administrator
 * @param <T> 泛型标识--类型形参
 *           T创建对象的时候里指定具体的数据类型。
 */
class BigTest<T> {
    //T是由外部指定的类的时候固定的。
    private T key;

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }

    public BigTest() {
    }

    public BigTest(T key) {
        this.key = key;
    }

    @Override
    public String toString() {
        return "BigTest{" +
                "key=" + key +
                '}';
    }
}

2.4使用方法

使用语法

类名<具体的数据类型> 对象名 = new 类名<集体的数据类型>（）；

Java1.7版本之后，后面的<>中具体的数据类型可以不用写了；

类名<具体的数据类型> 对象名 = new 类名<>（）；

泛型类注意事项

1）泛型类，如果没有指定的数据类型，返回的是Object类型；

2）泛型的类型参数只是类类型，不能是基本数据行；

3）泛型类型在逻辑上可以看成是多个不同的类型，但实际上是相同的类型，占用的空间相同。

默认情况下的泛型

泛型参数只能是类类型不能是参数类型

同一泛型不同的数据类型，占用的空间大小相同

2.5泛型类的继承情况

从泛型类派生子类
1.子类也是泛型类，子类和父类的泛型类型要一致
class ChildGeneric<T> extends Generic<T>
2.子类不是泛型类，父类要明确泛型的数据类型
class ChildGeneric extends Generic <String>

创建一个父类

package Four;

/**
 * @author Administrator
 */
public class Parent<E> {
    private E value;

    public void setValue(E value) {
        this.value = value;
    }

    public E getValue(){
        return value;
    }
}

写一个类继承父类

package Four;

/**
 * @author Administrator
 * 1.泛型类派生子类。子类也是泛型类，那么子类的泛型标识要和父类一致
 */
public class ChildFirst<T> extends Parent <T>{
    
    @Override
    public T getValue() {
        return super.getValue();
    }

    @Override
    public void setValue(T value) {
        super.setValue(value);
    }
}

2.52在写一个没有指定类型的子类

package Four;

/**
 * @author Administrator
 * 泛型类派生紫烈，如果子类不是泛型类，那么要明确数据类型
 */
public class ChildSecond extends Parent<Integer>{
  

    @Override
    public void setValue(Integer value) {
        super.setValue(value);
    }

    @Override
    public Integer getValue() {
        return super.getValue();
    }
}

在main里面测试

2.6泛型接口

2.61泛型接口的使用

1）实现列不是泛型类，接口要明确数据类型

2）实现类也是泛型类，实现类和接口的泛型类型要一致

代码定义一个泛型接口然后实现泛型接口的例子

第二种实现泛型接口还是实现上图的接口（提高了泛型接口的灵活性）

三泛型方法

1）泛型类实在实例化类的时候指定说明泛型的具体数据类型

2）泛型方法，实在调用方法的时候指明泛型的具体类型

3.1语法结构

修饰符<T ,E...>返回值类型方法名（形参列表）

{

形参列表

}

3.2常用泛型定义形式

package Demo;

/**
 * 定义一个泛型接口
 * @author Administrator
 * 定义公共的方法
 */
public interface  Generator <T> {
    T getKey();
}

package Demo;

/**
 * @author Administrator
 * 在这里可以重写接口公共的方法 和一些自己特定的方法
 */
public class Im  implements Generator{
    @Override
    public Object getKey() {
        return null;
    }

    public Object AddAge() {
        return null;
    }

}

package Demo;

/**
 * @author Administrator
 * 在这里具体调用实现
 */
public class Ex extends Im {
    public static void main(String[] args) {
        Im im = new Im();
        im.AddAge();
        im.getKey();
    }
}

首先定义一个泛型接口，然后在各自的类里面去定义各自特有的方法，最后实现，各自的具体方法。

四：泛型通配符；

什么是类型通配符；

1）类型通配符一般使用？号代替具体的类型实参；

2）类型通配符是实行参数，而不是类型形参；

定义一个泛型类

package Demo;

/**定义一单行类
 * @author Administrator
 */
public class Box<T> {
    private T number;

    public T getNumber() {
        return number;
    }

    public void setNumber(T number) {
        this.number = number;
    }
}

package Demo;

/**
 * @author Administrator
 */
public class BoxTest {
    public static void showBox(Box<?> box){
        Object number = box.getNumber();
        System.out.println(number);
    }
//    public static void showBox(Box<String> box){
//
//    }

    public static void main(String[] args) {
        Box <Integer> box = new Box<>();
        box.setNumber(100);
        showBox(box);
        Box<String> box1 = new Box<>();
        box1.setNumber("十五");
        showBox(box1);
    }
}

4.2：通配符的上限问题建立三个类分别是爷爷父亲孙子的类

package Demo;

/**
 * 爷爷辈分的类
 * @author Administrator
 */
public class GrandDad {

}

package Demo;

/**父亲辈分的类
 * @author Administrator
 */
public class Father extends GrandDad{

}

package Demo;

import java.util.ArrayList;

/**孙子辈分的类
 * @author Administrator
 */
public class Son extends Father {
    public static void main(String[] args) {
        ArrayList<GrandDad> arrayList = new ArrayList<>();
        ArrayList<Father> arrayList1 = new ArrayList<>();
        ArrayList<Son> arrayList2 = new ArrayList<>();
        AddPerson(arrayList);
        AddPerson(arrayList1);
        AddPerson(arrayList2);

    }
    public static void AddPerson(ArrayList<? extends Father> list){

    }
}