12.2简单泛型类的定义

一个泛型类就是有一个或多个类型变量的类。

一般的类和方法,只能使用具体的类型(基本类型或者自定义类型)。如果要编译应用于多种类型的代码就要引入泛型了。

例12-1使用Pair类。静态方法minmax遍历数组同时计算出最小值和最大值。用一个Pair返回两个结果

package core.pair_12_1;


public class PairTest1 {

    public static void main(String[] args) {
        String[] words = {"Mary", "had", "a", "little", "lamb"};
        Pair<String> mm = ArrayAlg.minmax(words);
        System.out.println("min = " + mm.getFirst());
        System.out.println("max = " + mm.getSecond());
    }
}

class ArrayAlg {

    public static Pair<String> minmax(String[] a) {
        // TODO Auto-generated method stub
        if (a == null || a.length == 0)
            return null;
        
        String min = a[0];
        String max = a[0];
        
        for (int i = 1; i < a.length; i++) {
            if (min.compareTo(a[i]) > 0)
                min = a[i];
            if (max.compareTo(a[i]) < 0)
                max = a[i];
        }
        return new Pair<String>(min, max);
    }
    
}

class Pair<T> {
    private T first;
    private T second;

    public Pair() {
        first = null;
        second = null;
    }
    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }
    
    public T getFirst() {
        return first;
    }
    public T getSecond() {
        return second;
    }
    
    public void setFirst(T newValue) {
        first = newValue;
    }
    public void setSecond(T newValue) {
        second = newValue;
    }
}


12.3泛型方法

泛型方法可以定义在泛型类中也可以定义在普通类中:

public static <T> getMiddle(T[] a) {

return a[a.length / 2];

}

注意,类型变量<T>放在修饰符(这里是public static)后面,返回类型的前面。

<think>我们被要求回答关于Java泛型类定义及示例的问题。根据提供的引用内容,我们可以总结如下: 1. 泛型类是在类名后面使用尖括号`< >`声明类参数的类。类参数通常用单个大写字母表示,如T(表示类)、E(表示元素)、K(表示键)、V(表示值)等。 2. 在类内部,类参数T可以像普通类一样使用,例如声明成员变量、方法参数和返回类等。 3. 引用[4]提供了一个泛型类的示例代码:`Student<T>`类,其中有一个类为T的成员变量`data`,以及相应的构造方法和访问方法。 现在,我们根据用户要求,定义一个泛型类并给出示例代码。 ### 定义Java泛型类的方法 1. **声明泛型类**:在类名后面添加类参数声明,例如:`public class ClassName<T> { ... }`。这里的T是类参数,可以是任何非关键字标识符,通常用单个大写字母。 2. **使用类参数**:在类中,可以将类参数T用于成员变量、方法参数和返回类等。例如:`private T data;`。 3. **实例化泛型类**:在创建泛型类的对象时,需要指定具体的类参数。例如:`ClassName<String> obj = new ClassName<>();`。 ### 示例代码 下面我们定义一个简单泛型类`Box<T>`,它表示一个可以存放任何类数据的盒子。类中包含一个T类的成员变量,以及设置和获取该变量的方法。 ```java // 定义一个泛型类Box public class Box<T> { // T表示类参数 private T content; // 盒子中的内容 // 构造方法 public Box() { } public Box(T content) { this.content = content; } // 设置内容 public void setContent(T content) { this.content = content; } // 获取内容 public T getContent() { return content; } // 主方法用于测试 public static void main(String[] args) { // 创建一个Box实例,指定类为String Box<String> stringBox = new Box<>(); stringBox.setContent("Hello, Generics!"); System.out.println("String box content: " + stringBox.getContent()); // 创建一个Box实例,指定类为Integer Box<Integer> integerBox = new Box<>(100); System.out.println("Integer box content: " + integerBox.getContent()); } } ``` ### 代码说明 - `Box<T>`是一个泛型类,类参数T在实例化时确定。 - 成员变量`content`的类为T,因此它可以存储任何类的数据(由实例化时指定的类决定)。 - 构造方法可以接受T类的参数,也可以无参数。 - `setContent`和`getContent`方法分别用于设置和获取内容,它们使用类T。 - 在`main`方法中,我们创建了两个`Box`对象:一个存储字符串,另一个存储整数。这展示了泛型类的类安全性。 ### 注意事项 1. 泛型类参数不能是基本数据类(如int, char等),但可以使用其包装类(如Integer, Character等)。 2. 在实例化泛型类时,可以省略构造器后的类参数(菱形语法),如`new Box<>()`,编译器会自动推断类。 通过泛型类,我们可以创建可重用的组件,这些组件在编译时进行类检查,从而提高了代码的安全性和可读性。 §§相关问题§§ 1. Java泛型类中可以使用多个类参数吗? 2. 如何理解泛型类的类擦除? 3. 泛型类方法有什么区别?</think>### Java泛型类定义方法及示例代码 #### 1. 泛型类定义方法 在Java中定义泛型类需遵循以下语法: ```java 访问修饰符 class 类名<T> { // 使用T作为类参数 private T 成员变量; public 类名(T 参数) { // 构造方法使用 this.成员变量 = 参数; } public T 方法名() { // 返回泛型类 return 成员变量; } } ``` - **类参数声明**:在类名后使用尖括号`<T>`声明类参数 - **类参数命名**:通常使用单个大写字母(如`T`表示类,`E`表示元素,`K`/`V`表示键值) - **类使用**:在类内部将`T`作为具体类使用 #### 2. 完整示例代码 ```java // 定义泛型类 public class Container<T> { private T content; // 成员变量 // 构造方法 public Container(T content) { this.content = content; } // getter方法 public T getContent() { return content; } // setter方法 public void setContent(T content) { this.content = content; } public static void main(String[] args) { // 创建String类的容器 Container<String> stringContainer = new Container<>("Hello Generics"); System.out.println("String content: " + stringContainer.getContent()); // 创建Integer类的容器 Container<Integer> intContainer = new Container<>(100); System.out.println("Integer content: " + intContainer.getContent()); } } ``` #### 3. 关键特性说明 1. **类安全**:编译时检查类一致性,避免运行时`ClassCastException` ```java // stringContainer.setContent(123); // 编译错误 ``` 2. **代码复用**:同一泛型类可处理不同类数据 ```java Container<Double> doubleContainer = new Container<>(3.14); ``` 3. **类推断**:Java 7+支持菱形语法`<>`自动推断类 ```java Container<Boolean> boolContainer = new Container<>(true); ``` #### 4. 多类参数示例 ```java public class Pair<K, V> { private K key; private V value; public Pair(K key, V value) { this.key = key; this.value = value; } public K getKey() { return key; } public V getValue() { return value; } public static void main(String[] args) { Pair<String, Integer> idPair = new Pair<>("ID001", 1001); System.out.println(idPair.getKey() + " : " + idPair.getValue()); } } ``` #### 5. 重要注意事项 - 泛型类**不能是基本数据类**,需使用包装类 ```java // Container<int> invalid; // 错误 Container<Integer> valid; // 正确 ``` - 信息在**运行时被擦除**(Type Erasure),无法获取具体类参数 - 静态成员**不能使用泛型类**,因为类参数属于实例级别 通过泛型类,可以创建类安全的容器和组件,减少强制类转换,提高代码重用性和可读性[^1][^3]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值