JAVA之旅(二十一)——泛型的概述以及使用,泛型类,泛型方法,静态泛型方法,泛型接口,泛型限定,通配符


不知不觉JAVA之旅已经写到21篇了,不得不感叹当初自己坚持要重学一遍JAVA的信念,中途也算是非常的痛苦吧,不过熬到现在,已经算是有点效果了,继续加油,估计三十来篇就能结束自己的JAVA之旅了,go,go!

一.泛型的概述

什么是泛型,我们可以用一个很典型的例子来说明

package com.lgl.hellojava;

import java.util.ArrayList;
import java.util.Iterator;

//公共的   类   类名
public class HelloJJAVA {
    public static void main(String[] args) {
        /**
         * 泛型
         */
        ArrayList al = new ArrayList();
        al.add("hello 1");
        al.add("hello 02");
        al.add("hello 0300");
        al.add("hello 084");
        //添加int
        al.add(5);
        Iterator iterator = al.iterator();
        while (iterator.hasNext()) {
            String s = (String) iterator.next();
            // 打印长度
            sop(s.length());
        }
    }

    // 输出
    public static void sop(Object obj) {
        System.out.println(obj);

    }
}

这里,我们用一个arraylist存储的数据有String也有int,输出的结果

不会发现,他报的就是类型的异常,我们要怎么去解决?这里就牵扯出泛型来了

  • 泛型:JDK1.5版本之后出现的新特性,用于解决安全问题,是一个安全机制;

我们要怎么使用?

ArrayList<String> al = new ArrayList<String>();

我定义了一个容器,容器的参数是String类型,规范了数据类型,就不能存其他的数据了,安全性提高了!

  • 好处:讲运行时期出现的问题转移到了编译时期,方便程序员解决问题,让运行时期问题减少,安全

二.泛型的使用

泛型的格式:通过<>来定义要操作的引用数据类型,在使用JAVA提供的对象时,什么时候写泛型呢,通常在集合框架中很常见,只要见到<>就是定义泛型!

其实<>就是用来接收类型的,当使用集合时,将集合中要存储的数据类型,作为参数,传递到<>一样 ,我们来个小例子

package com.lgl.hellojava;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

//公共的   类   类名
public class HelloJJAVA {
    public static void main(String[] args) {
        TreeSet<String> tr = new TreeSet<String>(new LenComp());
        tr.add("hello 01");
        tr.add("hello 012");
        tr.add("hello 013");
        tr.add("hello 014");

        Iterator<String> iterator = tr.iterator();
        while (iterator.hasNext()) {
            String string = iterator.next();
            sop(string);
        }
    }

    // 输出
    public static void sop(Object obj) {
        System.out.println(obj);

    }
}

// 比较器
class LenComp implements Comparator<String> {

    @Override
    public int compare(String o1, String o2) {
        String s1 = o1;
        int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
        if (num == 0) {
            return o1.compareTo(o2);
        }
        return num;
    }

}

你可以仔细的看看里面是怎么用泛型的,就是一些小技巧

三.泛型类

这是我们优化代码比较常见的一种方式,我们可以看这块代码

package com.lgl.hellojava;

//公共的   类   类名
public class HelloJJAVA {
    public static void main(String[] args) {
        Tool t = new Tool();
        t.setW(new Worker());
        t.getW();
    }

    // 输出
    public static void sop(Object obj) {
        System.out.println(obj);

    }
}
//操作工人的工具类
class Tool {
    private Worker w;

    public Worker getW() {
        return w;
    }

    public void setW(Worker w) {
        this.w = w;
    }

}

class Worker {

}

这里,有一个工人的类,我们定义一个工具类去操作,对吧,这个逻辑就是这么的简单,但是你回发现,如果我在定义一个学生的类,就又得需要一个学生的工具类了,我们为什么不去合并这个工具类,抽调共有的方法呢?你会说可以用Object?

//操作工人的工具类
class Tool {
    private Object obj;

    public Object getObj() {
        return obj;
    }

    public void setObj(Object obj) {
        this.obj = obj;
    }

}

这样的话,你如果传递的话,还是要定义床底类型,不然会报类型异常的,我们泛型的用法

class Utils<T> {

    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

由你来指定传递进来的参数,这样就可以为所欲为了

  • 什么时候定义泛型类

    当类中要操作的引用数据类型不确定的时候,早起定义Object来完成扩展,现在定义泛型来完成扩展

四.泛型方法

泛型除了定义在类中,还是可以定义在方法上的,我们来看一下

package com.lgl.hellojava;

//公共的   类   类名
public class HelloJJAVA {
    public static void main(String[] args) {
        Demo<String> d = new Demo<String>();
        d.show("hh");
        d.print("aa");
    }
}

class Demo<T> {
    public void show(T t) {
        System.out.println("show:" + t);
    }

    public void print(T t) {
        System.out.println("print:" + t);
    }
}

泛型类定义的泛型,在整个类中有效,如果被方面使用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。

  • 为了让不同的方法可以操作不同的类型,而且类型不确定,那么可以将泛型定义在方法上

仔细看

class Demo {
    public <T> void show(T t) {

    }
    public <T>void print(T t){

    }
}

这样就可以传递泛型参数了

五.静态泛型方法

这个倒不是什么大知识点,就是注意一下,泛型方法不能使用静态的,也可以说静态方法不可以访问类上定义的泛型,如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上,就可以了


class Demo<T> {
    public <T> void show(T t) {

    }

    public <T> void print(T t) {

    }

    public static <T> void method(T t) {

    }
}

要放在static后面哦!

六.泛型接口

你类和方法都有了,怎么能少得了接口呢?

package com.lgl.hellojava;

//公共的   类   类名
public class HelloJJAVA {
    public static void main(String[] args) {
        InterImpl<Integer> i = new InterImpl<Integer>();
        i.show(55);
    }
}

class InterImpl<T> implements Inter<T> {

    @Override
    public void show(T t) {
        System.out.println("show:" + t);
    }

}

interface Inter<T> {
    void show(T t);
}

结构也差不多,传参数就行,但是这种情况是不多见的

七.泛型限定

我们来玩玩泛型的高级用法,go

先从例子切入正题

package com.lgl.hellojava;

import java.util.ArrayList;
import java.util.Iterator;

//公共的   类   类名
public class HelloJJAVA {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();

        al.add("hello 01");
        al.add("hello 02");
        al.add("hello 03");
        al.add("hello 04");

        ArrayList<Integer> all = new ArrayList<Integer>();
        all.add(9);
        all.add(596);
        all.add(98);
        all.add(97);

        printColl(all);
    }
    //内容不明确
    public static void printColl(ArrayList<?> als) {
        Iterator<?> iterator = als.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

问号是占位符,上面的逻辑就是我们有两个arrayList,但是我们需要公用一个方法,内容不明确,所以用问号占位,其实实现的方式还有很多种,还有一种需求使用不到?的,因为?是打印任何的数据,但是我只需要打印限定的几种类型,这个时候该怎么做?

package com.lgl.hellojava;

import java.util.ArrayList;
import java.util.Iterator;

//公共的   类   类名
public class HelloJJAVA {

    public static void main(String[] args) {
        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("zhangsan"));
        al.add(new Person("lisi"));
        al.add(new Person("wangwu"));

        ArrayList<Student> al1 = new ArrayList<Student>();
        al1.add(new Student("zhangsan -- 1"));
        al1.add(new Student("lisi -- 2"));
        al1.add(new Student("wangwu -- 3"));

        // ArrayList
        printColl(al1);
    }

    // 内容不明确
    public static void printColl(ArrayList<? extends Person> als) {
        Iterator<? extends Person> iterator = als.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next().getName());
        }
    }
}

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Student extends Person {

    public Student(String name) {
        super(name);
    }
}

这里,就能打印出学生和人类,而不打印其他类型的参数了,这就叫泛型限定

  • ?叫通配符,也可以理解为占位符

    • 泛型的限定 ? extends E:E类型和E的子类型。这叫上限
    • ? super E:可以接受E类型和E的父类,这叫下限

下限我就不演示了,有机会的同学可以自己试试看,还是挺好玩的

好的,我们本篇文章就到这里OK了,下一篇聊聊Map吧,恩,下篇再见

欢迎加群:555974449

JAVA之旅(二十一)——泛型的概述以及使用,泛型类,泛型方法,静态泛型方法,泛型接口,泛型限定,通配符的更多相关文章

  1. JAVA之旅(十一)——RuntimeException,异常的总结,Package,jar包,多线程概述

    JAVA之旅(十一)--RuntimeException,异常的总结,Package,jar包,多程序概述 继续JAVA之旅 一.RuntimeException 在Exception种有一个特殊的子 ...

  2. JAVA之旅(三)——数组,堆栈内存结构,静态初始化,遍历,最值,选择/冒泡排序,二维数组,面向对象思想

    JAVA之旅(三)--数组,堆栈内存结构,静态初始化,遍历,最值,选择/冒泡排序,二维数组,面向对象思想 我们继续JAVA之旅 一.数组 1.概念 数组就是同一种类型数据的集合,就是一个容器 数组的好 ...

  3. Java设计模式(二十一):职责链模式

    职责链模式(Chain Of Responsibility Pattern) 职责链模式(Chain Of Responsibility Pattern):属于对象的行为模式.使多个对象都有机会处理请 ...

  4. 夯实Java基础(二十一)——Java反射机制

    1.反射机制概述 Java反射机制是指程序在运行状态中,对于任何一个类,我们都能够知道这个类的所有属性和方法(包括private.protected等).对于任何一个对象,我们都能够对它的属性和方法进 ...

  5. Java笔记(二十一) 动态代理

    动态代理 一.静态代理 代理的背后一般至少有一个实际对象,代理的外部功能和实际对象一般是一样的, 用户与代理打交道,不直接接触实际对象.代理存在的价值: 1)节省成本比较高的实际对象创建开销,按需延迟 ...

  6. Java并发(二十一):线程池实现原理

    一.总览 线程池类ThreadPoolExecutor的相关类需要先了解: (图片来自:https://javadoop.com/post/java-thread-pool#%E6%80%BB%E8% ...

  7. Java从零开始学二十一(集合List接口)

    一.List接口 List是Collection的子接口,里面可以保存各个重复的内容,此接口的定义如下: public interface List<E> extends Collecti ...

  8. Java学习笔记二十一:Java面向对象的三大特性之继承

    Java面向对象的三大特性之继承 一:继承的概念: 继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类. 继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方 ...

  9. Java基础(二十一)集合(3)List集合

    一.List接口 List集合为列表类型,列表的主要特征是以线性方式存储对象. 1.实例化List集合 List接口的常用实现类有ArrayList和LinkedList,根据实际需要可以使用两种方式 ...

  10. Java进阶专题(二十一) 消息中间件架构体系(3)-- Kafka研究

    前言 Kafka 是一款分布式消息发布和订阅系统,具有高性能.高吞吐量的特点而被广泛应用与大数据传输场景.它是由 LinkedIn 公司开发,使用 Scala 语言编写,之后成为 Apache 基金会 ...

随机推荐

  1. dict 字典的用法

    因为这一章节用的比较多,而需要注意的得比较多, 所以总结的笔记也相对比较多一点,我就直接单独写了一页 ##    {key:value} 1. key不能为列表 2.value可以是任意类型值 3.返 ...

  2. python的IDE(pycharm)安装以及简单配置

    使用IDE的好处 界面更友好,看起来更舒服 智能提示功能很赞,大大提高开发效率 pycharm的安装过程 去pycharm官网下载安装包,请下载专业版,建议不要去网上下载汉化版 点击安装包一直下一步即 ...

  3. 剑指架构师系列-持续集成之Maven实现项目的编译、发布和部署

    Maven组织项目进行编译.部署 Maven项目基本的结构说明如下: mazhi  // 控制所有荐的编译.部署.发布 mazhi-app-parent  // 项目的父项目,有一些公共的设置可以被子 ...

  4. 含有分类变量(categorical variable)的逻辑回归(logistic regression)中虚拟变量(哑变量,dummy variable)的理解

    版权声明:本文为博主原创文章,博客地址:,欢迎大家相互转载交流. 使用R语言做逻辑回归的时候,当自变量中有分类变量(大于两个)的时候,对于回归模型的结果有一点困惑,搜索相关知识发现不少人也有相同的疑问 ...

  5. SpringMVC+BUI实现文件上传(附详解,源码下载)

    中午有限时间写这博文,前言就不必多说了,直奔主题吧. BUI是一个前端框架,关于BUI的介绍请看博主的文章那些年用过的一些前端框架. 下面我们开始实例的讲解! 一.效果演示: 上传成功后,会发现本地相 ...

  6. Spring之WEB模块

    Spring的WEB模块用于整合Web框架,例如Struts 1.Struts 2.JSF等 整合Struts 1 继承方式 Spring框架提供了ActionSupport类支持Struts 1的A ...

  7. 信用卡3D验证相关资料

    3D 验证服务,是银行与VISA .MASTERCARD国际组织联合推出的为保障银行维萨及万事达信用卡持卡客户网上交易安全,防范网上伪冒交易的一项信用卡网上支付安全验证服务( 维萨卡使用的验证服务叫& ...

  8. activity的启动模式和栈管理

     在学习Android的过程中,Intent是我们最常用Android用于进程内或进程间通信的机制,其底层的通信是以Binder机制实现的,在物理层则是通过共享内存的方式实现的.     Intent ...

  9. Android ListView中Item点击事件失效解决方案

    欢迎关注公众号,每天推送Android技术文章,二维码如下:(可扫描) 在平常的开发过程中,我们的ListView可能不只是简单的显示下文本或者按钮,更多的是显示复杂的布局,这样的话,我们就得自己写布 ...

  10. 【NPR】漫谈轮廓线的渲染

    写在前面 好久没写文章.最近在看<Real Time Rendering, third edition>这本书,看到了NPR这一章就想顺便记录下一些常见的轮廓线渲染的方法. 在非真实感渲染 ...