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