Java泛型與註解全面分析講解

//T標誌可以任意起名-----若此處有多個標誌時，使用時必須為每個泛型指定資料型別
public class Student<T> {
    private T name;
    private T age;
    public void show(){
        System.out.println("name:"+name+"age:"+age);
    }
    public Student() {
    }
    public Student(T name, T age) {
        this.name = name;
        this.age = age;
    }
    public T getName() {
        return name;
    }
    public void setName(T name) {
        this.name = name;
    }
    public T getAge() {
        return age;
    }
    public void setAge(T age) {
        this.age = age;
    }
}

public class StudentTest {
    public static void main(String[] args) {
        Student<Integer> stu=new Student<Integer>(33,44);
        stu.show();
        //若指定泛型型別預設為Object
        Student<String> stu1=new Student<>("張三","22");
        stu1.show();
        Student stu2=new Student("李四","55");
        String age = (String) stu2.getAge();//若想使用真正的型別接受，那麼必須進行強轉
        System.out.println(age);
    }
}

public class Test04 {
    public static void main(String[] args) {
            Info<Integer> i=new Info<>();
            i.setVar(25);
            fun(i);
            Info<String> i2=new Info<>();
            i2.setVar("張三");
            fun(i2); //如果下面不是使用萬用字元？則會報錯  原因是如果為泛型型別：不但要求資料型別相同之外還要求泛型型別也匹配。
           Info<Double> i3=new Info<>();
           i3.setVar(25.5);
           fun(i3);
            //能不能設定泛型型別可以接受任意的型別呢? 我們可以使用同設定?
    }
    public static void fun(Info<?> info){
         info.show();
    }
}
//T標誌可以任意起名.----> 那麼在建立物件時，必須為每個泛型指定資料型別。
class Info<T>{
    private T var;
    public void show(){
        System.out.println("var========"+var);
    }
    public T getVar() {
        return var;
    }
    public void setVar(T var) {
        this.var = var;
    }
}

public class ShangXiaXianTest {
    public static void main(String[] args) {
        Info<Number> i=new Info<>();
         fun2(i);
         Info<Object> i3=new Info<>();
         fun2(i3);
         Info<Integer> i4=new Info<>();
         fun2(i4);
    }
    //傳遞的引數泛型型別必須為Number的父類別或者Number型別  下限
    public static void fun2(Info<? super Number> info){
        info.show();
    }
    //傳遞的引數泛型型別必須為Number的子類（注意String不是Number的子類）或者Number型別   上限
    public static void fun3(Info<? extends Number> info){
        info.show();
    }
    public static void fun(Info<?> info){
        info.show();
    }
}
class Info<T>{
    private T var;
    public void show(){
        System.out.println("var==============="+var);
    }
    public Info(T var) {
        this.var = var;
    }
    public Info() {
    }
    public T getVar() {
        return var;
    }
    public void setVar(T var) {
        this.var = var;
    }
}

public class JieKouTest {
    public static void main(String[] args) {
        Upan u=new Upan();
        u.name="小可愛";
        Mouse<String> mouse=new Mouse<>();
        mouse.t="5555";
        System.out.println(mouse.fun());
        System.out.println(u.fun());
    }
}
interface USB<T>{
    public static final String NAME="";//常數的命名必須全部大寫
    public T fun();
    //JDK1.8後新特性
    default void fun2(){
    }
    static void fun3(){
    }
}
//子類也實現泛型和父類別名相同的泛型
class Mouse<T> implements USB<T>{
    T t;
    @Override
    public T fun() {
        return t;
    }
}
//子類在實現介面時，確定泛型型別
class Upan implements USB<String>{
    public String name;
    @Override
    public String fun() {
        return name;
    }
}

public class factorTest {
        String hello = Student.fun("hello");
        Integer fun = Student.fun(25);
        Double fun1 = Student.fun(25.0);
         System.out.println(hello+"--"+fun+"--"+fun1);
}
class Student{
    //泛型方法： static靜態成員，隨著類的載入而被載入到JVM記憶體中 常數池
    public static <T> T fun(T t){
        return t;
    }
    //泛型方法： static靜態成員，隨著類的載入而被載入到JVM記憶體中 常數池
    public static <T> Info<?> fun1(Info<? extends T> t){
        return t;
    }
}
class Info<T>{
}

public class Test {
    public static void main(String[] args) {
        Info i=new Info();
        i.name="張三";
        i.show();
    }
}
//定義好註解了
@interface My{
   //註解屬性
}
//使用註解
@My
class Info{
    @My
    public String name;
    @My
    public void show(){
        System.out.println("show================="+name);
    }
}

public class Test {
    public static void main(String[] args) {
        Info i=new Info();
        i.name="張三";
        i.show();
    }
}
//定義好註解
//表示該註解可以使用的位置
@Target(value = {ElementType.TYPE,ElementType.METHOD})
//表示註解什麼時候生效--source--class[預設位元組碼有效]---runtime[反射時驗證]
@Retention(value = RetentionPolicy.RUNTIME)
//是否在生成api檔案時存在該註解
@Documented
//子類是否能繼承該註解，如果註解在定義時使用了下面這個元註解則能被子類繼承。
@Inherited
@interface My{
    String value(); //如果設定default預設值，那麼在使用該註解時可以不為該屬性賦值。
    int age() default 15;
    String[] hobby() default {};//
}
//使用註解 如果使用註解時有且僅有一個屬性沒有賦值，而且該屬性的名字value那麼在給該屬性賦值值，可以省略value，當寫其他內容時，不能省略value
@My(value = "hello",hobby = "游泳")
class Info{
    public String name;
    public void show(){
        System.out.println("show================="+name);
    }
}
class Student extends Info{
}