java核心(九)：泛型

package com.study.Type;

/**
 * 在声明类的时候，定义了两个泛型：T、A
 * @param <T>
 * @param <A>
 */
class Fruit<T, A>{
    private T name;
    private A size;

    public Fruit(T name, A size) {
        this.name = name;
        this.size = size;
    }

    public void getInfo(){
        System.out.println("name: "+this.name+" , size: "+this.size);
    }

    public T getName() {
        return name;
    }

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

    public A getSize() {
        return size;
    }

    public void setSize(A size) {
        this.size = size;
    }

}

public class Test {
    public static void main(String[] args) {
        Fruit<String,Integer> f1 = new Fruit<>("苹果",10);
        f1.getInfo();                   // name: 苹果 , size: 10
        String name2 = f1.getName();
        int size2 = f1.getSize();
        System.out.println(name2);      //  "苹果"
        System.out.println(size2);      //  10

        Fruit<String,String> f2 = new Fruit<>("苹果","直径10公分");
        f2.getInfo();                   // name: 苹果 , size: 直径10公分
    }
}

package com.study.Type;

/**
 * 接口使用泛型：T
 */
interface IFruit<T>{
    public void print(T t);
}

/**
 * 实现类继续使用泛型：T
 */
class Apple<T> implements IFruit<T>{
    @Override
    public void print(T t) {
        System.out.println(t+" , "+t.getClass());
    }
}

/**
 * 实现类不使用泛型，指定接口的泛型参数类型
 */
class Orange implements IFruit<String>{
    @Override
    public void print(String s) {
        System.out.println(s+" , "+s.getClass());
    }
}

public class Test {
    public static void main(String[] args) {
        IFruit<String> a1 = new Apple<String>();
        a1.print("苹果");         //  苹果 , class java.lang.String

        IFruit<Integer> a2 = new Apple<Integer>();
        a2.print(100);           //  100 , class java.lang.Integer

        IFruit<String> orange = new Orange();
        orange.print("橘子");     //  橘子 , class java.lang.String
        //orange.print(100);     //语法错误：Error:(43, 22) java: 不兼容的类型: int无法转换为java.lang.String


    }
}

class Test {
    public static void main(String[] args) {
        String str = print("苹果");
        System.out.println(str);    // 苹果

        int num = print(123);
        System.out.println(num);    //  123
    }

    /**
     * 
     * @param t ：   入参
     * @param <T> ： 声明一个泛型
     * @return
     */
    public static  <T> T print(T t){
        return t;
    }
}

package com.study.Type;

import java.util.Date;

    class Message<T> {
   private T msg;

    public Message(T msg) {
        this.msg = msg;
    }

    public T getMsg() {
        return msg;
    }
}


public class Test {
    public static void main(String[] args) {
        Message<String> f1 = new Message<>("苹果");
        print(f1);      //  苹果 , class java.lang.String

        Message<Integer> f2 = new Message<>(100);
        print(f2);      //  100 , class java.lang.Integer

        Message<Date> f3 = new Message<>(new Date());
        print(f3);      //  Fri Mar 08 15:26:25 CST 2019 , class java.util.Date
    }

    /**
     * 使用通配符"?"，来接受泛型
     * @param message
     */
    public static void print(Message<?> message){
        System.out.println(message.getMsg()+"  ,  "+message.getMsg().getClass());
    }
}

class GT<T>{
    /**
     * 泛型类的静态变量是共享的
     */
    public static int var = 0;

    public void nothing(T x){}
}

class StaticTest{
    public static void main(String[] args){
        GT<Integer> g1 = new GT<Integer>();
        g1.var = 1;
        System.out.println(g1.var);     // 1

        GT<String> g2 = new GT<String>();
        g2.var = 2;
        System.out.println(g1.var);     // 2
        System.out.println(g2.var);     // 2

        GT<Date> g3 = new GT<>();
        System.out.println(g1.var);     // 2
        System.out.println(g2.var);     // 2
        System.out.println(g3.var);     // 2
    }
}