Java二次复习笔记（1）

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

Java二次复习笔记（1）

Java采用的默认字符编码集是Unicode。
byte=byte+byte报错，值为int，而byte+=byte不报错。同样short = short+short报错，值为int；short += short不报错。
float和double小数计算有时会出现误差，原因是计算机底层为二进制，有些小数无法用二进制准确表示。如：0.5可以用2的-1次表示，0.3则无法用二进制表示。
static方法是类级别的；非static方法是对象级别的。

对象可以 -> new一个对象后，对象.static方法()或对象.非static方法()

类只能 -> 类名.static方法

class Sta{

    public static void test01(){

        System.out.println("用类名直接调用static方法！");

    }

    public static void test02(){

        System.out.println("new一个对象后调用static方法！");

    }

}

public class Test {

    public static void test(){

        System.out.println("本类直接调用static方法！");

    }

    public static void main(String[] args) {

        test();

        Sta.test01();

        new Sta().test02();

    }

}

运行结果：

本类直接调用static方法！

用类名直接调用static方法！

new一个对象后调用static方法！

对于非基本类型（也叫对象类型或引用类型）：

只定义，不new：默认值为null。例如 Person p; String s; 其中p和s都为null。

new实例化：Xxx xx = new Xxx(); xx值不是null，xx内部的属性值全部是数据类型的默认值。例如 String s = new String(); s为""， Person p = new Person(); p对象里的属性name为null，age为0，stature为0.0。
字符串。如果直接使用字面量（ String s = "abc"; ）,则从常量池中找；如果使用new（ String s = new String("abc"); ），则从堆中找，而堆又会从常量池中找，如果常量池中不存在，则在常量池中创建，并引用该常量池中的字符串。

①问： String s = new String("hello"); 创建了多少个对象？答：如果之前常量池中不存在“hello”字符串，创建了两个对象（堆中+常量池中）+一个引用。如果之前常量池中存在“hello”字符串，则创建了一个对象（堆中）+一个引用。

②问：如果常量池为空， String s = new String("a"+"b"); 创建了多少个对象？答：创建了4个对象（堆中new的东西+常量池中"a"、"b"、"ab"）。
. String中的inter()方法，可以让引用直接指向常量池。例 String s1="a"; String s2=new String("a"); 此时 s1==s2 为false，当 s2=s2.inter(); 后 s1==s2 为true。
字符串分割。split()方法有些符号（. | + 等等）是无法直接分割的，需要加两个转义字符\；也可以使用 StringTokenizer token = new StringTokenizer(要分割的字符串,分割的符号); 然后迭代 while(token.hasMoreElements()) {System.out.println(token.nextElement());} 实现分割。

import java.util.StringTokenizer;

public class Test {

    public static void main(String[] args) {

        String s = "abc+def";

        String[] splits = s.split("\\+");

        System.out.println(splits[0]+"\t"+splits[1]);

        StringTokenizer tokenizer = new StringTokenizer(s,"+");

        while (tokenizer.hasMoreElements()){

            System.out.println(tokenizer.nextElement());

        }

    }

}

运行结果：

abc def

abc

def

构造方法。如果类中没有构造方法，则系统自动提供一个无参构造方法，如果类中存在了任何构造方法，系统不再提供无参构造方法。this();调用本类构造，super();调用父类构造,只能放在第一行。建议：如果给类中编写构造方法，提前写一个无参构造防止报错。
子类继承父类。 private、构造方法是不能被继承的，但是子类可以显示调用父类构造->super(); 。

class F{

    private int age = 10;

    public F(){

        System.out.println(age);

        ff();

    }

    private void ff(){

        System.out.println("ff");

    }

    public void tt(){

        System.out.println("tt");

    }

}

class S extends F{

    public S(){

        super();

    }

}

public class Test {

    public static void main(String[] args) {

        new S().tt();

    }

}

运行结果：

10

ff

tt

实例化。当new Xxx();时经历了以下过程：测试类static静态代码块->父类static静态代码块->子类static静态代码块->父类普通代码块->父类无参->子类普通代码块->子类无参...

静态代码块（static{ }）：第一次执行且永远只执行一次。

普通代码块（{ }）：每次执行无参构造之前执行。

class F{

    static {

        System.out.println("父类静态代码块");

    }

    {

        System.out.println("父类普通代码块");

    }

    public F(){

        System.out.println("父类构造方法");

    }

}

class S extends F{

    static {

        System.out.println("子类静态代码块");

    }

    {

        System.out.println("子类普通代码块");

    }

    public S(){

        System.out.println("子类构造方法");

    }

}

public class Test {

    static {

        System.out.println("测试类静态代码块");

    }

    {

        System.out.println("测试类普通代码块");

    }

    public static void main(String[] args) {

        new S();

        new S();

    }

}

运行结果：

测试类静态代码块

父类静态代码块

子类静态代码块

父类普通代码块

父类构造方法

子类普通代码块

子类构造方法

父类普通代码块

父类构造方法

子类普通代码块

子类构造方法

构造方法不能被重写（原因：重写必须是子类重写父类，构造方法不能被继承，所以不存在重写）。

| | 位置 | 方法名 | 参数列表 | 返回值 | 访问修饰符 |

| --- | --- | --- | --- | --- | --- |

| 方法重写 | 子类 | 相同 | 相同 | 相同或子类 | 不能比父类更严格 |

| 方法重载 | 同类或子类 | 相同 | 不相同 | 无关 | 无关 |
抽象类不能实例化，原因：抽象类中可能存在抽象方法，而抽象方法没有方法体。
final关键字。final修饰的类不能被继承，final修饰的方法不能被重写，final修饰的变量、属性不能被修改。
多态。打：打篮球、打水、打架...

多态：父类引用指向子类对象；引用在栈空间中，子类对象在堆空间中。

父类 引用对象名字 = new 子类（）；

Pet pet = new Dog();//多态

Pet pet = new Cat();//多态

double d = 10;//double = int(大范围类型 = 小范围类型)

继承： 子类 is a 父类 ->狗是一个宠物（狗是子类，宠物是父类）

接口： 类 has a 接口 ->门有锁的功能（门是类，锁是接口）
接口。接口中没有方法体，且方法都默认为“public abstract”，属性都默认为“static final”。接口和抽象类一样，不能实例化。
子类必须重写父类中的所有抽象方法；实现类必须实现接口中的所有抽象方法。
包装类。

public class BZL {

    public static void main(String[] args) {

        int i = 10;

        Integer j = new Integer(20);

        i = j;  //自动装箱  底层使用的是intValue()

        j = i;  //自动装箱  底层使用的是valueOf()

        /*valueOf()该方法中有一个缓冲区【-128，127】，如果装箱的数字不在此范围内，要重新new一个对象*/

        Integer a = 100;

        Integer b = 100;

        Integer c = 1000;

        Integer d = 1000;

        System.out.println("a与b比较："+ (a==b));

        System.out.println("c与d比较："+ (c==d));

    }

}

运行结果：

a与b比较：true

c与d比较：false

集合。

Collection 存储的数据不唯一，无序，是List的父类，Collection接口的父类是Iterable接口。

package collection;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

public class CollectionTest {

    public static void main(String[] args) {

        Collection col = new ArrayList<>();

        Collection col1 = new ArrayList();

        //col.add();  添加元素

        col.add("a");

        col.add("b");

        col.add("c");

        System.out.println("col"+col);

        col1.add(1);

        col1.add(2);

        col1.add("3");

        System.out.println("col1"+col1);

        //迭代

        Iterator it = col.iterator();

        while (it.hasNext()) {

            String s = (String) it.next();

            System.out.println(s);

        }

        //col.addAll();  添加一个集合所包含的全部元素

        col.addAll(col1);

        System.out.println("col:"+col);

        //col.toArray();  将集合转换为数组

        Object[] os = col.toArray();

        System.out.print("集合转数组：");

        for (int i = 0; i < os.length; ++i) {

            System.out.print(os[i]+"\t");

            if (i==os.length-1){

                System.out.println();

            }

        }

        //col.remove(Object o); 移除

        col.remove("b");

        System.out.println("移除后 col:"+col);

        //col.removeAll();  移除一个集合所包含的全部元素

        col.removeAll(col1);

        System.out.println("移除"+col1+"后col:"+col);

        col.addAll(col1);

        System.out.println("col:"+col);

        //col.retainAll();  只剩一个集合所包含的全部元素

        col.retainAll(col1);

        System.out.println("retainAll"+col1+"后col:"+col);

        //col.contain();  判断是否包含该元素

        System.out.println(col.contains("2"));

        System.out.println(col.contains(2));

        //col.containAll();  判断是否包含该集合

        System.out.println(col.containsAll(col1));

        System.out.println("判断集合是否为空："+col.isEmpty());

        System.out.println("返回集合长度："+col.size());

        System.out.println("返回集合哈希值："+col.hashCode());

        //清空集合

        col.clear();

        System.out.println("col:"+col);

    }

}

运行结果：

col[a, b, c]

col1[1, 2, 3]

a

b

c

col:[a, b, c, 1, 2, 3]

集合转数组：a b c 1 2 3

移除后 col:[a, c, 1, 2, 3]

移除[1, 2, 3]后col:[a, c]

col:[a, c, 1, 2, 3]

retainAll[1, 2, 3]后col:[1, 2, 3]

false

true

true

判断集合是否为空：false

返回集合长度：3

返回集合哈希值：30865

col:[]

List（ArrayList，LinkList）存储的数据是不唯一的，有序的（按存入顺序排），可以通过索引增删改查元素。

package collection;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

//List接口拥有Collection接口的所有功能

public class ListTest {

   public static void main(String[] args) {

       ArrayList list = new ArrayList();

       list.add("a");

       list.add("b");

       System.out.println("list："+list);

       //add(int index,Object element);  index位置插入元素element

       list.add(0,"A");

       System.out.println("list："+list);

       List list1 = new ArrayList();

       list1.add("F");

       list1.add("f");

       list1.add("B");

       //add(int index,Collection c);  index位置插入集合c

       list.addAll(1,list1);

       System.out.println("将集合"+list1+"插入1位置后list："+list);

       //get();  返回某位置元素

       System.out.println("位置3的元素为："+list.get(3));

       //indexOf(); 返回某元素首次出现的位置

       //lastIndexOf(); 返回某元素最后出现的位置

       System.out.println("b元素的位置："+list.indexOf("b"));

       //remove(int index);  删除指定位置的元素

       list.remove(2);

       System.out.println("删除位置2处的元素后list："+list);

       //set(int index,Object element);  index位置元素替换为元素element

       list.set(0,"OK");

       System.out.println("0位置元素替换为OK后，list："+list);

       //subList(int fromIndex,int toIndex);  截取集合元素[fromIndex,toIndex)

       ArrayList list3 = new ArrayList(list.subList(1,3));

       System.out.println("截取list的[1，3)："+list3);

       LinkedList link = new LinkedList();

       link.add("a");

       link.add("b");

       link.addFirst("头");

       link.addLast("尾");

       System.out.println("link："+link);

       //普通for循环遍历

       System.out.println("普通for循环遍历");

       for (int i=0;i<link.size();i++){

           System.out.println(link.get(i));

       }

       //增强for循环遍历

       System.out.println("增强for循环遍历");

       for (Object o:link){

           String s = (String)o;

           System.out.println(s);

       }

       //迭代器

       System.out.println("迭代器");

       Iterator iterator = link.iterator();

       while (iterator.hasNext()){

           String s = (String)iterator.next();

           System.out.println(s);

       }

   }

}

运行结果：

list：[a, b]

list：[A, a, b]

将集合[F, f, B]插入1位置后list：[A, F, f, B, a, b]

位置3的元素为：B

b元素的位置：5

删除位置2处的元素后list：[A, F, B, a, b]

0位置元素替换为OK后，list：[OK, F, B, a, b]

截取list的[1，3)：[F, B]

link：[头, a, b, 尾]

普通for循环遍历

头

a

b

尾

增强for循环遍历

头

a

b

尾

迭代器

头

a

b

尾

Set（HashMap，TreeMap）存储的数据是唯一的，无序的。因为无序，所以无法通过索引增删改查元素。

package collection;

import java.util.HashSet;

import java.util.Iterator;

//Set接接口拥有Collection接口的所有功能

public class SetTest {

    public static void main(String[] args) {

        HashSet set = new HashSet();

        set.add("a");

        set.add("b");

        set.add("A");

        set.add("B");

        set.add("a");

        System.out.println(set);

        //增强for循环遍历

        System.out.println("增强for循环遍历");

        for (Object o :set) {

            String s = (String)o;

            System.out.println(s);

        }

        //迭代器遍历

        System.out.println("迭代器遍历");

        Iterator iterator = set.iterator();

        while(iterator.hasNext()){

            String s = (String)iterator.next();

            System.out.println(s);

        }

    }

}

运行结果：

[a, A, b, B]

增强for循环遍历

a

A

b

B

迭代器遍历

a

A

b

B

Map（HashMap，TreeMap）无序的，key值是唯一的，value值不唯一。

package map;

import java.util.*;

//HashMap接口拥有Map接口的所有功能

//无序的：与存储顺序无关

public class MapTest {

    public static void main(String[] args) {

        HashMap map = new HashMap();

        map.put("2","张三");

        map.put("1","李四");

        map.put("3","王五");

        map.put("A1","哈哈");

        System.out.println(map);

        //根据key找value

        System.out.println("key值为2的value值："+map.get(2));

        System.out.println("集合长度："+map.size());

        System.out.println("判断是否包含指定的key："+map.containsKey(1));

        System.out.println("判断是否包含指定的value："+map.containsValue("王五"));

        //转为只含key的单值集合(key值唯一，所以用Set)

        Set set = map.keySet();

        System.out.println(set);

        //转为只含value的单值集合(value值不唯一，所以用Collection)

        Collection coll = map.values();

        System.out.println(coll);

        //remove(key);  根据key删除元素，返回值为value

        map.remove(2);

        System.out.println("删除key值为2的元素："+map);

        //增强for循环遍历--通过entry遍历

        System.out.println("增强for循环遍历--通过entry遍历");

        Set entries = map.entrySet();

        for(Object o:entries){

            Map.Entry et = (Map.Entry) o;

            Object k = et.getKey();

            Object v = et.getValue();

            System.out.println("key:"+k+"--"+"value:"+v);

        }

        //迭代器

        System.out.println("迭代器");

        Set keySet = map.keySet();

        Iterator iterator = keySet.iterator();

        while(iterator.hasNext()){

            Object k = iterator.next();

            Object v = map.get(k);

            String sk = (String)k;

            String sv = (String)v;

            System.out.println("key:"+sk+"--"+"value:"+sv);

        }

    }

}

运行结果：

{A1=哈哈, 1=李四, 2=张三, 3=王五}

key值为2的value值：null

集合长度：4

判断是否包含指定的key：false

判断是否包含指定的value：true

[A1, 1, 2, 3]

[哈哈, 李四, 张三, 王五]

删除key值为2的元素：{A1=哈哈, 1=李四, 2=张三, 3=王五}

增强for循环遍历--通过entry遍历

key:A1--value:哈哈

key:1--value:李四

key:2--value:张三

key:3--value:王五

迭代器

key:A1--value:哈哈

key:1--value:李四

key:2--value:张三

key:3--value:王五

泛型：

package generic;

import java.util.*;

class Person{

    private int id;

    private String name;

    private int age;

    private double height;

    @Override

    public String toString() {

        return "Person{" +

                "id=" + id +

                ", name='" + name + '\'' +

                ", age=" + age +

                ", height=" + height +

                '}';

    }

    public Person(){}

    public Person(int id, String name, int age, double height) {

        this.id = id;

        this.name = name;

        this.age = age;

        this.height = height;

    }

    public int getId() {

        return id;

    }

    public void setId(int id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public double getHeight() {

        return height;

    }

    public void setHeight(double height) {

        this.height = height;

    }

}

public class Demo {

    public static void main(String[] args) {

        Map<Integer,String> map = new HashMap<>();

        map.put(1,"张三");

        map.put(3,"王五");

        map.put(2,"李四");

        Set<Map.Entry<Integer, String>> entries = map.entrySet();

        for (Map.Entry<Integer,String> entry:entries){

            System.out.println("key = "+entry.getKey());

            System.out.println("value = "+entry.getValue());

        }

        List<Person> list = new ArrayList<>();

        Person p1 = new Person(1,"张三",20,1.78);

        Person p2 = new Person(3,"王五",25,1.69);

        Person p3 = new Person(2,"李四",22,1.88);

        list.add(p1);

        list.add(p2);

        list.add(p3);

        Iterator<Person> iterator = list.iterator();

        while (iterator.hasNext()){

            Person p = iterator.next();

            System.out.println(p);

        }

    }

}

运行结果：

key = 1

value = 张三

key = 2

value = 李四

key = 3

value = 王五

Person{id=1, name='张三', age=20, height=1.78}

Person{id=3, name='王五', age=25, height=1.69}

Person{id=2, name='李四', age=22, height=1.88}

集合删除（remove()）：

Collection中的类（List、Set），删除的返回值是boolean；

Map中的类，是根据key删除，返回值是value。
工具类。（Arrays、Collections）

数组工具类：

import java.util.Arrays;

public class ArraysTest {

    public static void getArr(int[] arr){

        for (int i=0;i<arr.length;i++){

            System.out.print(arr[i]+"\t");

        }

        System.out.println();

    }

    public static void main(String[] args) {

        int[] arr = {5,8,9,11,6,2,7,9};

        System.out.println("原数组：");

        getArr(arr);

        Arrays.sort(arr);

        System.out.println("数组排序：");

        getArr(arr);

        //二分查法， 必须先排序再二分查

        System.out.println("9的位置："+Arrays.binarySearch(arr,9));

        Arrays.fill(arr,5);

        System.out.println("填充全部：");

        getArr(arr);

    }

}

运行结果：

原数组：

5 8 9 11 6 2 7 9

数组排序：

2 5 6 7 8 9 9 11

9的位置：5

填充全部：

5 5 5 5 5 5 5 5

集合工具类：

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

public class CollectionsTest {

    public static void main(String[] args) {

        List<String> list = new ArrayList<>();

        list.add("java");

        list.add("mysql");

        list.add("html");

        list.add("php");

        list.add("python");

        System.out.println(list);

        Collections.sort(list);

        System.out.println("字典排序："+ list);

        System.out.println("最大值："+Collections.max(list));

        System.out.println("最小值："+Collections.min(list));

        //二分法查（使用前，必须保证集合元素是 自然有序的）

        System.out.println("\"php\"位置："+Collections.binarySearch(list,"php"));

        Collections.shuffle(list);

        System.out.println("洗牌后："+list);

        Collections.reverse(list);

        System.out.println("反转后：" + list);

        Collections.swap(list,1,2);

        System.out.println("1位置与2位置元素交换：" + list);

        Collections.replaceAll(list,"php","c++");

        System.out.println("新元素替换所有旧元素" + list);

        Collections.fill(list,"hello");

        System.out.println("填充全部：" + list);

    }

}

运行结果：

[java, mysql, html, php, python]

字典排序：[html, java, mysql, php, python]

最大值：python

最小值：html

"php"位置：3

洗牌后：[mysql, html, php, java, python]

反转后：[python, java, php, html, mysql]

1位置与2位置元素交换：[python, php, java, html, mysql]

新元素替换所有旧元素[python, c++, java, html, mysql]

填充全部：[hello, hello, hello, hello, hello]

异常。

try{ }catch{ } 自己（当前方法）能够处理，使用try catch；

package exception;

public class ExceptionTest {

    public static void test01(){

        try{

            Object obj = null;

            obj.equals(""); //会出现空指针异常

        }catch (NullPointerException e){

            System.out.println("发生了空指针异常！");

        }catch (Exception e){

           e.printStackTrace();

        }finally{

            System.out.println("最终都会执行的地方！");

        }

    }

    public static int test02(){

        try{

           int[] i = new int[1];

//            System.exit(1);     //关闭虚拟机，直接终止，下面都不会运行

           i[1] = 5; //发生数组越界异常

            return 0;

        }

        //捕获时，先写范围小的类型，后写范围大的类型

        catch (NullPointerException e){

            System.out.println("发生了空指针异常！");

            return 1;

        }catch (Exception e){

            System.out.println("上面catch没捕获到后用这个捕获！");

            return 2;

        }finally {

            System.out.println("最终都会执行的地方！");

            //return 3;

        }

    }

    public static void main(String[] args) {

        test01();

        System.out.println("返回值是："+test02());

    }

}

运行结果：

发生了空指针异常！

最终都会执行的地方！

上面catch没捕获到后用这个捕获！

最终都会执行的地方！

返回值是：2

throws 自己（当前方法）不能处理，上交个上级（方法调用处）处理，使用throws。

自定义异常：MyException.java

package exception;

public class MyException extends Exception {

   public MyException(String message){

       super(message);

   }

}

ThrowTest.java

package exception;

public class ThrowTest {

   //1.利用try catch处理异常

   public static void test01(){

       int age = 188;

       //约定年龄范围(0，120]

       if (age<=0 || age>120){

           try {

               throw new MyException("年龄不符！");

           } catch (MyException e) {

               e.printStackTrace();

           }

       }

   }

   //2.利用throws抛出异常

   public static void test02() throws MyException {

       int age = 188;

       //约定年龄范围(0，120]

       if (age<=0 || age>120){

           throw new MyException("年龄不符！");

       }

   }

   public static void main(String[] args) {

       test01();

       //对于用throws抛出异常的方法，调用时要么try catch，要么继续throws抛出

       try {

           test02();

       }catch (MyException e){

           e.printStackTrace();

       }

   }

}

运行结果：

exception.MyException: 年龄不符！

 at exception.ThrowTest.test01(ThrowTest.java:15)

 at exception.ThrowTest.main(ThrowTest.java:31)   ...

exception.MyException: 年龄不符！

 at exception.ThrowTest.test02(ThrowTest.java:26)

 at exception.ThrowTest.main(ThrowTest.java:34)   ...

内置注解

@Override：可以确保重写的方法的确存在于父类或者接口中，可以有效的避免单词拼错等情况。

@Deprecated：用于提示，该方法由于安全、性能问题等已经不推荐使用了。此外，在版本升级时，如果要计划删除一些方法，也通常会在下一个版本中将该方法加上@Deprecated，然后再在后续版本中删除。

@SuppressWarnings（value="unchecked"）：压制警告（一般不建议使用）。value值有unchecked，deprecation（忽略一些过期的API），unused（是否未被使用），fallthrough（switch是否一直往下执行而没有break），path（忽略堆路径不存在的检查），serialVersionUID（忽略一个类可以被序列化，但没有序列化的警告），all（忽略一切警告）。
元注解 （修饰注解的注解）

@Target：限制注解使用的位置（属性、方法、类），如果一个注解没有@Target描述，则该注解可以修饰任何类型的元素，如果有@Target修饰。该注解就只能用于被@Target修饰的地方。

public enum ElementType {

    /**  类，接口（包括注释类型）或枚举声明 */

    TYPE,

    /** 字段声明（包括枚举常量） */

    FIELD,

    /** 方法声明 */

    METHOD,

    /** 形式参数声明 */

    PARAMETER,

    /** 构造函数声明 */

    CONSTRUCTOR,

    /** 局部变量声明 */

    LOCAL_VARIABLE,

    /** 注释类型声明 */

    ANNOTATION_TYPE,

    /** 包声明 */

    PACKAGE,

    /**

     * 类型参数声明

     *

     * @since 1.8

     */

    TYPE_PARAMETER,

    /**

     * 使用类型

     *

     * @since 1.8

     */

    TYPE_USE,

    /**

     * 模块声明.

     *

     * @since 9

     */

    MODULE

}

@Retention：限制注解的生命周期

public enum RetentionPolicy {

    /**

     * 批注将被编译器丢弃。

     jvm直接将该注解丢弃

     */

    SOURCE,

    /**

     * 注释将由编译器记录在类文件中，但不必在运行时由VM保留。这是默认的行为。

     .java -> .class

     程序在编译时会使用注解，在运行时不会使用

     */

    CLASS,

    /**

     * 注释由编译器记录在类文件中，并在运行时由VM保留，因此可以通过反射方式读取它们。

     *

     * @see java.lang.reflect.AnnotatedElement

     程序在编译以及运行时。都会使用注解

     */

    RUNTIME

}

@Document：

默认情况下，javadoc不包含注解的解释，如果想在javadoc文档中也包含注解的说明，则需要使用@Document标注。

@Inherited：继承。如果A类有一个注解，B类继承A类时，默认不会继承该注解；如果该注解用@Inherited修饰，则就可以继承注解。

接下来举个例子：

先自定义一个注解

package annotation;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

@Target(value = {ElementType.FIELD,ElementType.METHOD}) //修饰注解，只能在属性、方法上使用

@Retention(RetentionPolicy.RUNTIME) //修饰注解，编译运行时都会使用注解

public @interface MyAnnotation {

    //String value(); //用定义方法的形式，定义了一个属性value

    //String[] value(); //数组形式

    String value() default "Hello"; //default指定了value默认值为H ello

    int age() default 24;

}

测试一下

package annotation;

import java.lang.annotation.Annotation;

public class AnnotationTest {

    @MyAnnotation

    @Deprecated

    public static void test() throws Exception {

        //获取  “类名” 的 “方法” 的 “注解”

        Annotation[] annotations = Class.forName("annotation.AnnotationTest").getMethod("test").getAnnotations();

        for (Annotation a: annotations) {

        /*注：如果元注解@Retention的值不为RetentionPolicy.RUNTIME，则会直接执行下面的else结果*/

            if (a instanceof MyAnnotation){

                System.out.println("获取自定义注解的value值：" + ((MyAnnotation)a).value() );

                System.out.println("获取自定义注解得到age值：" + ((MyAnnotation)a).age() );

            }else{

                System.out.println("@Deprecated");

            }

        }

    }

    public static void main(String[] args) throws Exception {

        test();

    }

}

运行结果：

获取自定义注解的value值：Hello

获取自定义注解得到age值：24

@Deprecated

正文

相关阅读

go语言的案例，go语言实战笔记

知了课堂python爬虫笔记，知了课堂百度云

尚硅谷go核心编程之npm教程，尚硅谷html笔记

微服务架构设计教程，微服务架构笔记

面向对象编程笔记原型，面向对象编程技巧

macos三星，三星笔记mac版本

html5静态页面笔记，html静态页面兼职

私人设计模式笔记，私人设计师如何接单

目录[+]