泛型简单探索

本文是阅读《ThinkInJava》的笔记。

写一个元组

import java.util.Date;

/**
 * Created by jay.zhou on 2018/7/3.
 */
//三元组，不提供get/set方法，调用的话，直接 对象.属性
public class ThreeTuple<A,B,C> {
    public final A a;

    public final B b;

    public final C c;

    //必须通过构造函数初始化，因为持有的对象是final的
    public ThreeTuple(A a, B b, C c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    @Override
    public String toString() {
        return "ThreeTuple{" +
                "a=" + a +
                ", b=" + b +
                ", c=" + c +
                '}';
    }

    public static final ThreeTuple<String,Integer,Date> function(){
        ThreeTuple<String,Integer,Date> threeTuple = new ThreeTuple<>("a",3,new Date());
        System.out.println(threeTuple.a);
        System.out.println(threeTuple.b);
        System.out.println(threeTuple);
        return new ThreeTuple<>("a",3,new Date());
    }

    public static void main(String[] args) {
        function();
    }
}

写一个基于泛型的小队列。

package com.ssi.domains.base.entity;

/**
 * Created by jay.zhou on 2018/7/3.
 */
public class MyLinkedList<T> {
    //自制一个嵌套类
    private static class MyNode<T>{
        //内部存储的数据
        T element;
        //下一个节点的引用
        MyNode<T> next;
        //通过构造器接收参数
        public MyNode(T element, MyNode<T> next) {
            this.element = element;
            this.next = next;
        }
    }

    //最后一个节点的引用
    MyNode<T> last;

    //第一节点的引用
    MyNode<T> first;

    /**
     * 添加元素
     *
     * @param element
     */
    public void push(T element){
        //先封装元素
        MyNode<T> node = new MyNode<>(element,null);
        //第一次添加数据，last会为null。
        //如果last为null，第一个添加进来的元素，既是第一个也是最后一个
        if(last == null){
            //第一个添加的是第一个
            first = node;
            //也是最后一个
            last = node;
            return ;
        }

        //如果有第一个节点，那么第一个节点的下一个节点就是新添加的节点
        last.next = node;
        //现在，新插入的节点，就是最后一个节点了
        last = node;
    }


    public void list(){
        //遍历的话，从第一个开始遍历
        while (first !=null){
            System.out.println(first.element);
            //打印出来后，把头指针指向第二个元素
            first = first.next;
        }

    }

    public static void main(String[] args) {
        MyLinkedList<String> list = new MyLinkedList<>();
        list.push("a");
        list.push("b");
        list.push("c");
        list.list();//运行结果  a  b  c
    }



}

工厂方法模式的泛型代码

/**
 * Created by jay.zhou on 2018/7/3.
 */
public interface Factory<T> {
    T create();
}

泛型方法

加在类上的泛型，由第一次构造此对象的时候指明泛型。

加载方法的上泛型，由第一次调用此方法的时候指明，在返回值类型前面加上泛型

方法上的泛型相当于无限重载

public <T> void doSomething(T arg){
	
}

public <T> T doAnything(T arg){
	return T;
}

制作一个存放不同元素的集合

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Created by jay.zhou on 2018/7/3.
 */
public class CollectionUitls {
    private CollectionUitls() {
    }

    public static <T> List<T> createList(T... args) {
        List<T> list = new ArrayList<>();
        for (T arg : args) {
            list.add(arg);
        }
        return list;
    }

    public static <T> Set<T> createSet(T... args) {
        Set set = new HashSet<>();
        for (T arg : args) {
            set.add(arg);
        }
        return set;
    }

}

为什么有的类要带泛型
一个类由多个属性组成

因为这个类中至少有一个属性，其类型不确定。

或者是另外一种情况，一个方法的参数不确定，并且返回值是跟这个泛型有关的类型。比如List<T>

猜你喜欢