第4课第1节_Java高级应用_泛型_P

最新推荐文章于 2022-11-11 01:06:10 发布
最新推荐文章于 2022-11-11 01:06:10 发布
阅读量260 收藏
点赞数
分类专栏： java快速入门
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34738528/article/details/109669089
版权

 

泛型是程序设计语言的一种特性。允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。各种程序设计语言和其编译器、运行环境对泛型的支持均不一样。将类型参数化以达到代码复用提高软件开发工作效率的一种数据类型。泛型类是引用类型，是堆对象，主要是引入了类型参数这个概念。
泛型的定义主要有以下两种：
1.在程序编码中一些包含类型参数的类型，也就是说泛型的参数只可以代表类，不能代表个别对象。（这是当今较常见的定义）
2.在程序编码中一些包含参数的类。其参数可以代表类或对象等等。（人们大多把这称作模板）不论使用哪个定义，泛型的参数在真正使用泛型时都必须作出指明。
一些强类型编程语言支持泛型，其主要目的是加强类型安全及减少类转换的次数，但一些支持泛型的编程语言只能达到部分目的。

上面Tips如果是不了解泛型的还是比较难理解，本章使用代码的形式，可以简洁明了的看出泛型究竟是什么，下面先写一个没有使用到泛型的JAVA代码，如下：

class Person {
    private int age;

    public void setAge(int age) {
        this.age  = age;
    }

    public int getAge() {
        return this.age;
    }
}

public class Generics {
    public static void main(String args[]) {
        Person p = new Person();
        p.setAge(3);
        System.out.println(p.getAge());
    }
}

上面的代码，假设我们 setAge 这个函数要传递的参数不是整型变量了，要传递个 “3 years old” 这个字符串，那么我们需要把 Person 类里面的定义的 int 型变量全都一个一个的改成 String，这显然就很不方便也很浪费时间，那么这时候就可以引入泛型了，泛型就是把类里面的属性类型使用名字来代替，当我们需要把 int 改为 String 的时候，直接修改定义一处即可实现所有类型的替换，还是以代码的形式比较直观，经过修改上面的代码使用泛型后，如下：

/* 这个 T 就是泛型(可以用其它名字,不一定是T)，它可以替代类里面使用到的变量类型 */
class Person <T>{
    private T age;

    public void setAge(T age) {
        this.age  = age;
    }

    public T getAge() {
        return this.age;
    }
}

public class Generics {
    public static void main(String args[]) {
        /* 当我们需要把int改为String，直接往<>里面写入类型即可 */
        Person<String> p = new Person<String>();
        p.setAge("3 years old");
        System.out.println(p.getAge());

        /* 这里不能用int，因为泛型是类类型,也需要使用Integer类 */
        Person<Integer> p2 = new Person<Integer>();
        p2.setAge(3);
        System.out.println(p2.getAge());
    }
}

当然，上面的 < T > 如果想声明成使用两个泛型的话也是可以的，比如 < T,N > 来代替两个类型，在定义时也需要定义两个类型，比如< String,int >。上面的打印过程如果使用函数来实现，那函数形参的定义能不能也使用泛型呢，上面传递的类他们的泛型都不一样，一个是< String >，一个是< Integer >，那我们在传递给形参的时候可以使用通配符< ? >来定义，也可以把其它已经实例化的对象赋值给通配符的对象，如下代码所示：

class Person <T>{
    private T age;

    public void setAge(T age) {
        this.age  = age;
    }

    public T getAge() {
        return this.age;
    }
}

public class Generics {
    public static void main(String args[]) {
        Person<String> p = new Person<String>();
        p.setAge("3 years old");
        //System.out.println(p.getAge());
        printInfo(p);

        Person<Integer> p2 = new Person<Integer>();
        p2.setAge(3);
        //System.out.println(p2.getAge());
        printInfo(p2);

        /* 使用通配符来特定一个对象的时候,只能去获取,无法设置，就是没法setAge */
        Person<?> p3;
        p3 = p;
        p3.getAge();
    }

    /* <?> 使用这个通配符表示代替传递进来的类型 */    
    public static void printInfo(Person<?> p) {
        System.out.println(p.getAge());
    }
}

那么如果想让形参也使用泛型不使用通配符< ? >行不行呢，可以的，看代码的实现：

public class Generics {
    public static void main(String args[]) {
        Person<String> p = new Person<String>();
        p.setAge("3 years old");
        //System.out.println(p.getAge());
        printInfo(p);

        Person<Integer> p2 = new Person<Integer>();
        p2.setAge(3);
        //System.out.println(p2.getAge());
        printInfo(p2);


        Person<?> p3;
        p3 = p;
        p3.getAge();

        /* 形参为泛型的使用 */
        printInfo2(p);
        printInfo2(p2);
        printInfo2(p3);
    }

    public static void printInfo(Person<?> p) {
        System.out.println(p.getAge());
    }

    /* 前面的<T>用来表示形参中的参数是泛型 */
    public static <T> void printInfo2(Person<T> p) {
        System.out.println(p.getAge());
    }
}

子类能否也使用父类里面的泛型呢，具体实现看代码：

class Person <T>{
    private T age;

    public void setAge(T age) {
        this.age  = age;
    }

    public T getAge() {
        return this.age;
    }
}

/* 子类使用泛型 */
class Student<T> extends Person<T> {
}

/* 子类不想使用泛型了,就要指定使用哪一种泛型,如下 */
class Student2 extends Person<String> {
}

public class Generics {
    public static void main(String args[]) {
        Person<String> p = new Person<String>();
        p.setAge("3 years old");
        //System.out.println(p.getAge());
        printInfo(p);

        Person<Integer> p2 = new Person<Integer>();
        p2.setAge(3);
        //System.out.println(p2.getAge());
        printInfo(p2);


        Person<?> p3;
        p3 = p;
        p3.getAge();

        /* 形参为泛型的使用 */
        printInfo2(p);
        printInfo2(p2);
        printInfo2(p3);

        Student<Integer> s = new Student<Integer>();
        s.setAge(10);
        printInfo(s);//传入s子类会向上转换为Person父类

        /* 子类不使用泛型,只有父类使用的话定义的时候这个子类就不用指定泛型了 */
        Student2 s2 = new Student2();
        s2.setAge("11 years old");
        printInfo(s2);
    }

    public static void printInfo(Person<?> p) {
        System.out.println(p.getAge());
    }

    /* 前面的<T>用来表示形参中的参数是泛型 */
    public static <T> void printInfo2(Person<T> p) {
        System.out.println(p.getAge());
    }
}

当然，接口可以看做是特殊的父类，当然也能使用泛型，如下：

interface Person <T>{
    public void setAge(T age);
    public T getAge();
}

class Student<T> implements Person<T> {
    T age;

    public void setAge(T age){
        this.age = age;
    }
    public T getAge(){
        return this.age;
    }
}


class Student2 implements Person<String> {
    String age;

    public void setAge(String age){
        this.age = age;
    }
    public String getAge(){
        return this.age;
    }
}

public class Generics {
    public static void main(String args[]) {
        Student<Integer> s = new Student<Integer>();
        s.setAge(10);
        printInfo(s);//传入s会向上转换了Person

        /* 定义的时候这个子类就不用指定泛型了 */
        Student2 s2 = new Student2();
        s2.setAge("11 years old");
        printInfo(s2);
    }

    public static void printInfo(Person<?> p) {
        System.out.println(p.getAge());
    }

    /* 前面的<T>用来表示形参中的参数是泛型 */
    public static <T> void printInfo2(Person<T> p) {
        System.out.println(p.getAge());
    }
}

最后再看看“受限的泛型”，泛型可以定义上限和下限，先来看看泛型的上限，把 T 定义为只能是 Number 类或其子类,用 extemds 表示上限。

interface Person <T>{
    public void setAge(T age);
    public T getAge();
}

/* 指定只能是 Integer 或 float等 */
/* 这些类都来源于 Number 类 */
class Student<T extends Number> implements Person<T> {
    T age;

    public void setAge(T age){
        this.age = age;
    }
    public T getAge(){
        return this.age;
    }
}


class Student2 implements Person<String> {
    String age;

    public void setAge(String age){
        this.age = age;
    }
    public String getAge(){
        return this.age;
    }
}

public class Generics {
    public static void main(String args[]) {
        /* 加了上限后如果这里的泛型使用String就会出错 */
        Student<Integer> s = new Student<Integer>();
        s.setAge(10);
        printInfo(s);

        Student2 s2 = new Student2();
        s2.setAge("11 years old");
        printInfo(s2);
    }

    public static void printInfo(Person<?> p) {
        System.out.println(p.getAge());
    }
    public static <T> void printInfo2(Person<T> p) {
        System.out.println(p.getAge());
    }
}

再看看泛型的下限，把 T 定义为只能是 String 类或其父类,用 super 表示下限，而且super只能用于通配符，如下：

interface Person <T>{
    public void setAge(T age);
    public T getAge();
}

//不能直接这样用，super只能用于通配符
//class Student<T super String> implements Person<T> {
class Student<T> implements Person<T> {
    T age;

    public void setAge(T age){
        this.age = age;
    }
    public T getAge(){
        return this.age;
    }
}

class Student2 implements Person<String> {
    String age;

    public void setAge(String age){
        this.age = age;
    }
    public String getAge(){
        return this.age;
    }
}

public class Generics {
    public static void main(String args[]) {
        /* 这里因为有下限所以要改成String才能编译通过 */
        Student<String> s = new Student<String>();
        s.setAge("10 years old");
        printInfo(s);

        Student2 s2 = new Student2();
        s2.setAge("11 years old");
        printInfo(s2);
    }

    /* 只允许那些通配符是String或者String父类的实例化对象 */
    public static void printInfo(Person<? super String> p) {
        System.out.println(p.getAge());
    }

    public static <T> void printInfo2(Person<T> p) {
        System.out.println(p.getAge());
    }
}

 

 

 

 

 

qq_34738528
关注
专栏目录
Java泛型入门
低调、博学、修身
10-27 1万+
  Java泛型入门 在学习本章之前，需要对Java的集合（Collection、Map）有一定的基础。 Java集合有一个缺点，就是把一个对象“丢进”集合里后，集合就会“忘记”这个对象的数据类型，当再次取出该对象时，该对象的编译类型就变成了Object类型（其运行时类型没变）。 之所以这样设计是因为设计集合的程序员不会知道我们要用它来保存什么类型的对象，所以这样设计具有很好的通用
JAVA快速入门-泛型
itdo_just的博客
02-15 355
Tips: 泛型是程序设计语言的一种特性。允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。各种程序设计语言和其编译器、运行环境对泛型的支持均不一样。将类型参数化以达到代码复用提高软件开发工作效率的一种数据类型。泛型类是引用类型，是堆对象，主要是引入了类型参数这个概念。 泛型的定义主要有以下两种： 1.在程序编码中一些包含类型参数的类型，...
Java泛型编程快速入门
cjiac的专栏
04-15 991
JDK1.5 令我们期待很久,可是当他发布的时候却更换版本号为5.0。这说明Java已经有大幅度的变化。本文将讲解JDK5.0支持的新功能-----Java的泛型. 1、Java泛型 其实Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样，方法是这样的method(String str1,String str2 ),方法中参数str1、str2的值是可变的。而泛型也是一样的，这样
java泛型入门篇
qq_25073223的博客
07-05 138
java泛型入门篇
完整版 Java高级教程 Java语言程序设计 第4章 Java泛型（共10页）.ppt
12-19
Java泛型是自Java 1.5版本引入的一项重要特性，它允许我们在编程时指定类型参数，从而增强代码的类型安全性和重用性。泛型的主要目标是消除强制类型转换，减少ClassCastException的风险，并提高代码的可读性和可维护...
第16章：Java集合.zip_java 集合_java集合
09-24
Java集合框架是Java编程语言中的一个核心特性，它为存储、管理和操作对象提供了一组统一的接口和类。本章内容主要围绕Java集合框架展开，包括ArrayList、LinkedList、HashSet、HashMap等常见数据结构的使用方法及其...
Week17_第9讲_泛型与集合类.pdf
01-06
#### 一、泛型简介 - **定义**：泛型是Java SE 5.0引入的新特性，它允许程序员在编译时检查类型安全，并且所有的强制转换都是自动和隐式的，提高了代码的重用率。 - **作用**： - 消除强制类型转换。 - 在编译期...
The_Java_Tutorial.rar_The java tutorial_java Tutorial
09-21
2. ** HelloWorld程序**：通过编写并运行第一个"Hello, World!"程序，了解Java程序的基本结构和编译运行流程。 3. **数据类型与变量**：讲解Java中的基本数据类型（整型、浮点型、字符型、布尔型）和引用类型，以及...
tul_advanced_java_exercise1:这是 TUL 上高级 Java 课程的第一个练习
06-03
在本主题中，我们将深入探讨TUL（可能是指塔尔图大学或其他教育机构）的高级Java课程中的第一个练习。这个练习旨在帮助学生巩固基础，并挑战他们在面向对象编程、设计模式、并发处理、集合框架以及Java的其他核心...
JAVA泛型入门代码
u012775853的博客
04-18 232
让我们来写一段实际代码来了解，泛型设计代码如何写。 下面是设计一个游戏中的npc管理器。 //npc public abstract class Npc{ //... } //士兵，继承了npc public class Soldier extends Npc{ public void goAttack(Location loc){ //... ...
java(泛型入门)
awei的blog
12-23 204
什么是泛型 泛型可以理解为一个模板，但是与接口抽象类不一样，它规范的是类型，而不是内部的行为。 以List为例子，它是一个接口，我们通常使用的是它的实现类–ArrayList，使用它们我们可以代替声明一个定长的数组，因为ArrayList是变长的，当然它们的区别还不仅于此，List还使用了泛型，所以在使用的时候我们要声明List保存的数据的类型，如下： int[] ints = new int[3...
Java中的泛型-入门篇
qq_28359883的博客
12-06 204
什么是泛型 泛型解决了什么痛点 常见的定义和使用 泛型类 泛型接口 泛型函数 学习总结 原本今天是想接着写Java8新特性相关的文章的，在啃Stream的源码的时候，发现Stream对泛型的使用简直是牛逼！于是乎，想起我那可怜的Java基础。因此决定对泛型相关的知识点做一个全面的总结。写给自己看，讲给大家听。 什么是泛型泛型(Generics)是JDK5中引入的一个新特性...
JAVA 泛型 入门
weixin_34413802的博客
10-03 98
什么是泛型 本质而言，指的是参数化类型。 参数化类型很重要，因为使用该特性创建的类，接口以及方法，可以作为参数指定所操作数据的类型。 上面的这个是名词解释，看了是不是一头雾水，跟天书一样。 风.fox 可以这么理解 规定了变量数据类型是数值型，你就必须传输数值型的，传输其他类型的就会错误。 class Box<T&g...
Java 泛型入门
新手专用的博客
01-13 234
参考资料 泛型入门 编译时不检查类型的异常 使用泛型 Java 7泛型的菱形语法 深入泛型 定义泛型类 从泛型类派生子类 并不存在泛型类 类型通配符 使用类型通配符 设定类型通配符的上限 设定类型形参上限 泛型方法 定义泛型方法 泛型方法和类型通配符的区别 Java 7的菱形语法与泛型构造器 设定通配符的下限 泛型方法与方法重载 Java 8改进的类型推断 擦除与转换 泛型与数组
Java泛型--泛型入门
吴英强的技术博客
10-14 2239
1、认识泛型 按照此定义格式，定义一个point类。 class Point{ // 此处可以随便写标识符号，T是type的简称 private T var ; // var的类型由T指定，即：由外部指定 public T getVar(){ // 返回值的类型由外部决定 return var ; } public void setVar(T var){ // 设置的
*泛型入门篇*
最新发布
你们的伟仔的博客
11-11 166
本节目标：1.了解泛型 2.以能阅读Java集合源码为目标学习泛型
深入学习Java：Thinking in Java(第四版)中文解读
"《Thinking_in_Java》是Bruce Eckel创作的第四版中文版书籍，是一本详尽的Java编程教程。这本书旨在帮助初学者和经验丰富的程序员掌握Java语言，而不是深入讨论与平台相关的理论。内容涵盖Java 1.2的主要特性，包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值