import java.util.*;

public class Test {
    public static void main(String[] args) {
//        GenericMethods.test();
//        GenericVarargs.test();
        BasicGeneratorDemo.test();
    }
}

/*
    如论合适,如果使用泛型方法可以取代将整个类泛型化,那么就应该只使用泛型方法
    因为它可以使事情更清楚明白。另外,对于一个static的方法而言,无法访问泛型类
    的类型参数,所以,如果static方法需要使用泛型的能力,就必须使其成为泛型方法
 */

class GenericMethods {
    public <T> void f(T x) {
        System.out.println(x.getClass().getName());
    }

    public static void test() {
        GenericMethods gm = new GenericMethods();
//        gm.f("");
//        gm.f(1);
//        gm.f(1.0);
//        gm.f('c');
//        gm.f(gm);
        gm.f(New.map());
    }
}

/*
    需求:
        利用方法的推导功能,简化我们创建集合类时的编码,但是这个工作
        现在已经不需要了,因为IDE和编译器都可以满足自动推导的功能。
 */
class New {
    public static <K,V> Map<K,V> map() {
        return new HashMap<>();
    }
}

/*
    类型推导只对赋值操作有效果,其他时候并不起作用。如果你将一个泛型方法
    调用的结果(例如New.map())作为参数,传递给另一个方法时,这时候编译
    器并不会执行类型推导。这种情况下,编译器认为:调用泛型方法后,其返回值
    被赋给了一个Object类型的变量
        ——现在好像可以哦
 */
class LimtsOfInference {
    static void f(Map<String, List<? extends Map>> arg) {

    }

    static void test() {
        f(New.map());
    }
}
/*
    泛型方法中,显式指明类型的语法。要显式指明类型,必须在点操作符
    与方法名之间插入尖括号,然后把类型置于尖括号内。
        ——这些知识点,有点不适用了,现在
 */
class LimtsOfInference2 {
    static void f(Map<String, List<? extends Map>> arg) {

    }

    static void test() {
        f(New.<String,List<? extends Map>>map());
    }
}

/*
    15.4.2 可变参数与泛型方法
 */
class GenericVarargs {
    public static <T> List<T> makeList(T... args) {
        List<T> result = new ArrayList<>();
        for (T item : args) {
            result.add(item);
        }
        return result;
    }

    static void test() {
        List<String> ls = makeList("A");
        System.out.println(ls);

        ls = makeList("A", "B", "C");
        System.out.println(ls);

        ls = makeList("adfasdfsafsdf".split(""));
        System.out.println(ls);
    }
}

/*
    15.4.3 用于Generator的泛型方法
 */
interface Generator<T>{
    T next();
}
class Generators {
    //给我一个容器,给我一个生成器,我帮你把容器填满,只省下了几行for循环的代码
    public static <T> Collection<T> fill(Collection<T> coll, Generator<T> gen, int len) {
        ; i < len; i++) {
            coll.add(gen.next());
        }
        return coll;
    }
}

/*
    15.4.4 一个同游的Generator

    下面的程序,可以为任何类构造一个Generator,只要该类具有默认的构造器,为了
    减少类型的声明,它提供了一个泛型的方法,用于生成BasicGenerator。我感觉我
    上一个小节的代码,也可以为任何类构造了一个Generator啊

    我觉得真正的区别会在这儿,以往的Generator,是需要自己去实现next()部分的
    代码的,而这个Generator却不用,你传给它一个Class对象,它就能为你生成许多
    个对象,是真正意义上的简化了操作
 */
class BasicGenerator<T> implements Generator<T> {

    private Class<T> type;

    public BasicGenerator(Class<T> type) {
        this.type = type;
    }

    @Override
    public T next() {
        try {
            return type.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static <T> Generator<T> create(Class<T> type) {
        return new BasicGenerator<>(type);
    }
}

class CounterObject {
    ;
    private final long id = counter++;

    public long id() {
        return id;
    }

    public String toString() {
        return "Counted Object "+id;
    }
}

class BasicGeneratorDemo {
    static void test() {
        Generator<CounterObject> g = BasicGenerator.create(CounterObject.class);
        ; i < ; i++) {
            System.out.println(g.next());
        }
    }
}

/*
    15.4.5 简化元组的使用
 */

class TwoTuple<A, B> {
    public final A first;
    public final B second;

    public TwoTuple(A first, B second) {
        this.first = first;
        this.second = second;
    }

    public String toString() {
        return "(" + first + "," + second + ")";
    }
}

/*
    这个方案只是在创建的时候,给简化了一下,统一了一下创建的接口
 */
class Tuple {
    public static <A, B> TwoTuple<A, B> tuple(A a, B b) {
        return new TwoTuple<>(a, b);
    }
}

/*
    问题:
        方法f()返回一个参数化的TwoTuple对象,而f2()返回的是非参数化的
        TwoPuple对象。在这个例子中,编译器并没有f2()的警告信息,因为我们
        并没有将其返回值作为参数化对象使用。在某种意义上,它被“向上转型”为
        一个非参数化的TwoTuple。然而,如果试图将f2()的返回值转型为参数化
        的TwoTuple,编译器就会发出警告
            ——有点尴尬,参数化其实就是指的泛型化
 */
class TupleTest {
    static TwoTuple<String, String> f() {
        return Tuple.tuple("AAA","BBB");
    }

    static TwoTuple f2() {
        return  Tuple.tuple("BBB","CCC");
    }

    static void test(){}
}

/*
    15.4.6 一个Set实用工具

    需求:
        用Set表示集合的各种关系,如交集、并集、、补集
 */
class Sets {
    public static <T> Set<T> union(Set<T> a, Set<T> b) {
        Set<T> result = new HashSet<>(a);
        a.addAll(b);
        return result;
    }

    public static <T> Set<T> intersection(Set<T> a, Set<T> b) {
        Set<T> result = new HashSet<>(a);
        result.retainAll(b);
        return result;
    }

    public static <T> Set<T> difference(Set<T> superset, Set<T> subset){
        Set<T> result = new HashSet<>(superset);
        result.retainAll(subset);
        return result;
    }

    public static <T> Set<T> complement(Set<T> a, Set<T> b) {
        return difference(union(a,b),intersection(a,b));
    }
}

enum Letters{
    A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z
}

/*
    EnumSet:
        用来从enum直接创建Set,在这儿,我们向static方法EnumSet.range()传入某个范围的
        第一个元素和最后一个元素,然后它将返回一个Set,其中包括该范围内的所有元素
 */

class LettersDemo {
    static void test() {
        /*
            我看案例中,有一个import static.generics.watercolors.Watercolos.*
            又看到他解释说:为了方便起见(可以直接使用enum中的元素名),下面的实例以
            static的方式引入Watercolors。
                ——这种写法,我从来没有用过,标记一下
         */
        Set<Letters> l1 = EnumSet.range(Letters.A, Letters.D);
        //。。。
    }
}

Java编程思想:泛型方法的更多相关文章

  1. Java编程思想(11~17)

    [注:此博客旨在从<Java编程思想>这本书的目录结构上来检验自己的Java基础知识,只为笔记之用] 第十一章 持有对象 11.1 泛型和类型安全的容器>eg: List<St ...

  2. 《Java编程思想》读书笔记

    前言 这个月一直没更新,就是一直在读这本<Java编程思想>,这本书可以在Java业界被传神的一本书,无论谁谈起这本书都说好,不管这个人是否真的读过这本书,都说啊,这本书很好.然后再看这边 ...

  3. Java编程思想(后)

    Java编程思想(后) 持有对象 如果一个程序只包含固定数量的且其生命期都是已知的对象,那么这是一个非常简单的程序. Java中的库基本类型: List, Set, Queue和Map --- 称为集 ...

  4. Java中的泛型 --- Java 编程思想

    前言 ​ 我一直都认为泛型是程序语言设计中一个非常基础,重要的概念,Java 中的泛型到底是怎么样的,为什么会有泛型,泛型怎么发展出来的.通透理解泛型是学好基础里面中非常重要的.于是,我对<Ja ...

  5. JAVA编程思想——分析阅读

    需要源码.JDK1.6 .编码风格参考阿里java规约 7/12开始 有点意识到自己喜欢理论大而泛的模糊知识的学习,而不喜欢实践和细节的打磨,是因为粗心浮躁导致的么? cron表达式使用 设计能力.领 ...

  6. Java编程思想 笔记

    date: 2019-09-06 15:10:00 updated: 2019-09-24 08:30:00 Java编程思想 笔记 1. 四类访问权限修饰词 \ 类内部 本包 子类 其他包 publ ...

  7. 《Java编程思想》读书笔记(二)

    三年之前就买了<Java编程思想>这本书,但是到现在为止都还没有好好看过这本书,这次希望能够坚持通读完整本书并整理好自己的读书笔记,上一篇文章是记录的第一章到第十章的内容,这一次记录的是第 ...

  8. JAVA编程思想(第四版)学习笔记----4.8 switch(知识点已更新)

    switch语句和if-else语句不同,switch语句可以有多个可能的执行路径.在第四版java编程思想介绍switch语句的语法格式时写到: switch (integral-selector) ...

  9. 《Java编程思想》学习笔记(二)——类加载及执行顺序

    <Java编程思想>学习笔记(二)--类加载及执行顺序 (这是很久之前写的,保存在印象笔记上,今天写在博客上.) 今天看Java编程思想,看到这样一道代码 //: OrderOfIniti ...

  10. #Java编程思想笔记(一)——static

    Java编程思想笔记(一)--static 看<Java编程思想>已经有一段时间了,一直以来都把笔记做在印象笔记上,今天开始写博客来记录. 第一篇笔记来写static关键字. static ...

随机推荐

  1. textblock的LineHeight的调整

    原文:textblock的LineHeight的调整 <TextBlock Width="113.594" Height="73.667" Text=&q ...

  2. GIS基础软件及操作(六)

    原文 GIS基础软件及操作(六) 练习六.空间分析的应用 1.加深对缓冲区分析基本原理.方法的认识:2.熟练掌握距离制图创建缓冲区技术方法.3.掌握利用缓冲区分析方法解决地学空间分析问题的能力. 1. ...

  3. 毕设(三)NotifyIcon

    NotifyIcon是一个比较特殊的组件,其特殊之处是既可以把它归类到控件中,也可以把它归类到组件中.这是因为将其拖放到设计窗体后,我们并不能马上看到它的界面(像组件),而是在运行时才能看到它(像控件 ...

  4. ASP.NET MVC控制器Controller

    控制器的定义 MVC模式下的控制器(Controller)主要负责响应用户的输入,并且在响应时可能的修改模型(Model). 之前的URL访问,通常是通过指定服务器的路径来实现,如访问URL:http ...

  5. Qt静态编译时使用OpenSSL有三种方式(不使用,动态使用,静态使用,默认是动态使用)

    When compiling Qt you can choose one of these options based on the configure command line: no OpenSS ...

  6. Firemonkey实现Mac OS程序中内嵌浏览器的功能(自己动手翻译,调用苹果提供的webkit框架)

    XE系列虽然可以跨平台,但是在跨平台的道路上只是走了一小半的路,很多平台下的接口都没实现彻底,所以为了某些功能,还必须自己去摸索. 想实现程序中可以内嵌浏览器的功能,但是Firemonkey还没有对应 ...

  7. visual studio添加docker支持简记

    很久以前学过一段时间的docker,那时装了电脑卡得受不了,学了一会就卸载了,最近电脑又装上了docker,感觉好像没有以前这么卡了,还是同一台电脑surface pro4, 试了一下visual s ...

  8. Qt 设置背景图片3种方法(三种方法:QPalette调色板,paintEvent,QSS)

    方法1. setStylSheet{"QDialog{background-image:url()"}}  //使用styleSheet 这种方法的好处是继承它的dialog都会自 ...

  9. Python正则表达式进阶-零宽断言

    1. 什么是零宽断言 有时候在使用正则表达式做匹配的时候,我们希望匹配一个字符串,这个字符串的前面或后面需要是特定的内容,但我们又不想要前面或后面的这个特定的内容,这时候就需要零宽断言的帮助了.所谓零 ...

  10. 简单学习js

    由于是个前端小白,通过这一两天的学习html,css,js和jquery等,基本上前端会用了,而且熟悉我博客的人来说,没错,我把自己的博客给优化了一下(一些大佬都是禁用模板的所有样式,然后自己设计页面 ...