Java编程思想读书笔记——泛型(三)

最新推荐文章于 2021-06-25 22:49:22 发布
最新推荐文章于 2021-06-25 22:49:22 发布
阅读量337 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_21088863/article/details/78881327
版权
15.11 问题
15.11.1 任何基本类型都不能作为类型参数

对于基本类型，只能使用对应的包装类来作为类型参数。这又涉及到自动装箱和自动拆箱的问题，会对性能造成一定的影响。
Org.apache.commons.collectiions.primitives这一开源的框架中可以使用由基本类型作为类型参数的泛型。
自动装箱机制不能用于数组。
例如：

package com.mzm.chapter15;

import com.mzm.chapter16.RandomGenerator;

/**
 * 自动包装机制不能解决所有问题
 * 
 */
public class PrimitiveGenericTest {

    public static void main(String[] args) {
        String[] strings = FArray.fill(new String[7], new RandomGenerator.String(10));
        for(String s : strings) {
            System.out.println(s);
        }
        Integer[] integers = FArray.fill(new Integer[7], new RandomGenerator.Integer());
        for(int i : integers) {
            System.out.println(i);
        }

        //无法使用自动包装机制
        //int[] b = FArray.fill(new int[7], new RandomGenerator.Integer())
    }
}

class FArray {

    public static <T> T[] fill(T[] a, Generator<T> gen) {
        for(int i = 0; i < a.length; i++) {
            a[i] = gen.next();
        }
        return a;
    }

 }
15.11.2 实现参数化接口

一个类不能实现同一个泛型接口的两种变体，因为存在擦除。

package com.mzm.chapter15;

/**
 * 
 */
public class MutipleInterfaceVariants {
}

interface Payable<T> {

}

class Employee2 implements Payable<Employee2> {

}

//该类不能实现同一个泛型接口的不同类型参数版本
/*class Hourly extends Employee2 implements Payable<Hourly> {

}*/
15.11.3 转型和警告

对带有泛型类型参数的变量进行转型或者使用instanceof，不会有任何结果。

package com.mzm.chapter15;

/**
 * 
 */
public class GenericCast {

    public static final int SIZE = 10;

    public static void main(String[] args) {
        FixedSizeStack<String> strings = new FixedSizeStack<>(SIZE);
        for(String s : "A B C D E F G H I J".split(" ")) {
            strings.push(s);
        }
        for(int i = 0; i < SIZE; i++) {
            String s = strings.pop();
            System.out.print(s + " ");
        }
    }
}

class FixedSizeStack<T> {

    private int index = 0;
    private Object[] storage;

    public FixedSizeStack(int size) {
        storage = new Object[size];
    }

    public void push(T item) {
        storage[index++] = item;
    }

    /**
     * 由于擦除的存在，类型信息缺失，转型安全性未知
     * @return
     */
    @SuppressWarnings("unchecked")
    public T pop() {
        return (T)storage[--index];
    }
}

但有时泛型也确实有对转型的需要：

package com.mzm.chapter15;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.List;

/**
 * 
 */
public class NeedCasting {

    //@SuppressWarnings("unchecked")
    public void f(String[] args) throws Exception {
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(args[0]));
        List<Widget> shapes = (List<Widget>)in.readObject();
    }
}

注释@SuppressWarnings(“unchecked”)，执行编译：

注: NeedCasting.java使用了未经检查或不安全的操作。
注: 有关详细信息, 请使用 -Xlint:unchecked 重新编译。

如果执行javac -Xlint:unchecked NeedCasting.java，又会出现以下情况：

NeedCasting.java:13: 警告: [unchecked] 未经检查的转换
        List<Widget> shapes = (List<Widget>)in.readObject();
                                                         ^
  需要: List<String>
  找到:    Object
1 个警告

这样就造成既要求转型，又告知不应转型的情况。
解决这样的问题，必须使用JavaSE 5中引入的新的转型形式。

package com.mzm.chapter15;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.List;

/**
 * 
 */
public class ClassCasting {

    @SuppressWarnings("unchecked")
    public void f(String[] args) throws Exception {
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(args[0]));
        List<Widget> lw2 = List.class.cast(in.readObject());
    }
}
15.11.4 重载

这种形式的重载是不允许的，因为在擦除之后，出现了两个同样的方法。这一错误，可通过编译器看出。

package com.mzm.chapter15;

import java.util.List;

/**
 * 
 */
public class UseList<W, T> {

    void f1(List<T> v) {

    }

    /*void f1(List<W> v) {

    }*/
}
15.11.5 基类劫持了接口

类型参数中的类型是确定的，不允许是其子类。

package com.mzm.chapter15;

/**
 * Created by 蒙卓明 on 2018/1/1.
 */
public class ComparablePet implements Comparable<ComparablePet> {

    @Override
    public int compareTo(ComparablePet o) {
        return 0;
    }
}


/*
class Cat extends ComparablePet implements Comparable<Cat> {

}*/
package com.mzm.chapter15;

/**
 * 
 */
public class RestrictedComparablePets {
}

/**
 * Hamster虽然是ComparablePet的子类，但当其需要实现Comparable接口时，其类型参数也必须要是ComparablePet
 * 等价于Hamster是ComparablePet的子类即可
 */
class Hamster extends ComparablePet implements Comparable<ComparablePet> {

    public int compareTo(ComparablePet arg) {
        return 0;
    }
}

class Gecko extends ComparablePet {

    public int compareTo(ComparablePet arg) {
        return 0;
    }
}
15.12 自限定的类型
15.12.1 古怪的循环泛型

古怪的循环泛型(CRG)是指创建一个新类，其继承自一个泛型类型，接受自身类名作为泛型参数。

package com.mzm.chapter15;

/**
 * 创建一个新类，其继承自一个泛型类型，接受自身类名作为泛型参数
 * 
 */
public class CuriouslyRecurringGeneric extends GenericType<CuriouslyRecurringGeneric>{
}

class GenericType<T> {

}
package com.mzm.chapter15;

/**
 * 
 */
public class CRGWithBasicHolder {

    public static void main(String[] args) {
        Subtype st1 = new Subtype(), st2 = new Subtype();
        //新类SubType接受的参数和返回的值具有SubType类型，而不仅是基类BasicHolder类型
        st1.set(st2);
        Subtype st3 = st1.get();
        st1.f();
    }
}

class Subtype extends BasicHolder<Subtype> {

}

CRG的本质：父类用子类替代其参数。

15.12.2 自限定
package com.mzm.chapter15;


/**
 * 自限定
 * 
 */
public class SelfBounding {

    public static void main(String[] args) {
        A a = new A();
        a.set(new A());
        a = a.set(new A()).get();
        a = a.get();
        C c = new C();
        c = c.setAndGet(new C());
    }
}

/**
 * 自限定，泛型类以自身为泛型参数的边界
 * @param <T>
 */
class SelfBounded<T extends SelfBounded<T>> {

    T element;

    SelfBounded<T> set(T arg) {
        element = arg;
        return this;
    }

    T get() {
        return element;
    }
}

/**
 * 自限定主要是，在继承关系中，将子类作为父类(泛型类)的泛型参数
 */
class A extends SelfBounded<A> {

}

/**
 * 也可以使用其他参数
 */
class B extends SelfBounded<A> {

}

class C extends SelfBounded<C> {

    C setAndGet(C arg) {
        set(arg);
        return get();
    }
}

class D {

}

/*
 * 但是这一泛型参数必须是泛型类的子类才可
class E extends SelfBounded<D> {

}*/

class F extends SelfBounded {

}

自限定主要用于，定义一个泛型类的子类时，强制使用泛型类的子类作为其泛型参数(可以是自身或其他子类)。

package com.mzm.chapter15;

/**
 * 自限定用于泛型方法
 * 
 */
public class SelfBoundingMethods {

    static <T extends SelfBounded<T>> T f(T arg) {
        return arg.set(arg).get();
    }

    public static void main(String[] args) {
        A a = f(new A());
    }
}
15.12.3 参数协变

自限定类型可以产生协变参数类型——方法参数类型会随子类而变化。
方法的返回类型随子类而变化：

package com.mzm.chapter15;

/**
 * 非自限定情况
 */
public class CovariantReturnTypes {

    void test(DerivedGetter d) {
        Derived d2 = d.get();
    }
}

class Base {

}

class Derived extends Base {

}

interface OrdinaryGetter {
    Base get();
}

interface DerivedGetter extends OrdinaryGetter {
    /**
     * 非自限定情况通过显式重写父类的get()方法，返回子类类型
     * @return 子类类型
     */
    Derived get();
}
package com.mzm.chapter15;

/**
 * 
 */
public class GenericAndReturnTypes {

    void test(Getter g) {
        //子类Getter对象的返回类型为Getter
        Getter result = g.get();
        GenericGetter gg = g.get();
    }
}

/**
 * 自限定接口
 * @param <T> 泛型类自身作为泛型参数的边界
 */
interface GenericGetter<T extends GenericGetter<T>> {
    T get();
}

/**
 * 自限定情况，无需通过显式覆盖同名方法实现返回类型随子类变化，实际上已经完成方法的重写
 */
interface Getter extends GenericGetter<Getter> {

}

方法的参数类型随子类而变化：

package com.mzm.chapter15;

/**
 * 非自限定情况
 * Created by 蒙卓明 on 2018/1/6.
 */
public class OrdinaryArguments {

    public static void main(String[] args) {
        Base base = new Base();
        Derived derived = new Derived();
        DerivedSetter ds = new DerivedSetter();
        //在DerivedSetter类中，两个set()方法共存，说明出现重载
        ds.set(derived);
        ds.set(base);
    }
}

class OrdinarySetter {

    /**
     * 父类的set()方法
     * @param base 以Base类自身作为参数类型
     */
    void set(Base base) {
        System.out.println("OrdinarySetter.set(Base)");
    }
}

class DerivedSetter extends OrdinarySetter {

    /**
     * 非限定情况只能显式重载父类的set()方法，来实现方法参数类型随子类而变化
     * @param derived 以Base子类Derived类型作为参数类型
     */
    void set(Derived derived) {
        System.out.println("DerivedSetter.set(Derived)");
    }
}
package com.mzm.chapter15;


/**
 * 自限定情况
 * Created by 蒙卓明 on 2018/1/6.
 */
public class SelfBoundedSetterAndCovariantArguments {

    void testA(Setter s1, Setter s2, SelfBoundSetter sbs) {
        //接受自身类型变量
        s1.set(s2);
        //不接受父类SelfBoundSetter类型变量作为参数，只接受子类类型
        //s2.set(sbs);
    }
}

interface SelfBoundSetter<T extends SelfBoundSetter<T>> {
    void set(T arg);
}

/**
 * 自限定情况，则无需显式重载父类同名方法，但是实际上父类的同名方法已经被覆盖
 */
interface Setter extends SelfBoundSetter<Setter> {

}
package com.mzm.chapter15;

/**
 * 
 */
public class PlainGenericInheritance {

    public static void main(String[] args) {
        Base base = new Base();
        Derived derived = new Derived();
        DerivedGS dgs = new DerivedGS();
        //同时接受父类对象和子类对象作为方法参数，说明父类和子类的set()共存
        dgs.set(derived);
        dgs.set(base);
    }
}

/**
 * 非自限定
 * @param <T>
 */
class GenericSetter<T> {

    void set(T arg) {
        System.out.println("GenericSetter.set(Base)");
    }
}

class DerivedGS extends GenericSetter<Base> {

    /**
     * 非自限定只能显式重载父类的同名方法来实现方法参数类型随子类而变化
     * @param derived
     */
    void set(Derived derived) {
        System.out.println("DerivedGS.set(Derived)");
    }
}
15.13 动态类型安全

在向Java SE5之前的代码传递泛型容器时，旧代码可能会破坏泛型容器。Java SE5的java.util.Collections中有一组便利工具，可以解决在这种情况下类型检查问题。它们是静态方法:

checkedCollection();
checkedList();
checkedMap();
checkedSet();
checkedSortedMap();
checkedSortSet();

这些方法接受两个参数，第一个是容器对象，第二个是检查的类型。

package com.mzm.chapter15;

import com.mzm.chapter14.Cat;
import com.mzm.chapter14.Dog;
import com.mzm.chapter14.Pet;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 
 */
public class CheckedList {

    @SuppressWarnings("unchecked")
    static void oldStyleMethod(List probablyDogs) {
        probablyDogs.add(new Cat());
    }

    public static void main(String[] args) {
        List<Dog> dogs1 = new ArrayList<>();
        //针对dogs1，插入Cat类型对象没有问题
        oldStyleMethod(dogs1);
        List<Dog> dogs2 = Collections.checkedList(new ArrayList<>(), Dog.class);

        try {
            //针对dogs2，插入Cat类型对象抛出异常
            oldStyleMethod(dogs2);
        } catch (Exception e) {
            System.out.println(e);
        }

        //以父类作为检查类型，也没有问题
        List<Pet> pets = Collections.checkedList(new ArrayList<>(), Pet.class);
        pets.add(new Dog());
        pets.add(new Cat());
    }

}
15.14 异常

由于擦除的存在，catch语句不能捕获泛型类型的异常，而泛型类也不能直接或间接地继承自Throwable。
但是类型参数可以应用于方法的throws子句中，基于此，可以编写出随检查类型异常的类型而发生变化的泛型代码：

package com.mzm.chapter15;

import java.util.ArrayList;
import java.util.List;

/**
 * 
 */
public class ThrowGenericException {

    public static void main(String[] args) {
        ProcessRunner<String, Failure1> runner = new ProcessRunner<>();
        for(int i = 0; i < 3; i++) {
            runner.add(new Processor1());
        }

        try {
            System.out.println(runner.processAll());
        } catch (Failure1 e) {
            System.out.println(e);
        }

        ProcessRunner<Integer, Failure2> runner2 = new ProcessRunner<>();
        for(int i = 0; i < 3; i++) {
            runner2.add(new Processor2());
        }

        try {
            System.out.println(runner2.processAll());
        } catch (Failure2 e) {
            System.out.println(e);
        }
    }
}

/**
 * 该接口执行process()方法
 * @param <T> List中持有的对象类型
 * @param <E> 抛出的异常类型
 */
interface Processor<T, E extends Exception> {

    void process(List<T> resultCollector) throws E;

}

class ProcessRunner<T, E extends Exception> extends ArrayList<Processor<T, E>> {

    /**
     * 执行每一个存储在该容器中的Processor对象的process()方法
     * @return
     * @throws E
     */
    List<T> processAll() throws E {
        List<T> resultCollector = new ArrayList<>();
        for(Processor<T, E> processor : this) {
            processor.process(resultCollector);
        }
        return resultCollector;
    }

}

class Failure1 extends Exception {

}

class Processor1 implements Processor<String, Failure1> {

    static int count = 3;

    @Override
    public void process(List<String> resultCollector) throws Failure1 {
        if(count-- > 1) {
            resultCollector.add("Hep!");
        } else {
            resultCollector.add("Ho!");
        }
        if(count < 0) {
            throw new Failure1();
        }
    }
}

class Failure2 extends Exception {

}

class Processor2 implements Processor<Integer, Failure2> {

    static int count = 2;

    @Override
    public void process(List<Integer> resultCollector) throws Failure2 {
        if(count-- == 0) {
            resultCollector.add(47);
        } else {
            resultCollector.add(11);
        }

        if(count < 0) {
            throw new Failure2();
        }
    }
}
mzm1991
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
疯狂Java讲义-泛型
u011714517的博客
01-02 1142
泛型 本章思维导图 泛型入门 Java集合有个缺点——把一个对象“丢进”集合里之后，集合就会“忘记”这个对象的数据类型，当再次取出该对象时，该对象的编译类型就变成了Object类型（其运行时类型没变）。 编译时不检查类型的异常 下面代码将会看到编译时不检查类型所导致的异常。 import java.util.ArrayList; import java.util.List; public cl...
Java学习笔记——并发编程（三）
l903445981的博客
07-29 836
obj.wait()让进入object监视器的线程到waitSet等待obj.notify()在object上正在waitSet等待的线程中挑一个唤醒obj.notifyAll()让object上正在waitSet等待的对象全部唤醒它们都是线程之间协作的手段，都属于Object对象的方法。必须获得此对象的锁，才能调用这几个方法。log.debug("执行....");try{//让线程在obj上一直等待下去}catch(InterruptedExceptione){...
编译java文件提示使用或覆盖了已过时的 API，使用 -Xlint:deprecation命令重新编译，获取更详细的信息
热门推荐
hangxingkong的专栏
06-25 1万+
举个例子，假如在编译Test.java文件时，出现如下提示 注: Test.java使用或覆盖了已过时的 API。 注: 有关详细信息, 请使用 -Xlint:deprecation 重新编译。 原因：系统上安装的jdk版本较新，而你码代码过程中使用了过时的API编码规则 解决办法：使用 -Xlint:deprecation命令重新编译，获取更详细的提示信息。如有需要可查阅所安装jdk对应版本API，对过时代码进行修改 如：javac -Xlint:deprecation Test.java
请使用 -Xlint:deprecation 重新编译
qq_34884729的博客
11-29 7595
在编译的过程中出现了这个提示,但是并没有说明到底是哪一个类中出现的情况.  使用的是 gradle assembleDebug 注: /home/malin/malin_github/BilibiliLogin/app/src/main/Java/com/malin/animation/fragment/LoginFragment.java使用或覆盖了已过时的 API。  注: 有关
编译.java后出现：Note:checkUser.java uses unchecked or unsafe operations.Note:Recompile with -Xlint :unchecked for details.
KOOK_OKKO的专栏
05-25 1万+
 如果显示为中文就是：     注意： a.java 使用了未经检查或不安全的操作。     注意： 要了解详细信息，请使用 -Xlint:unchecked 重新编译。  其实是很简单，是因为用到了JAVA5.0的泛型，而5.0的泛型不做类型检查，例如ArrayList a =new ArrayList();a.add("hello");这样会出现警告，解决方法有以下
Java编程思想__泛型(三)
NULL
06-11 334
下面是使用模板的C++示例, 你将注意到用于参数化类型的语法十分相似,因为Java是受C++的启发。 template<class T> class Manipulator{ T obj; public: Manipulator(T x){ obj=x; } void maniput(){ obj.f(); } } class HasF{ public: void f(){ cout << "HasF
Java编程思想-笔记.docx
06-21
Java编程思想笔记 本笔记涵盖了Java编程思想的多个方面，包括访问权限控制、封装、继承、多态、接口、内部类、持有对象等。 访问权限控制 访问权限控制是为了把变动的事物与保持不变的事物区分开来。Java中有四种...
java基础学习笔记之泛型
09-02
泛型是Java编程语言中的一个重要特性，首次在JDK 1.5版本中引入，它允许程序员在定义类、接口和方法时使用类型参数，从而实现了类型的安全性和代码的复用性。泛型的主要目标是增强类型安全，避免在运行时出现...
java编程思想读书笔记
07-10
《Java编程思想》是 Bruce Eckel 的经典著作，这本书深入浅出地讲解了Java语言的核心概念和编程技术。这份读书笔记记录了读者在研读此书过程中的理解和体会，涵盖了从基础语法到高级特性的全面解析。以下是笔记中...
java编程思想读书笔记.rar
05-31
《Java编程思想》是 Bruce Eckel 的经典之作，这本书深入浅出地介绍了Java语言的核心概念和技术，对于初学者和有经验的程序员来说都是极好的学习资源。以下是对书中的主要知识点进行的详细解读： 1. **Java语言基础...
Java编程思想笔记(全)
最新发布
06-14
第 1 章 对象导论 第 2 章 一切都是对象 ...第 15 章 泛型 第 16 章 数组 第 17 章 容器深入研究 第 18 章 Java I/O 系统 第 19 章 枚举类型 第 20 章 注解 第 21 章 并发 第 22 章 图形化用户界面
Error:注: 某些输入文件使用或覆盖了已过时的 API。 注: 有关详细信息, 请使用 -Xlint:deprecation 重新编译。
铁树开花
10-21 1万+
Error:注: 某些输入文件使用或覆盖了已过时的 API。 注: 有关详细信息, 请使用 -Xlint:deprecation 重新编译。 注: 某些输入文件使用了未经检查或不安全的操作。 注: 有关详细信息, 请使用 -Xlint:unchecked 重新编译。 FAILURE: Build failed with an exception. 最近项目出现的一些问题可以在build中加
Hadoop学习之Win7下 Hadoop-2.4.0 Eclipse插件编译实践
一页林空
05-13 3398
一、准备工作            下载插件源码地址：https://github.com/winghc/hadoop2x-eclipse-plugin            下载ANT：http://www.apache.org/dist/ant/binaries/apache-ant-1.9.4-bin.zip 二、修改源码 1、修改ivy配置文件（hadoop2x-eclip
Java编程思想读书笔记——泛型(四)
mengzm的博客
01-28 343
15.15 混型 混型：混合多个类的能力，以产生一个可以表示混型中所有类型的类。 15.15.1 C++中的混型 15.15.2 与接口混合 使用接口产生混型效果： package com.mzm.chapter15; import java.util.Date; /** * */ public class Mixins { public static v
Java编程思想读书笔记——操作符
mengzm的博客
09-19 333
第三章 操作符 3.1 更简单的打印语句 3.2 使用Java操作符 操作符 接受一个或多个参数，并生成新的值。 操作数 操作符的参数。 几乎所有的操作符都只能操作基本数据类型。 例外：=、==和!=，这三个操作符可以操作所有对象。而’+’和’+=’可以操作String对象。 3.3 优先级 最简单的就是以括号明确规定计算顺序。 3.4 赋值 只能是=右
Java编程思想读书笔记——泛型(二)
mengzm的博客
01-28 331
15.7 擦除的神秘之处 泛型的类型与类型参数无关。 package com.mzm.chapter15; import java.util.ArrayList; /** * 泛型的类型不受类型参数的影响 * */ public class ErasedTypeEquivalence { public static void main(String[] args) {
Java编程思想读书笔记——访问权限控制
mengzm的博客
10-02 319
第六章 访问控制权限 6.1 包：库单元 默认包(未命名包)：.java文件(编译单元/转译单元)直接位于src目录下。 6.1.1 代码组织 类库 -> 包 -> 编译单元(包含一个public类和任意个非public类) package语句是.java文件的第一句非注释语句，它指明了该.java文件位于那一个包下。 .java文件的文件名必须与public类的类名相同(大小写敏感)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值