精华内容
下载资源
问答
  • java泛型概述

    2019-11-06 23:49:16
    泛型概述2. 泛型类3. 泛型方法4. 泛型接口5. 泛型通配符 一、泛型 1. 泛型概述 泛型的由来 当我们要接收一个参数的时候,但却不明确接收的参数的类型,这个时候就可以将参数类型设置为Object类型,这样子所有类型...

    一、泛型

    1. 泛型概述

    • 泛型的由来
      • 当我们要接收一个参数的时候,但却不明确接收的参数的类型,这个时候就可以将参数类型设置为Object类型,这样子所有类型的参数都可以接收。
      • 但是这样子做有一个问题,我们用Object类型的变量可以接收所有类型的对象,但是当我们要使用这个对象内部存储的数据时,需要手动将这个对象再次强转为它原来的类型,很麻烦。
      • 这个时候就可以使用泛型,它可以自动识别参数的类型,确定返回值,不用再手动进行类型转换
    • 泛型的定义
      • 类型的明确工作不再是在定义的时候完成,而是交由创建对象或调用方法时去明确。也就是定义的时候并不知道是什么类型,在实际使用的时候再确定类型
      • 格式
        • <数据类型>
        • 只能是引用的数据类型
      • 可以定义在类、接口、方法、集合上
    • 泛型的优点
      • 将运行时期的类型选择问题提前到了编译期间
      • 避免了类型的强制转换
      • 优化程序设计,解决黄色警告
      • 注:泛型只在编译期间存在,在运行期间泛型就擦除了

    2. 泛型类

    • 将泛型定义在类上面
    • 定义格式
      • public class 类名 <泛型类型…>
    • 注意事项:泛型必须为引用类型

    3. 泛型方法

    • 将泛型定义在方法上
    • 定义格式
      • public <泛型类型…> 返回类型 方法名(泛型类型 变量名){方法体}

    4. 泛型接口

    • 将泛型定义在接口上
    • 定义格式
      • public interface 接口名<泛型类型…>

    5. 泛型通配符

    • <?>
      • 任意类型
    • <? extends E> + 向下限定,只限E及子类
    • <? super E> + 向上限定,只限E及父类
    • 泛型一经明确,则左右两边的类型要一致,且只能添加明确的类型的对象
      向上限定,只限E及父类
    • 泛型一经明确,则左右两边的类型要一致,且只能添加明确的类型的对象
    展开全文
  • Java泛型概述

    2017-09-02 12:45:59
    本文我们将从零开始来看一下Java泛型的设计,将会涉及到通配符处理,以及让人苦恼的类型擦除。泛型基础泛型类我们首先定义一个简单的Box类:public class Box { private String object; public void set(String ...

    泛型是Java中一个非常重要的知识点,在Java集合类框架中泛型被广泛应用。本文我们将从零开始来看一下Java泛型的设计,将会涉及到通配符处理,以及让人苦恼的类型擦除。

    泛型基础

    泛型类

    我们首先定义一个简单的Box类:

    public class Box {
        private String object;
        public void set(String object) { this.object = object; }
        public String get() { return object; }
    }
    

    这是最常见的做法,这样做的一个坏处是Box里面现在只能装入String类型的元素,今后如果我们需要装入Integer等其他类型的元素,还必须要另外重写一个Box,代码得不到复用,使用泛型可以很好的解决这个问题。

    public class Box<T> {
        // T stands for "Type"
        private T t;
        public void set(T t) { this.t = t; }
        public T get() { return t; }
    }
    

    这样我们的Box类便可以得到复用,我们可以将T替换成任何我们想要的类型:

    Box<Integer> integerBox = new Box<Integer>();
    Box<Double> doubleBox = new Box<Double>();
    Box<String> stringBox = new Box<String>();
    

    泛型方法

    看完了泛型类,接下来我们来了解一下泛型方法。声明一个泛型方法很简单,只要在返回类型前面加上一个类似<K, V>的形式就行了:

    public class Util {
        public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
            return p1.getKey().equals(p2.getKey()) &&
                   p1.getValue().equals(p2.getValue());
        }
    }
    public class Pair<K, V> {
        private K key;
        private V value;
        public Pair(K key, V value) {
            this.key = key;
            this.value = value;
        }
        public void setKey(K key) { this.key = key; }
        public void setValue(V value) { this.value = value; }
        public K getKey()   { return key; }
        public V getValue() { return value; }
    }
    

    我们可以像下面这样去调用泛型方法:

    Pair<Integer, String> p1 = new Pair<>(1, "apple");
    Pair<Integer, String> p2 = new Pair<>(2, "pear");
    boolean same = Util.<Integer, String>compare(p1, p2);
    

    或者在Java1.7/1.8利用type inference,让Java自动推导出相应的类型参数:

    Pair<Integer, String> p1 = new Pair<>(1, "apple");
    Pair<Integer, String> p2 = new Pair<>(2, "pear");
    boolean same = Util.compare(p1, p2);
    

    边界符

    现在我们要实现这样一个功能,查找一个泛型数组中大于某个特定元素的个数,我们可以这样实现:

    public static <T> int countGreaterThan(T[] anArray, T elem) {
        int count = 0;
        for (T e : anArray)
            if (e > elem)  // compiler error
                ++count;
        return count;
    }
    

    但是这样很明显是错误的,因为除了short, int, double, long, float, byte, char等原始类型,其他的类并不一定能使用操作符>,所以编译器报错,那怎么解决这个问题呢?答案是使用边界符。

    public interface Comparable<T> {
        public int compareTo(T o);
    }
    

    做一个类似于下面这样的声明,这样就等于告诉编译器类型参数T代表的都是实现了Comparable接口的类,这样等于告诉编译器它们都至少实现了compareTo方法。

    public static <T extends Comparable<T>> int countGreaterThan(T[] anArray, T elem) {
        int count = 0;
        for (T e : anArray)
            if (e.compareTo(elem) > 0)
                ++count;
        return count;
    }
    

    通配符

    在了解通配符之前,我们首先必须要澄清一个概念,还是借用我们上面定义的Box类,假设我们添加一个这样的方法:

    public void boxTest(Box<Number> n) { /* ... */ }
    

    那么现在Box<Number> 允许接受什么类型的参数?我们是否能够传入Box<Integer>或者Box<Double>呢?答案是否定的,虽然Integer和Double是Number的子类,但是在泛型中Box<Integer>或者Box<Double>Box<Number>之间并没有任何的关系。这一点非常重要,接下来我们通过一个完整的例子来加深一下理解。

    首先我们先定义几个简单的类,下面我们将用到它:

    class Fruit {}
    class Apple extends Fruit {}
    class Orange extends Fruit {}
    

    下面这个例子中,我们创建了一个泛型类Reader,然后在f1()中当我们尝试Fruit f = fruitReader.readExact(apples);编译器会报错,因为List<Fruit>List<Apple>之间并没有任何的关系。

    public class GenericReading {
        static List<Apple> apples = Arrays.asList(new Apple());
        static List<Fruit> fruit = Arrays.asList(new Fruit());
        static class Reader<T> {
            T readExact(List<T> list) {
                return list.get(0);
            }
        }
        static void f1() {
            Reader<Fruit> fruitReader = new Reader<Fruit>();
            // Errors: List<Fruit> cannot be applied to List<Apple>.
            // Fruit f = fruitReader.readExact(apples);
        }
        public static void main(String[] args) {
            f1();
        }
    }
    

    解决方式一:通配符

    但是按照我们通常的思维习惯,Apple和Fruit之间肯定是存在联系,然而编译器却无法识别,那怎么在泛型代码中解决这个问题呢?我们可以通过使用通配符来解决这个问题,改写内部类Reader如下:

    static class Reader<T> {
        T readExact(List<? extends T> list) {
            return list.get(0);
        }
    }
    

    这样就相当与告诉编译器, fruitReader的readCovariant方法接受的参数只要是满足Fruit的子类就行(包括Fruit自身),这样子类和父类之间的关系也就关联上了。

    解决方式二:返回类型前加上泛型

    static class Reader<T> {
        <T> T readExact(List<T> list) {
            return list.get(0);
        }
    }
    

    虽然可以解决问题,但是我不知道为什么???!!!

    PECS原则

    Produce extends,Conxumer super.

    上面我们看到了类似<? extends T>的用法,利用它我们可以从list里面get元素,那么我们可不可以往list里面add元素呢?我们来尝试一下:

    public class GenericsAndCovariance {
        public static void main(String[] args) {
            // Wildcards allow covariance:
            List<? extends Fruit> flist = new ArrayList<Apple>();
            // Compile Error: can't add any type of object:
            // flist.add(new Apple());
            // flist.add(new Orange());
            // flist.add(new Fruit());
            // flist.add(new Object());
            flist.add(null); //合法但无意义
            // We Know that it returns at least Fruit:
            Fruit f = flist.get(0);
        }
    }
    

    答案是否定,Java编译器不允许我们这样做,为什么呢?对于这个问题我们不妨从编译器的角度去考虑。因为List<? extends Fruit> flist它自身可以有多种含义:

    List<? extends Fruit> flist = new ArrayList<Fruit>();
    List<? extends Fruit> flist = new ArrayList<Apple>();
    List<? extends Fruit> flist = new ArrayList<Orange>();
    

    当我们尝试add一个Apple的时候,flist可能指向new ArrayList<Orange>();
    当我们尝试add一个Orange的时候,flist可能指向new ArrayList<Apple>();
    当我们尝试add一个Fruit的时候,这个Fruit可以是任何类型的Fruit,而flist可能只想某种特定类型的Fruit,编译器无法识别所以会报错。

    所以对于实现了<? extends T>的集合类只能将它视为Producer向外提供(get)元素,而不能作为Consumer来对外获取(add)元素。

    如果我们要add元素应该怎么做呢?可以使用<? super T>

    public class GenericWriting {
        static List<Apple> apples = new ArrayList<Apple>();
        static List<Fruit> fruit = new ArrayList<Fruit>();
        static <T> void writeExact(List<T> list, T item) {
            list.add(item);
        }
        static void f1() {
            writeExact(apples, new Apple());
            writeExact(fruit, new Apple());
        }
        //wildcard:通配符
        static <T> void writeWithWildcard(List<? super T> list, T item) {
            list.add(item);
        }
        static void f2() {
            writeWithWildcard(apples, new Apple());
            writeWithWildcard(fruit, new Apple());
        }
        public static void main(String[] args) {
            f1(); f2();
        }
    }
    

    这样我们可以往容器里面添加元素了,但是使用super的坏处是以后不能get容器里面的元素了,原因很简单,我们继续从编译器的角度考虑这个问题,对于List<? super Apple> list,它可以有下面几种含义:

    List<? super Apple> list = new ArrayList<Apple>();
    List<? super Apple> list = new ArrayList<Fruit>();
    List<? super Apple> list = new ArrayList<Object>();
    

    当我们尝试通过list来get一个Apple的时候,可能会get得到一个Fruit,这个Fruit可以是Orange等其他类型的Fruit。

    根据上面的例子,我们可以总结出一条规律,Producer Extends, Consumer Super

    • “Producer Extends” – 如果你需要一个只读List,用它来produce T,那么使用? extends T。
    • “Consumer Super” – 如果你需要一个只写List,用它来consume T,那么使用? super T。

    如果需要同时读取以及写入,那么我们就不能使用通配符了。

    如何阅读过一些Java集合类的源码,可以发现通常我们会将两者结合起来一起用,比如像下面这样:

    public class Collections {
        public static <T> void copy(List<? super T> dest, List<? extends T> src) {
            for (int i=0; i<src.size(); i++)
                dest.set(i, src.get(i));
        }
    }
    

    类型擦除

    Java泛型中最令人苦恼的地方或许就是类型擦除了,特别是对于有C++经验的程序员。类型擦除就是说Java泛型只能用于在编译期间的静态类型检查,然后编译器生成的代码会擦除相应的类型信息,这样到了运行期间实际上JVM根本就知道泛型所代表的具体类型。这样做的目的是因为Java泛型是1.5之后才被引入的,为了保持向下的兼容性,所以只能做类型擦除来兼容以前的非泛型代码。对于这一点,如果阅读Java集合框架的源码,可以发现有些类其实并不支持泛型。

    说了这么多,那么泛型擦除到底是什么意思呢?我们先来看一下下面这个简单的例子:

    public class Node<T> {
        private T data;
        private Node<T> next;
        public Node(T data, Node<T> next) {
            this.data = data;
            this.next = next;
        }
        public T getData() { return data; }
        // ...
    }
    

    编译器做完相应的类型检查之后,实际上到了运行期间上面这段代码实际上将转换成:

    public class Node {
        private Object data;
        private Node next;
        public Node(Object data, Node next) {
            this.data = data;
            this.next = next;
        }
        public Object getData() { return data; }
        // ...
    }
    

    这意味着不管我们声明Node<String>还是Node<Integer>,到了运行期间,JVM统统视为Node<Object>。有没有什么办法可以解决这个问题呢?这就需要我们自己重新设置bounds了,将上面的代码修改成下面这样:

    public class Node<T extends Comparable<T>> {
        private T data;
        private Node<T> next;
        public Node(T data, Node<T> next) {
            this.data = data;
            this.next = next;
        }
        public T getData() { return data; }
        // ...
    }
    

    这样编译器就会将T出现的地方替换成Comparable而不再是默认的Object了:

    public class Node {
        private Comparable data;
        private Node next;
        public Node(Comparable data, Node next) {
            this.data = data;
            this.next = next;
        }
        public Comparable getData() { return data; }
        // ...
    }
    

    上面的概念或许还是比较好理解,但其实泛型擦除带来的问题远远不止这些,接下来我们系统地来看一下类型擦除所带来的一些问题,有些问题在C++的泛型中可能不会遇见,但是在Java中却需要格外小心。

    问题一

    在Java中不允许创建泛型数组,类似下面这样的做法编译器会报错:

    List<Integer>[] arrayOfLists = new List<Integer>[2]; // compile-time error
    

    为什么编译器不支持上面这样的做法呢?继续使用逆向思维,我们站在编译器的角度来考虑这个问题。

    我们先来看一下下面这个例子:

    Object[] strings = new String[2];
    strings[0] = "hi"; // OK
    strings[1] = 100; // An ArrayStoreException is thrown.
    

    对于上面这段代码还是很好理解,字符串数组不能存放整型元素,而且这样的错误往往要等到代码运行的时候才能发现,编译器是无法识别的。接下来我们再来看一下假设Java支持泛型数组的创建会出现什么后果:

    Object[] stringLists = new List<String>[]; // compiler error, but pretend it's allowed
    stringLists[0] = new ArrayList<String>(); // OK
    // An ArrayStoreException should be thrown, but the runtime can't detect it.
    stringLists[1] = new ArrayList<Integer>();
    

    假设我们支持泛型数组的创建,由于运行时期类型信息已经被擦除,JVM实际上根本就不知道new ArrayList<String>()new ArrayList<Integer>()的区别。类似这样的错误假如出现才实际的应用场景中,将非常难以察觉。

    如果你对上面这一点还抱有怀疑的话,可以尝试运行下面这段代码:

    public class ErasedTypeEquivalence {
        public static void main(String[] args) {
            Class c1 = new ArrayList<String>().getClass();
            Class c2 = new ArrayList<Integer>().getClass();
            System.out.println(c1 == c2); // true
        }
    }
    

    问题二

    继续复用我们上面的Node的类,对于泛型代码,Java编译器实际上还会偷偷帮我们实现一个Bridge method。

    public class Node<T> {
        public T data;
        public Node(T data) { this.data = data; }
        public void setData(T data) {
            System.out.println("Node.setData");
            this.data = data;
        }
    }
    public class MyNode extends Node<Integer> {
        public MyNode(Integer data) { super(data); }
        public void setData(Integer data) {
            System.out.println("MyNode.setData");
            super.setData(data);
        }
    }
    

    看完上面的分析之后,你可能会认为在类型擦除后,编译器会将Node和MyNode变成下面这样:

    public class Node {
        public Object data;
        public Node(Object data) { this.data = data; }
        public void setData(Object data) {
            System.out.println("Node.setData");
            this.data = data;
        }
    }
    public class MyNode extends Node {
        public MyNode(Integer data) { super(data); }
        public void setData(Integer data) {
            System.out.println("MyNode.setData");
            super.setData(data);
        }
    }
    

    实际上不是这样的,我们先来看一下下面这段代码,这段代码运行的时候会抛出ClassCastException异常,提示String无法转换成Integer:

    MyNode mn = new MyNode(5);
    Node n = mn; // A raw type - compiler throws an unchecked warning
    n.setData("Hello"); // Causes a ClassCastException to be thrown.
    // Integer x = mn.data;
    

    如果按照我们上面生成的代码,运行到第3行的时候不应该报错(注意我注释掉了第4行),因为MyNode中不存在setData(String data)方法,所以只能调用父类Node的setData(Object data)方法,既然这样上面的第3行代码不应该报错,因为String当然可以转换成Object了,那ClassCastException到底是怎么抛出的?

    实际上Java编译器对上面代码自动还做了一个处理:

    class MyNode extends Node {
        // Bridge method generated by the compiler
        public void setData(Object data) {
            setData((Integer) data);
        }
        public void setData(Integer data) {
            System.out.println("MyNode.setData");
            super.setData(data);
        }
        // ...
    }
    

    这也就是为什么上面会报错的原因了,setData((Integer) data);的时候String无法转换成Integer。所以上面第2行编译器提示unchecked warning的时候,我们不能选择忽略,不然要等到运行期间才能发现异常。如果我们一开始加上Node<Integer> n = mn就好了,这样编译器就可以提前帮我们发现错误。

    问题三

    正如我们上面提到的,Java泛型很大程度上只能提供静态类型检查,然后类型的信息就会被擦除,所以像下面这样利用类型参数创建实例的做法编译器不会通过:

    public static <E> void append(List<E> list) {
        E elem = new E();  // compile-time error
        list.add(elem);
    }
    

    但是如果某些场景我们想要需要利用类型参数创建实例,我们应该怎么做呢?可以利用反射解决这个问题:

    public static <E> void append(List<E> list, Class<E> cls) throws Exception {
        E elem = cls.newInstance();   // OK
        list.add(elem);
    }
    

    我们可以像下面这样调用:

    List<String> ls = new ArrayList<>();
    append(ls, String.class);
    

    实际上对于上面这个问题,还可以采用Factory和Template两种设计模式解决,感兴趣的朋友不妨去看一下Thinking in Java中第15章中关于Creating instance of types(英文版第664页)的讲解,这里我们就不深入了。

    问题四

    我们无法对泛型代码直接使用instanceof关键字,因为Java编译器在生成代码的时候会擦除所有相关泛型的类型信息,正如我们上面验证过的JVM在运行时期无法识别出ArrayList<Integer>ArrayList<String>的之间的区别:

    public static <E> void rtti(List<E> list) {
        if (list instanceof ArrayList<Integer>) {  // compile-time error
            // ...
        }
    }
    
    => { ArrayList<Integer>, ArrayList<String>, LinkedList<Character>, ... }
    

    和上面一样,我们可以使用通配符重新设置bounds来解决这个问题:

    public static void rtti(List<?> list) {
        if (list instanceof ArrayList<?>) {  // OK; instanceof requires a reifiable type
            // ...
        }
    }
    

    工厂模式

    接下来我们利用泛型来简单的实现一下工厂模式,首先我们先声明一个接口Factory:

    package typeinfo.factory;
    public interface Factory<T> {
        T create();
    }
    

    下面我们定义了几个实体类FuelFilter和AirFilter以及FanBelt和GeneratorBelt。

    class Filter extends Part {}
    class FuelFilter extends Filter {
        public static class Factory implements typeinfo.factory.Factory<FuelFilter> {
            public FuelFilter create() {
                return new FuelFilter();
            }
        }
    }
    class AirFilter extends Filter {
        public static class Factory implements typeinfo.factory.Factory<AirFilter> {
            public AirFilter create() {
                return new AirFilter();
            }
        }
    }
    

    Part类的实现如下,注意我们上面的实体类都是Part类的间接子类。在Part类我们注册了我们上面的声明的实体类。所以以后如果要创建相关的实体类的话,只需要调用Part类的相关方法就可以了。这么做的一个好处是如果业务中出现了新的实体类比如CabinAirFilter或者PowerSteeringBelt的话,我们不需要修改太多的代码,只需要在Part类中将它们注册即可。

    class Belt extends Part {}
    class FanBelt extends Belt {
        public static class Factory implements typeinfo.factory.Factory<FanBelt> {
            public FanBelt create() {
                return new FanBelt();
            }
        }
    }
    class GeneratorBelt extends Belt {
        public static class Factory implements typeinfo.factory.Factory<GeneratorBelt> {
            public GeneratorBelt create() {
                return new GeneratorBelt();
            }
        }
    }
    

    最后我们来测试一下:

    public class RegisteredFactories {
        public static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                System.out.println(Part.createRandom());
            }
        }
    }
    

    References

    展开全文
  • JAVA泛型概述

    2020-05-07 10:50:00
    java泛型 一 通常情况下为了表示变量可以接受不同类型的数据(如: 坐标接受int, float, string等) 1.传统(IDK1.5以前): 利用向上转型和自动装箱可以实现将所有原始数据封装为object类型 向下转型存在风险, 编译时...

    java泛型


    在这里插入图片描述

    一 通常情况下为了表示变量可以接受不同类型的数据(如: 坐标接受int, float, string等)



    1.传统(IDK1.5以前):

    利用向上转型和自动装箱可以实现将所有原始数据封装为object类型

    向下转型存在风险, 编译时不易发现错误
    重载有重复代码

    • int --> Integer --> Object
    • double -->Double --> Object
    • String --> Object



    2.泛型:


    所谓“泛型”,就是“宽泛的数据类型”,任意的数据类型。
    • 泛型类

      • public fuck{}
    • 泛型方法

      • public void fuck ( T x){}

        • 修饰符 <类型参数列表> 返回类型 方法名(形参列表) { 方法体 }
    • 泛型接口

      • public interface fuck{}

        • 实现:
          public damn implement fuck{}

    二 传值参数(我们通常所说的参数)由小括号包围,如 (int x, double y)




    三 类型参数(泛型参数)由尖括号包围,多个参数由逗号分隔,如 或 <T, E>。


    1.特点

    • 不但数据的值可以通过参数传递,数据的类型也可以通过参数传递
    • T1, T2 是自定义的标识符,也是参数,用来传递数据的类型,而不是数据的值,我们称之为类型参数
    • 泛型类在实例化时必须指出具体的类型,也就是向类型参数传值,格式为:
      className variable<dataType1, dataType2> = new className<dataType1, dataType2>();

    2.限制泛型

    • 用户传递其他数据类型可能会引起错误

      • 例如 某些类型不支持其他类型的方法,doubleValue不支持IString的对象调用
    • 通过 extends 关键字

    • 表示 T 只接受 Number 及其子类,传入其他类型的数据会报错。
      extends理解为 T 是继承自 Number 类的类型,或者 T 是实现了 XX 接口的类型

    tip: 方法声明


    访问权限>>方法类型>>返回类型>>方法名称>>参数列表>>方法体

    • 方法声明

      • ①修饰符:修饰符,这是可选的,告诉编译器如何调用该方法。定义了该方法的访问类型。
      • ②返回值类型 :方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作,但没有返回值。在这种情况下,returnValueType 是关键字void。
      • ③方法名:是方法的实际名称。方法名和参数表共同构成方法签名。
      • ④参数类型:参数像是一个占位符。当方法被调用时,传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的,方法可以不包含任何参数。
      • ⑤方法体:方法体包含具体的语句,定义该方法的功能。

    我的博客来康好康的 不困.top

    展开全文
  • Java 泛型概述

    2017-08-20 16:48:49
    1 什么是泛型 泛型的本质就是参数化类型,参数化类型重要性在于,允许创建一些类、接口和方法,其 所操作的数据类型被指定为参数。例如我们可以使用泛型创建一个类,在这个类中可以自动使 用不同类型的数据。 ...

     

     

    1 什么是泛型

    泛型的本质就是参数化类型,参数化类型重要性在于,允许创建一些类、接口和方法,其

    所操作的数据类型被指定为参数。例如我们可以使用泛型创建一个类,在这个类中可以自动使

    用不同类型的数据。

    class GenericClass<T>{

    }

    2 泛型的作用

    泛型的作用表现在,在没有泛型之前,可以使用Object 来表示或者创建通用的类、接口和

    方法,但是这样作带来后果是需要作强制类型转换,而这种转换的条件是开发人员必须预知实

    际的参数类型,同时如果强制类型转换错误,编译器在编译时并不检查或提示转换错误,但是

    一旦在运行时发现错误则会产生异常,这对于一个程序来说是非常的不安全。

    而泛型的作用则恰恰体现在程序编译时就对类型进行检查,同时不必再进行强制类型转换,

    因此处理过程得到简化,代码的重用性高,并且又安全。

     

    3 泛型相关概念

    在学习如何使用泛型之前,还必须要了解 2 个重要的概念:

    1、参数化类型

    2、类型变量

    参数化类型:参数化类型包含一个类或者接口,以及实际的类型参数列表。

    类型变量:是一种非限定性标识符,用来指定类、接口或者方法的类型

     

     

    4 如何引入泛型

    下面我们就通过一个简单的例子来看看如何在程序中引入泛型

    class GenericClass<T>{

    private T obj; //指定了类变量的类型

    public GenericClass(T obj){

    this.obj=obj;

    }

     

    public T getObj(){ //指定了方法的返回值类型

    return obj;

    }

    }

    与普通的类不同,使用泛型定义的类可以拥有一个或多个类型的类。下面我们就来看一个

    应用了泛型的类的结构:

    我们首先来看类型变量的使用:使用大写的英文字母T 作为类型变量的名称,放置在一对

    尖括号内,并放在类名的后面;

    我们还可以使用类型变量指定方法的返回类型以及域和局部变量的类型

    在使用类型变量时还要注意一些规范的使用

    1、类型变量要使用大写字母,且比较短

    2、在Java 的类库中,使用变量E 来表示集合的元素类型

    3、使用字母K 和V 表示关键字和值的类型

    4、字母T 表示任意类型

    在使用泛型时,使用实际的类型来代替类型变量就可以实例化泛型类型。下面我们来看一

    个具体的泛型应用

    public class GenericDemo{

    public static void main(String[] args) {

    GenericClass<String> ge1 = new GenericClass<String>("this is String object");

    ge1.showType();

    GenericClass<Integer> ge2 = new GenericClass<Integer>(100);

    ge2.showType();

    }

    }

    class GenericClass<T>{

     

    private T obj;

    public GenericClass(T obj){

    this.obj=obj;

    }

    public T getObj(){

    return obj;

    }

    public void showType(){

    System.out.println("obj 的类型是"+obj.getClass().getName());

    }

    }

    在GenericDemo 类中,分别创建了GenericClass 类的2 个实例,一个使用String 类型替

    代了类型变量T,并将字符串赋予了成员变量obj。另一个使用了Integer 类型代替了类型变量

    T,同时将100 赋值给了类的属性那个obj。

    那么在GenericClass 类中的showType()方法能够区分出域变量是String 类型还是Integer

    类型吗,我们通过运行程序的效果来进行检验。

    通过运行输出我们可以清楚的发现GenericClass 类可以识别出,实际传递的数据类型并对

    obj 进行赋值。换句话说就是GenericClass<T>在使用中,能够根据T 形参的实际类型,对应创

     

    建多个逻辑形式的子类,例如 GenericClass<String >,GenericClass<Integer>等。

     

    5 泛型类

    5.1 什么是泛型类

    什么是泛型类,简单的说就是具有一个或者多个类型变量的类。

    5.2 如何定义泛型类

    泛型类的定义比较简单,只要在类名的后面添加一对尖括号,并声明类型参数列表即可。

    语法:

    访问控制符 class className<TypeList>

    TypelIst:表示类型参数列表,每个类型变量之间以逗号分隔

    例如:

    public class GenericClass<T>{

    }

    5.3 创建泛型类的实例

    创建泛型类实例时,使用指定的实际类型代替类型参数列表中的类型变量即可。

    语法:

    new className<TypeList>(argList)

    TypelIst:表示类型参数列表,每个类型变量之间以逗号分隔

    argList:表示参数列表,同样以逗号分隔

    例如:

    new GenericClass<String>(“this is String object”)

    GenericClass<T>是比较常见的泛型类,在定义泛型类时,还可以指定多个类型参数,下面

    我们就来看一个具有两个类型参数的泛型类

    class GenericDemo<T,V>{

    private T a;

    private V b;

    public GenericDemo(T a,V b){

    this.a = a;

     

    this.b = b;

    }

    public void showType(){

    System.out.println("a 的类型是"+a.getClass().getName());

    System.out.println("b 的类型是"+b.getClass().getName());

    }

    }

    与GenericClass<T>类不同的是,在GenericDemo<T,V>类中定义了两个类型参数,分别是

    形参T,和形参V。那么这两个类型变量的具体类型并不知道。注意当在一个泛型中,需要声明

    多个类型参数时,只需要在每个类型参数之间使用逗号将其隔开即可。

    由于GenericDemo<T,V>设置两个类型参数,因此在实例化泛型类时,就需要传递两个类型

    参数。下面我们来看一下实例化GenericDemo<T,V>的代码

    public class Demo{

    public static void main(String[] args) {

    GenericDemo<String,Integer> ge1 = new

    GenericDemo<String,Integer>("Jack",23);

    ge1.showType();

    }

    }

    在创建实例时,分别使用了String 和Integer 代替了形参T 和V,当然对于T 和V 两个形

    参,我们可以使用同一数据类型进行替代,只不过这样的话就不需要设置两个参数类型了。

     

     

    6 泛型接口

    6.1 什么是泛型接口

    什么是泛型接口,泛型接口就是拥有一个或多个类型变量的接口

    6.2 如何定义泛型接口

    泛型接口的定义方式与定义泛型类类似。

    语法:

     

    访问控制符 interface interfaceName<TypeList>

    TypeList:表示由逗号分隔的一个或多个类型参数列表

    而实现泛型接口的类,也必须要指定参数类型。

    语法:

    Class className<TypeList> implements interfaceName<TypeList>

    使用泛型接口时有几点需要注意:

    1、一旦建立类型参数,在实现时将它不加修改地直接传递给接口即可

    2、如果一个实现了一个泛型接口,那么这个类必须也是泛型

    3、当一个实现了一个特定类型的泛型接口,这个类不必指定为泛型

    泛型接口的优势:

    1、针对不同的数据类型进行实现

    2、允许对这些接口的数据类型进行限制

     

     

    7 泛型方法

    7.1 什么是泛型方法

    泛型方法实际上就是带有参数类型的方法

    需要特别注意的是,定义泛型方法与方法所在的类、或者接口是否是泛型类或者泛型接口

    没有直接的联系,也就是说无论是泛型类还是非泛型类,如果需要就可以定义泛型方法。

    7.2 如何定义泛型方法

    语法:

    访问修饰符 <类型参数> 返回值 方法名(类型参数列表)

    例如:

    public <String> void showName(String s){}

    注意在泛型方法中,类型变量是放置在访问修饰符与返回值之间。

    调用泛型方法的语法是:

    方法名称(参数列表)

     

    7.3 如何使用泛型方法

    了解了如何定义泛型方法和调用泛型方法后,我们通过一个实际的泛型方法应用来了解如

    何使用泛型方法。

    public class GenericMethod {

    public <Integer> void showSize(Integer o){

    System.out.println(o.getClass().getName());

    }

    public static void main(String[] args) {

    GenericMethod gm = new GenericMethod();

    gm. showSize(10);

    }

    }

    展开全文
  • Java泛型概述

    2021-06-05 17:22:26
    泛型 JDK泛型是JDK1.5中引入的一个新特性,其本质是参数化类型,把类型作为参数传递 常见形式有泛型类、泛型接口、泛型方法 语法: ​ <T,…> T成为类型占位符,表示一种引用类型 好处: ​ (1)提高代码...
  • 泛型概述在前面学习集合时,我们都知道集合中是可以存放任意对象的,只要把对象存储集合后,那么这时他们都会被提升成Object类型。当我们在取出每一个对象,并且进行相应的操作,这时必须采用类型转换。大家观察下面...
  • 泛型概述 泛型: 是JDK5中引入的特性,它提供了编译时类型安全检测机制,该机制允许在编译时检测到非法的类型; 它的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数; 参数化类型: 就是将类型由原来的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,513
精华内容 9,005
关键字:

java泛型的概述

java 订阅