Java-泛型，枚举，注解

标签：夏天   泛型类   ted   获取   nts   inner   泛型   autumn   dep   

1 泛型类

package demo;

public class FanXingLei {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        A<String> a1=new A<String>();//在new A的对象指定泛型的类型String
        a1.serKey("xxxx");//对象使用serKey(T key)方法，中的key形参就是string
        String s=a1.getKey();//T getKey(),返回值就有new对象确定返回值是string
        
        A a2=new A();//不指定泛型，相当于制定了一个object类型
        a2.serKey(new Object());
        Object object=a1.getKey();
        
        //同样的类，但是在new对象时泛型指定不同的数据类型，这些对象不能互相赋值
        a1=a2;
    }

}
class A<T>{
    private T key;
    public void serKey(T key) {
        this.key=key;
    }
    public T getKey() {
        return this.key;
    }
}

2.泛型接口

package demo;

public class FanXingJieKou {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        B1<Object> b1=new B1<Object>();
        B1<String> b2=new B1<String>();
        
        B2 b3=new B2();
    }

}
interface IB<T>{
    T test(T t);
}
//未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需要将泛型的声明一起加到类中
class B1<T> implements IB<T>{
    public T test(T t) {
        return t;
    }
}
//如果实现接口时指定接口泛型的具体类型数据，这个类实现接口所有方法的位置都要泛型替换实际的具体数据类型
class B2<String> implements IB<String>{
    public String test(String t) {
        return t;
    }
}

3.泛型方法

package demo;

public class FanXingFangFa {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Cc<Object> c=new Cc<Object>();
        c.test("xxx");
        //泛型方法，在调用之前没有固定的数据类型
        //在调用时，传入参数是什么类型，就会把泛型改成是什么类型
        //也就是说,泛型方法会在调用时确定泛型距离数据类型
        Integer i=c.test1(2);
        Boolean b=c.test1(true);//传递参数是Boolean,泛型就固定成Boolean,返回值就是Boolean
    }

}
class Cc<E>{
    private E e;
    
    public static void test3() {
        //在静态方法中，不能使用类定义泛型，如果要使用泛型，只能使用静态方法
//		System.out.println(this.e);
    }
    
    //无返回值的泛型方法
    public <T> void test(T s) {
        //在类上定义的泛型，可以在普通的方法中使用
        System.out.println(this.e);
        T t=s;
    }
    //有返回值的泛型方法
    public <T> T test1(T s) {
        return s;
    }
    //形参为可变参数的泛型方法
    public <T> void test2(T...strs) {
        for(T s:strs) {
            System.out.println(s);
        }
    }       
}

4.泛型通配符 ？

5.枚举

package meiju;

public class Test1 {
    public static  void main(String[] args) {
        //这段代码就是获取一个Season对象
        Season spring=Season.SPRING;
        spring.showInfo();
        
        Season spring2=Season.SPRING;
        System.out.println(spring2.equals(spring));
    }
}
enum Season{
    SPRING("春天","春暖花开"),//此处返回的是一个枚举对象，此处相当于调用有参的私有构造private Season(String name,String desc)
    SUMMER("夏天","炎炎夏日"),
    AUTUMN("秋天","秋高气爽"),
    WINNER("冬天","寒风瑟瑟");
    
    private final String name;
    private final String desc;
    
    private Season(String name,String desc) {
        this.name=name;
        this.desc=desc;
    }
    public void showInfo() {
        System.out.println(this.name+":"+this.desc);
    }
}

6.注解

@Override:限定重写父类方法，该注释只能用于方法
@Deprecated:用于表示某个程序元素（类，方法等）已过时
@SuppressWarnings:抑制编译器警告

Java-泛型，枚举，注解

标签：夏天   泛型类   ted   获取   nts   inner   泛型   autumn   dep   

原文地址：https://www.cnblogs.com/dongxuelove/p/13029687.html