泛型和注解

注解

目录

• 注解
  • 什么是注解？
  • 怎么使用？
  • 4大元注解
• 泛型：
  • 为什么需要泛型？
  • 泛型的介绍：
  • 泛型细节：
  • 自定义泛型类：
  • 自定义泛型接口：
  • 自定义泛型方法：
  • 泛型的继承和通配符:
• 总结：

什么是注解？

1. 注解（Annotation）也叫元数据(MetaDate)，用于修饰包，类，方法，属性，构造器，局部变量等数据信息
2. 和注释一样，注解不影响程序的逻辑，但注解可以被编译或运行，相当于嵌入代码中的补充信息
3. 在javaSE中注解使用简单，一般用来标记过时的信息。但在javaEE中，注解占据了重要角色，代替一些繁琐代码和XMl配置

怎么使用？

三个基本的Annotation:

1. @Override:限定某个方法，是重写父类方法,该注解只能用于方法
2. @Deprecated:用于表示某个程序元素(类，方法等)已过时
3. @SuppressWarnings: 抑制编译器警告

@Override

class son extends Father{
//    这里不写@Override，还是会重写
//    那么写了有什么用？编译器会检查这个方法是否真的重写了，如果确实父类有这个方法就通过，没有就报错

    @Override
    public void play() {
        super.play();
    }
}

//看看   @Override的定义
//    这个@interface是定义一个注解类
//Target元注解，修饰注解的注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

@SuppressWarnings

class son extends Father{
    @SuppressWarnings({"all"})//抑制所有
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(1);
    }
} 

4大元注解

修饰注解的注解

1. Retention （保持）//指定注解的作用范围,三种SOURCE（编译器）， CLASS（Class文件）,RUNTIME（Jvm运行后）
2. Target（目标）/指定注解可以在哪些地方使用（能在包，类，构造器，方法，属性，注解等地方使用）
3. Documented//指定该注解是否会在javadoc体现4) Inherited //子类会继承父类注解
4. Deprecated：表示能被javadoc写在jdk文档里

泛型：

是编译器的操作

为什么需要泛型？

1. 当我们使用集合时，由于添加的类型不限制，可能导致我们添加错数据，还有，如果添加进的是不同的对象，在取出对象的时候会进行向下转型，这个时候会报错
2. 频繁转型，如果集合数据量大，会影响效率

   ArrayList list = new ArrayList();
        list.add(new Dog(1,"A"));
        list.add(new Dog(2,"B"));
        list.add(new Dog(3,"C"));
        list.add(new cat());//一不小心会添加错误
        for (Object o:list){
           Dog d=(Dog)o;   //频繁转型
        }

泛型的介绍：

泛型：广泛的类型，表示数据类型的类型

1. 解决数据类型的安全问题

2. 解决编译时没有报错，运行时出现的错误ClassCastExpectation

3. 可以在类声明时通过一个标识表示类中某个属性的类型，或者方法的返回值的理想，或者是参数类型

4. 类似于一个模板，可以是任何类型代替

   class person<E>{
       E e;
       person(E e){
            e=this.e;
       }
       public E a(){
           return e;
       }
   }
   
   

   泛型细节：

   1. 泛型只能用引用类型，不能是基本数据类型
   2. 比如我限制了C类的泛型为B类，那么我传入B类肯定没问题，但是我要是传入A类就会报错，这个时候我用A继承B，再传入A就没问题了，所以泛型不仅仅只能传入这个类型，还能传入它的子类

     public static void main(String[] args) {
           a<B> ba = new a<>(new B());
           a<B> ca = new a<B>(new C());//不仅仅只能传入这个类型，还能传入它的子类**
       }
   }
   class a<B>{
       private B b;
       public a(B b) {
           this.b = b;
       }
   }
   class B{
   
   }
   class C extends B{
   
   }
   

   ​ 3.格式： a ba = new a<>(new B()); 后面<>推荐省略

   ​ 4.泛型的默认是Object，如果默认的写A a = new A(); 等价于 A a = new A()

自定义泛型类：

1. 基础语法class 类名（T，E...）{}
2. 普通成员可以使用泛型（属性，方法）
3. 静态方法中不能使用泛型
4. 创建对象时没有指定类型默认就是Object类型

 public class Fanxing6<E,T,R> {
    E e;
    T t;
    R r;
    public R r1(){
        return r;
    }
//   1.数组不确定你的类型，无法给你分配空间，编译通过不了
//   E e1[]=new E[2];

//    2.静态方法不能使用泛型
//    静态是随着类而加载的，类加载在创建对象前面，所以类加载时，还没有对象
//    public static T t1(){
//    }
}

自定义泛型接口：

1. interface 接口名<E,R,T>{}
2. 静态成员不能使用泛型
3. 泛型接口是在继承接口（接口和接口之间可以继承）或者实现接口时确定
4. 实现时没有指定类型就是Object类型

public interface Fanxing7<E> {
      E e();
}
//继承时
interface Fan extends Fanxing7<String>{
    @Override
    String e();
}
//实现时
class A implements Fanxing7<String> {
//            E变成了我们定义的String类型了
    @Override
    public String e() {
        return null;
    }

    public static void main(String[] args) {
//        实例化时没有定义就是Object类型
        Fanxing7 fanxing7 = new Fanxing7() {
            @Override
            public Object e() {
                return null;
            }
        };
    }
}

自定义泛型方法：

1. 基础语法：修饰符<T,R,E> 返回类型 方法名（T t，R r，E e）{}
2. 泛型类中也可以使用泛型方法

public class Fanxing8 {
    public void a(){
        //普通方法
    };
    public <E>void b(E e){
        //泛型方法
    }

    public static void main(String[] args) {
        c c = new c();

    }
}
//泛型类中也可以使用泛型方法
class c<E> {
    public <T>void a(T t){};//泛型方法
    public void b(E e){}//这个不是泛型方法，这个是普通方法使用了类声明的泛型
}

泛型的继承和通配符:

1. 泛型没有继承性

Arraylist<Object> a=new ArrayList<String>();编译不通过

总结：

• 什么是注解？类似于注释，是给编译器看的，在编译器会给一些提示，se中一般用来标记些过时的东西，ee中多用来读取配置文件

• 泛型

  • 什么是泛型
  1. 广泛的类型，向我们平时用的时候，就是在类，接口，方法中使用较多
  2. 类中呢，比如集合我们new ArrayList<>()会看到<>这个符号，这个东西就泛型
  • 泛型有什么作用？
  1. 比如我们集合添加元素时，可能大意啊填错数据类型，要是添加对象时，添加错了，后面取出来的时候，要转型就会出现异常，但是有了泛型会在添加时编译的时候就会报错该我们提示
  2. 并且啊上面的情况不定义类型，数据量大的话一直转型影响效率
  • 有哪些泛型种类？
  1. 类，接口，方法
  2. 类中class<T,R,E...>{定义属性啊，方法啊都可以用到T，R，E这几个我们定义类型，但是呢不能在静态里用泛型，因为静态跟对象无关，是在类加载的时候就定义了，而对象是在运行时才创建，所以产生静态的时候没有对象，自然用上T t对象等时会编译错误}
  3. 接口，也一样，方法，属性都能用，静态不能碰
  4. 方法中，区别泛型方法，和普通方法中使用了类的声明
  5. 创建了泛型，在定义时，会根据我们定义的类型，修改类，接口，方法中的T t对象

  • 怎么自定义泛型？

    1. 类中 class{T t;//属性 public T method（）{return t}//方法 }
    2. 接口interface{}
    3. 方法public viod method（T t）{return t}//参数列表一定要定义跟你类型一致的参数，不然定义泛型方法毫无意义