Java的自学之旅11

• 泛型

public class Test {
    public static void main(String[] args) {
        List list=new ArrayList();
       list.add(1111);
        list.add("aaaa");
        list.add(true);
//        只能存字符串（阻拦）
        List<String> l=new ArrayList();
        l.add("ddd");
//        l.add(111);//只能存字符串（类型安全）这是编译期的问题不会进入运行阶段
    }
}

  A<String> a1=new  A<String>();//在new A对象指定泛型的类型String
        a1.setKey("fd");//使用 setKey(T key)方法中的key的形参就是String
        String s=a1.getKey();//  T getKey()返回值就有new固定就是String

        A<Integer> a2=new  A<Integer>();
        a2.setKey(122);
       Integer w=a2.getKey();

       A a3=new A();//不指定就是object类型
        //不同的数据类型不能赋值a1=a2;


    }
}
class A<T>{//此处的泛型T可以取任意名一般使用这个字母type
    private T key;
    public void setKey(T key){
        this.key=key;
    }

    public T getKey() {
        return this.key;
    }
}

public class Test1 {
    public static void main(String[] args) {
        B1<Object> b1=new  B1<Object>();//使用b1方法需要定义类型
        B1<String> b2=new  B1<String>();

        B2 b21=new B2();//b2直接使用

        Cc<Object> c=new  Cc<Object>();
        c.test("da");//泛型方法在调用之前没有固定的数据类型
        c.test1(23);//在调用时，传入的参数是什么类型就会把泛型改成什么类型
        c.test2(true);//在调用的时候确定类型
    }
}
interface IB<T>{
    T test(T t);
}
//未传入泛型实参时，与泛型类型定义相同，在声明类的实现需将泛型的声明也一起加到类中
class B1<T> implements IB<T>{
    @Override
    public T test(T t) {
        return null;
    }
}
//如果实现接口的时候制定接口的泛型的具体数据类型
//这个实现接口所有的方法的位置都是泛型替换实际地具体数据类型
class B2<T> implements IB<String>{
    @Override
    public String test(String s) {
        return null;
    }
}
class Cc<R>{
    private R r;//在类上定义的泛型可以在方法中去使用
    private static<T> void test3(T t){
        //在静态的方法中不能使用类中的泛型如果要使用只能使用静态方法自己定义的方法
        System.out.println(t);
    }
    public <T> void  test(T a){//无返回值泛型方法 public <T>
        T t=a;

    }
    public <T> T  test1(T a){//有返回值泛型方法 public <T>
       return a;

    }
    public <T> void  test2(T...strs){//形参为可变参数的泛型方法
        for (T s:strs){
            System.out.println(s);
        }
    }
}

import java.util.ArrayList;
import java.util.List;

public class Test2 {
    public static void main(String[] args) {
        Dd d=new  Dd();
        List<String>l1=new ArrayList<String>();
        d.test(l1);
        List<Integer>l2=new ArrayList<Integer>();
        d.test(l2);

        List<C1>lc=new ArrayList<C1>();
        d.test1(lc);

        List<D1>ld=new ArrayList<D1>();
        d.test1(ld);

//        List<B3>lb=new ArrayList<B3>();
//        d.test1(lb);
        
        d.test2(lc);
        List<A1>la=new ArrayList<A1>();
        d.test2(la);
//        d.test2(ld);
        
        List<IAImp1>li=new ArrayList<IAImp1>();
        d.test3(li);
//        d.test3(la);
    }
}
class Dd {
   public void test(List<?> list){//test方法需要一个list集合，不确定到底存的什么数据
       
   }
    public void test1(List<? extends C1> list){//list参数的元素数据类型是c1及其子类
       
    }
    public void test2(List<? super C1> list){//list参数的元素数据类型是c1及其父类

    }
    public void test3(List<? extends IA> list){//list参数的元素数据类型是 IA的实现类

    }
}
class A1{
    
}
class B3 extends  A1{

}
    class C1 extends  B3{

}
class D1 extends  C1{

}
interface IA{}
class IAImp1 implements  IA{}

• 枚举

public class Test3 {
    public static void main(String[] args) {//这段执行的是获取一个season的对象
        Season  spring=    Season.SPRING ;
        spring.showInfo();
        Season  autumn=    Season.AUTUMN ;
        autumn.showInfo();
        Season summer=    Season.SUMMER;
        summer.showInfo();
        Season winter=    Season.WINTER ;
        winter.showInfo();
        Season spring1=Season.SPRING;
        System.out.println(Season.SPRING);
        System.out.println(spring.equals(spring1));//每次执行这个SEASON.spring获得是相同的对象，枚举类的每个枚举都是单例模式
        spring1.test();
    }
}
enum Season implements ITest{
    SPRING("春天","春暖花开"),//此处相当于在调用有参的构造
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","寒风咧咧");
    private final String name;
    private final String desc;
    private Season(String name,String desc){
        this.desc=desc;
        this.name=name;

    }
    public void showInfo(){
        System.out.println(  this.name+":"+ this.desc);
    }

    @Override
    public void test() {
        System.out.println("这是实现的itest方法");
    }
}
interface ITest{
    void test();
}

输出结果

春天:春暖花开

秋天:秋高气爽

夏天:夏日炎炎

冬天:寒风咧咧

SPRING

true

这是实现的itest方法

Process finished with exit code 0

• 注解Annotation

import java.awt.*;
import java.lang.annotation.*;
import java.util.ArrayList;

public class Test4 {
    public static void main(String[] args) {
        new TestB().test1();//过时
 
       @SuppressWarnings("rawtypes")//抑制警告
       ArrayList list=new ArrayList();
        
    }
    
}
class TestA{
    public void test(){
        
    }
}
//@TestAmm//不能给方法注解
class TestB extends TestA{
    @TestAmm(Id=100,desc ="姓名")
    String name;
    
    @Override
    public void test() {
        super.test();
    }
    @Deprecated
    public void test1() {}
}
@Target(ElementType.FIELD)//这个注解类是给其他类的属性做注解
    @Retention(RetentionPolicy.RUNTIME)//注解的声明周期
    @Documented
@interface TestAmm{
    public int Id() default 0;
    public String desc() default "";
}