Java泛型程序设计

最新推荐文章于 2024-07-10 22:13:59 发布
最新推荐文章于 2024-07-10 22:13:59 发布
阅读量1k 收藏 2
点赞数 1
分类专栏： Java 文章标签： 泛型编程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zengxiantao1994/article/details/77330681
版权

泛型的基本概念

        泛型是java se1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

        java语言引入泛型的好处是安全简单。

        在java se1.5之前，没有泛型的情况下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的，对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

        泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

示例如下：

List list = new ArrayList();
list.add("CSDN_SEU_Cavin");
list.add(100);
for (int i = 0; i < list.size(); i++) {
//取出Integer时，运行时出现异常
String name = (String) list.get(i);
System.out.println("name:" + name);
}

        本例向list类型集合中加入了一个字符串类型的值和一个Integer类型的值。（这样合法，因为此时list默认的类型为Object类型）。在之后的循环中，由于忘记了之前在list中也加入了Integer类型的值或其他原因，运行时会出现java.lang.ClassCastException异常。为了解决这个问题，泛型应运而生。


泛型只在编译阶段有效

ArrayList<String>a = new ArrayList<String>(); 
ArrayListb = new ArrayList(); 
Classc1 = a.getClass();
Classc2 = b.getClass();
System.out.println(c1 + " " + c2);
System.out.println(c1 == c2); //true

        上面程序c1和c2都是class java.util.ArrayList类，输出结果为true。因为所有反射的操作都是在运行时的，既然为true，就证明了编译之后，程序会采取去泛型化的措施。

        也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，成功编译过后的class文件中是不包含任何泛型信息的。


泛型类的使用

        一个泛型类（genericclass）就是具有一个或多个类型变量的类。

        Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样，方法是这样的method(String str1, String str2)，方法中参数str1、str2的值是可变的。而泛型也是一样的，这样写class Generics＜K, V＞，这里边的K和V就象方法中的参数str1和str2也是可变。


定义Pair泛型类：

package com.zxt.pair;
 
public classPair<T> {
    private T first;
    private T second;
 
    public Pair() {
        this.first = null;
        this.second = null;
    }
 
    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }
 
    public T getFirst() {
        return first;
    }
 
    public void setFirst(T first) {
        this.first = first;
    }
 
    public T getSecond() {
        return second;
    }
 
    public void setSecond(T second) {
        this.second = second;
    }
}

Pair类引入了一个类型变量T，用尖括号（<>）括起来，并放在类名的后面。

泛型类可以有多个类型变量。例如：public class Pair<T, U> { …  }。

类定义中的类型变量指定方法的返回类型以及域和局部变量的类型。


使用Pair类：

PairAlg.java

package com.zxt.pairtest;
 
import com.zxt.pair.Pair;
 
public classArrayAlg {
 
    public static Pair<String>minmax(String[] a){
 
        if (a == null || a.length == 0) {
            return null;
        }
 
        Stringmin = a[0];
        Stringmax = 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);
    }
 
}

PairTest1.java

package com.zxt.pairtest;
 
import com.zxt.pair.Pair;
 
public classPairTest1 {
 
    public static void main(String[] args) {
        String[]words = { "Mary", "had", "a", "little","lamb" };
        Pair<String>mm = ArrayAlg.minmax(words);
        System.out.println(mm.getFirst());
        System.out.println(mm.getSecond());
    }
}

泛型方法的使用

        除了泛型类外，还可以只单独定义一个方法作为泛型方法，可以指定方法参数或者返回值指定为泛型类型的声明，留待运行时确定。泛型方法就可以声明在泛型类中，也可以声明在普通类中。

        泛型类在多个方法签名间实施类型约束。例如在List<V>中，类型参数V出现在get()、add()、contains()等方法的签名中。当创建一个Map<K, V>类型的变量时，你就在方法之间宣称一个类型约束。你传递给add()的值将与get()返回的值的类型相同。

        类似地，之所以声明泛型方法，一般是因为你想要在该方法的多个参数之间宣称一个类型约束。


一个简单的例子：

package com.zxt.generic;
 
public classGenericMethodTest {
   
    public static void main(String[] args) {
        put("Hello");
        System.out.println(get(100));
    }
   
    // T表示泛型类型的对象，无论给put方法什么参数，只要不为空就都可以输出
    public static<T> void put(T t) {
        if(t != null) {
            System.out.print(t.toString()+"  ");
        }
    }
   
    // 无论给get方法什么参数，只要不为空就都可以返回
    public static<T> T get(T t) {
        if(t != null) {
            return t;
        }
       
        return null;
    }
}


泛型接口的使用

泛型接口的使用和泛型类差不多，

泛型接口定义：public interface IPool <T> {          T get();    int add(T t);      }

泛型接口的实现：public class GenericPool<T>implements IPool<T> {   …   }

                             publicclass GenericPool implements IPool<Account>{   …   }


简单的例子如下：

package com.zxt.generic;
import java.util.Date;
 
public classGenericTest implementsGenericInterfaceTest<String, Integer> {
 
    public static void main(String[] args) {
        GenericTestgt = new GenericTest();
        gt.show("Hi", 12306);
       
        Test<String,Date> t = new Test<String,Date>();
        t.show("Hello",newDate());
    }
   
    public void show(String t, Integer u) {
        t = t + t;
        u = u * 100;
        System.out.println(t + u);
    }
}
 
class Test<T, U> implements GenericInterfaceTest<T, U> {
 
    public void show(T t, U u) {
        System.out.println(t.toString() + u.toString());
    }
}


泛型变量的限定

        定义泛型变量的上界：public class NumberGeneric< T extendsNumber>

        泛型变量上界的说明：上述方式的声明规定了NumberGeneric类所能处理的类型变量其类型和Number有继承关系；

        extends关键字所声明的上界既可以是一个类，也可以是一个接口；当泛型变量这样声明时，在实例化一个泛型类时，需要明确类型必须为指定上界类型或者子类。

        <T extends Bounding Type>表示T应该是绑定类型的子类型（subtype）。T和绑定类型可以是类，也可以是接口。选择关键字extends的原因是更接近子类的概念。一个类型变量或通配符可以有多个限定，限定类型用“&”分割。例如：T extends Comparable & Serializable


简单示例：

ArrayAlg2.Java

package com.zxt.pairtest;
import com.zxt.pair.Pair;
 
@SuppressWarnings({ "unchecked", "rawtypes" })
public classArrayAlg2 {
 
    public static <T extends Comparable>Pair<T> minmax(T[] a) {
 
        if (a == null || a.length == 0) {
            return null;
        }
 
        Tmin = a[0];
        Tmax = 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<T>(min, max);
    }
}

PairTest2.java

package com.zxt.pairtest;
 
import java.util.Calendar;
import java.util.GregorianCalendar;
 
import com.zxt.pair.Pair;
 
public classPairTest2 {
 
    public static void main(String[] args) {
        GregorianCalendar[]birthdays = {
                new GregorianCalendar(1906,Calendar.DECEMBER,9),
                new GregorianCalendar(1815,Calendar.DECEMBER,10),
                new GregorianCalendar(1903,Calendar.DECEMBER,3),
                new GregorianCalendar(1910,Calendar.JUNE,22)
        };
       
        Pair<GregorianCalendar>mm = ArrayAlg2.minmax(birthdays);
        System.out.println(mm.getFirst().get(GregorianCalendar.YEAR));
        System.out.println(mm.getSecond().get(GregorianCalendar.YEAR));
    }
}

        定义泛型变量的下界：List<? super CashCard> cards = newArrayList<T>();

        泛型变量下界的说明：通过使用super关键字可以固定泛型参数的类型为某种类型或者其超类。当程序希望为一个方法的参数限定类型时，通常可以使用下限通配符。

        public static <T> void sort(T[] a, Comparator<? super T>  c){   …  }


通配符类型

        通配符：“？”符号表明参数的类型可以是任何一种类型，它和参数T的含义是有区别的。T表示一种未知类型，而“？”表示任何一种类型。这种通配符一般有以下三种用法：

        单独的？，用于表示任何类型。

        ? extends type，表示带有上界。

        ? super type，表示带有下界。

        可以使用无限定的通配符，例如，Pair<?>。初看起来，这好像与原始的Pair类型一样。实际上，有很大的不同。Pair<?>和Pair本质的不同在于：可以用任意Object对象调用原始的Pair类的setObject方法。


实例

Employee.java

package com.zxt.pair;
 
import java.util.Date;
import java.util.GregorianCalendar;
 
public classEmployee {
 
    private String name;
    private double salary;
    private Date hireDay;
 
    public Employee(String name, double salary, int year, int month, int day) {
        this.name = name;
        this.salary = salary;
        GregorianCalendarcalendar = new GregorianCalendar(year, month - 1, day);
        hireDay = calendar.getTime();
    }
 
    public void raiseSalary(double byPercent) {
        double raise = salary * byPercent / 100;
        salary += raise;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public double getSalary() {
        return salary;
    }
 
    public void setSalary(double salary) {
        this.salary = salary;
    }
 
    public Date getHireDay() {
        return hireDay;
    }
 
    public void setHireDay(Date hireDay) {
        this.hireDay = hireDay;
    }
}

Manager.java

package com.zxt.pair;
 
public classManager extendsEmployee {
 
    private double bonus;
 
    public Manager(String name, double salary, int year, int month, int day) {
        super(name, salary, year, month, day);
        this.bonus = 0;
    }
 
    public double getSalary() {
        double baseSalary = super.getSalary();
        return baseSalary + bonus;
    }
 
    public double getBonus() {
        return bonus;
    }
 
    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
 
}

PairAlg.java

package com.zxt.pair;
 
public classPairAlg {
 
    public static boolean basNulls(Pair<?> p) {
        return p.getFirst() == null || p.getSecond() == null;
    }
 
    public static void swap(Pair<?> p) {
        swapHelper(p);
    }
 
    public static <T> voidswapHelper(Pair<T> p) {
        Tt = p.getFirst();
        p.setFirst(p.getSecond());
        p.setSecond(t);
    }
}

PairTest3.java

package com.zxt.pairtest;
 
import com.zxt.pair.Employee;
import com.zxt.pair.Manager;
import com.zxt.pair.Pair;
import com.zxt.pair.PairAlg;
 
public classPairTest3 {
 
    public static void main(String[] args) {
        Managerceo = new Manager("Gus Greedy",800000, 2003, 12, 15);
        Managercfo = new Manager("Sid Sneaky",600000, 2003, 12, 15);
        Pair<Manager>buddies = new Pair<Manager>(ceo, cfo);
        printBuddies(buddies);
 
        ceo.setBonus(1000000);
        cfo.setBonus(500000);
        Manager[]managers = { ceo, cfo };
 
        Pair<Employee>result = new Pair<Employee>();
        minmaxBonus(managers, result);
        System.out.println("first: "+ result.getFirst().getName()+ ", second: " + result.getSecond().getName());
        maxminBonus(managers, result);
        System.out.println("first: "+ result.getFirst().getName()+ ", second: " + result.getSecond().getName());
    }
 
    public static void printBuddies(Pair<? extends Employee> p) {
        Employeefirst = p.getFirst();
        Employeesecond = p.getSecond();
        System.out.println(first.getName() + " and "+ second.getName()+ " are buddies");
    }
 
    public static void minmaxBonus(Manager[] a, Pair<? super Manager> result) {
        if (a == null || a.length == 0) {
            return;
        }
        Managermin = a[0];
        Managermax = a[0];
 
        for (int i = 0; i < a.length; i++) {
            if (min.getBonus() > a[i].getBonus()) {
                min = a[i];
            }
            if (max.getBonus() < a[i].getBonus()) {
                max = a[i];
            }
        }
 
        result.setFirst(min);
        result.setSecond(max);
    }
 
    public static void maxminBonus(Manager[] a, Pair<? super Manager> result) {
        minmaxBonus(a, result);
        PairAlg.swapHelper(result);
    }
}


泛型类型的继承规则

        Java语言中的数组是协变的（covariant），也就是说，如果Integer扩展了Number（事实也是如此），那么不仅Integer是Number，而且Integer[]也是Number[]，在要求Number[]的地方完全可以传递或者赋予Integer[]。（更正式地说，如果Number是Integer的超类型，那么Number[]也是Integer[]的超类型）。

        由于Employee是Manager的超类，因此可以将一个Manager[]数组赋给一个类型为Employee[]的变量：

        Manager[] managerBuddies ={ceo, cfo};

        Employee[] employeeBuddies =managerBuddies;

        你也许认为这一原理同样适用于泛型类型——Pair<Employee>是Pair<Manager>的超类型，那么可以将一个Pair<Manager>赋给一个类型为Pair<Employee>的变量。不幸的是，情况并非如此。

        Pair<Manager>managerBuddies = new Pair<Manager>(ceo, cfo);

        Pair<Employee>employeeBuddies = managerBuddies; //illegal

        employeeBuddies.setFirst(lowlyEmployee);

        不允许这样做有一个很充分的理由：这样做将破坏要提供的类型安全泛型。Java语言中泛型类不具协变性。如果能够将List<Integer>赋给List<Number>。那么下面的代码就允许将非Integer的内容放入List<Integer>：

List<Integer> li = newArrayList<Integer>();

        List<Number> ln = li;// illegal

        ln.add(new Float(3.1415));

        泛型类可以扩展或实现其它的泛型类。就一点而言，与普通的类没有什么区别。 例如，ArrayList<T>类实现List<T>接口。这意味着，一个ArrayList<Manager>可以被转换为一个List<Manager>。


总结

        在定义一个泛型类的时候，在“＜＞”之间定义形式类型参数，例如：“class TestGeneric＜K, V＞”，其中“K” , “V”不代表值，而是表示类型。实例化泛型对象的时候，一定要在类名后面指定类型参数的值（类型），一共要有两次书写。例如：

        TestGeneric＜String, String＞t = new TestGeneric＜String, String＞()；

        泛型中＜T extends Object＞，extends并不代表继承，它是类型范围限制。

        泛型不是协变的。

 

使用泛型的优点

        1、类型安全。通过知道泛型定义的变量类型限制，编译器可以更有效地提高Java程序的类型安全。

        2、消除强制类型转换。消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。所有的强制转换都是自动和隐式的。

        3、向后兼容。

        4、层次清晰。

        5、性能较高。用GJ(泛型JAVA)编写的代码可以为java编译器和虚拟机带来更多的类型信息，这些信息对java程序做进一步优化提供条件。

 

使用泛型的注意事项

        1、不能用基本类型实例化类型参数

        2、运行时类型查询只适用于原始类型

        3、不能抛出也不能捕获泛型类实例

        4、参数化类型的数组不合法

        5、不能实例化类型变量

        6、泛型类的静态上下文中类型变量无效

        7、注意擦除后的冲突

知行流浪
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
泛型程序设计
04-15
很实用的泛型讲解，很详细的，泛型学习必备！
Java中的泛型编程
陈九龙的专栏
01-08 486
引言 什么是泛型？ 泛型的意思是 类型参数化。 到底什么是类型参数化呢？通过这一节内容，我们希望大家能够彻底弄懂什么是泛型，以及如何在开发中使用泛型。 Java泛型应用是java核心基础之一，从java5开始引入泛型概念。如果你曾经使用过java中的collection相关的类，那么就算你已经接触过泛型了。在java的Collection中使用泛型是一件很简单的事情，可泛型还具有许...
面向对象程序设计（泛型）
hhxxttx_的博客
12-25 747
比如，我们可以定义一个泛型类或方法，让它可以处理不同类型的数据，而不需要针对每种类型都写一份代码。但需要注意的是，在使用通配符时，你无法往带有通配符的集合中添加元素，因为无法确定要添加的元素的确切类型。extends Number>` 表示可以接受类型为 `Number` 或其子类的 List。泛型的核心思想就是参数化类型，也就是说，我们可以编写出适用于多种类型的代码，而不必为每种类型都重复编写相似的代码。假设我们要定义一个简单的泛型类，比如一个盒子，可以放入不同类型的物品。在这里，`List
Java 中的泛型（超全详解）
最新发布
weixin_65752158的博客
07-10 5719
泛型的出现就是为了统一集合当中数据类型的尖括号 <> 中的 泛型标识被称作是类型参数，用于指代任何数据类型。T ：代表一般的任何类。E ：代表 Element 元素的意思，或者 Exception 异常的意思。K ：代表 Key 的意思。V ：代表 Value 的意思，通常与 K 一起配合使用。S ：代表 Subtype 的意思，文章后面部分会讲解示意。自己实现集合/*E: 表示不确定的类型,该类型在类名后面已经定义过了e: 形参的名字,变量名*/
Java高级编程——泛型
qq_61524266的博客
06-12 726
Java高级编程——泛型
【Java 基础篇】Java 泛型程序设计详解
繁依Fanyi的博客
06-27 328
Java 泛型程序设计是一项强大的特性，它使我们能够编写通用、类型安全的代码。本文介绍了泛型的概念、泛型类和泛型方法的使用，以及类型边界和通配符的应用。我们还讨论了类型擦除和桥方法的相关问题，以及如何在反射中处理泛型类型。通过合理运用泛型，我们可以提高代码的可重用性和灵活性，并提供更好的类型安全性。希望本文对你理解和使用 Java 泛型程序设计提供了帮助。
Java泛型编程
isuss的博客
05-25 301
泛型是Java中的一种特性，它允许我们定义一种类型，在使用时再指定具体的类型。例如，我们可以定义一个 List 类型，然后在使用时指定具体的元素类型，例如 List<String>、List<Integer> 等。Java中的泛型是通过参数化类型来实现的，我们可以在定义类、接口、方法时，使用参数来表示类型变量，并在使用时指定具体的类型。在上述代码中，我们定义了一个 Box 类，它使用类型变量 T 表示要存储的值的类型。");
Java程序设计PPT详解
08-20
本书讲解Java程序设计知识及其编程方法，包括Java语言的基础语法、结构化程序设计、面向对象程序设计、数组、字符串、向量、哈希表、泛型、枚举、异常处理、文件和数据流、图形用户界面设计、小应用程序、线程、编程...
Java泛型的继承和实现操作示例
08-25
Java泛型的继承和实现操作示例 ...* 《Java面向对象程序设计入门与进阶教程》 * 《Java数据结构与算法教程》 * 《Java操作DOM节点技巧总结》 * 《Java文件与目录操作技巧汇总》 * 《Java缓存操作技巧汇总》
Educoder–Java面向对象-泛型程序设计【笔记+参考代码】
12-21
Java中的泛型是面向对象程序设计的一个重要特性，它允许我们在类、接口和方法中使用类型参数，从而创建可重用的组件，这些组件能够处理多种数据类型而无需显式进行类型转换。泛型的主要目标是提高代码的类型安全性和...
Java——泛型设计
qq_40543015的博客
09-09 181
为集合提供编译时（静态）类型安全，并消除了大多数类型转换的需要（由于泛型是在编译时起作用，所以在运行时动态生成的反射可以绕过泛型限制）泛型类就是一个具有多种类型变量的类，泛型类可以拥有一个类型，也可以拥有多个类型[访问修饰符] class 类名<T,U,...> {T 泛型成员1;U 泛型成员2;...类型参数使用大写形式，且比较短，这是最常使用的​​/*** 查询全部* @return*//*** 根据id查询* @param k* @return*//**
Java泛型详解（史上最全泛型知识详解）
m0_70325779的博客
07-25 9924
泛型是在JDK5之后引入的一个新特性，可以在编译阶段约束操作的数据类型，并进行检查。泛型的格式为用大白话来说，泛型就好比是给一个标签，通常情况下我们会在开发过程中或者个人学习或练习的过程中使用到泛型；就拿数组的泛型举例来说，我们把数组比作一个药瓶子，我们药瓶子贴上了什么标签，就只能放什么药，如果不管什么药都放在一个药瓶子里，那不得出大事吗？同样容器(数组)写上什么泛型，就只能存放什么数据；这样就不会导致我们存取数据的混乱。这样就解决了我们引言中提到的问题，也就解释了什么是泛型。
Java 中的泛型（两万字超全详解）
热门推荐
林二月的博客
08-02 7万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
Java 泛型编程
gebilaowang1234的博客
05-27 1155
Java 泛型编程 一 . 定义泛型类 package com.example.java; public class Person<T> { T name; public T getName() { return name; } public void setName(T name) { this.name = name; } } public class Person<T, W> { T n
Java高级编程—泛型
triumph_421的博客
03-14 1210
新秧初出水，渺渺翠毯齐，及时趁芒种，散著畦东西。一入芒种，收苗插秧，又到了农家最忙碌的季节。中国自古便有着博大精深的农耕文化，梯田更是其中的历史瑰宝，它既体现了农人与自然和谐共生的智慧，也形成了独具地方风情的人文景观。来到丹寨高要梯田，在田野中感受夏日微热的风，在这个芒种时节返璞归真，让诗意的烟火尽情纵横于山野之间。
Java泛型详解，史上最全图文详解
mikechen的互联网架构
02-15 5万+
泛型在java中有很重要的地位，无论是开源框架还是JDK源码都能看到它。 毫不夸张的说，泛型是通用设计上必不可少的元素，所以真正理解与正确使用泛型，是一门必修课。 一：泛型本质 Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。 泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛.
【java】泛型编程
记录学习，一起进步
04-15 581
java泛型编程思想
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值