Java常用方法

JAVA 基础 [ 持续更新中 ]

解决异常：
1. throws 抛出异常;
2. try catch 处理异常;
Scanner：
1. new Scanner() 键盘输入;
Random：
1. new Random() 随机生成;
ArrayList：
1. add()：添加元素;
2. get()：获取元素;
3. remove()：删除元素;
4. size()：获取个数;
5. ArrayList<>：包装类特殊[int=Integer | char= Character];
String：
1. String()：String str = new String();
2. String(char[] array)：char[] charArray = {1, 2, 3} String srt = new String(charArray)把数组转换字符串;
3. String(byte[] array)：byte[] byteArray = {97,98,99} //键盘字节号 String str = new String(chaArray);
- .equals( )内容比对;
- .equalsIgnoreCase( )忽略大小写;
- int lenght( )获取长度;
- String concat(String str)拼接字符;
- char charAt(int index)指定单个字符 (索引);
- int indexof(String str)首次出现位置;
- .substring(int index)截取;
- char[] toCharArray( )拆分字符成数组;
- byte[] getBytes( )获得当前字符串底层字节数组;
- String replace( )将老字符串替换新的返回，替换之后的字符串;
- split( )切割字符串返回数组【.的话\.】;
Arrays：
1. toString()把数组变成字符串;
2. Array.sort()从小到大排序;
Math：
1. Math.abs()取绝对值;
2. Math.ceil()向上取整;
3. Math.floor()向下取整;
4. Math.round()四舍五入;
继承(extends 父类名称)：
1. 局部直接写 extends;
2. 子类访问本类用 this;
3. 访问父类 super;
4. @Override 检测是否正确;
权限(修饰符)：
1. public>protected>(defoult 空)>private;
抽象 abstract：
public abstract 返回值方法名称(参数列表)
1. 在 public 后面加 abstract 抽象方法不加{方法体}()结束;
2. 在最外层 class 前加 abstract;
3. 子类必须继承(extends)抽象父类方法去掉 abstract 加上{方法体};
接口 interface：
1. class换成interface[ 可以省略初学不建议 ]
2. 使用必须有个实现类 public class 实现类名称 implements 接口名称 {};// 必须覆盖重写所有抽象方法@Override(idea编辑器:ALT+回车)去掉adstract加上方法体,创建现实类(子类)对象使用;
3. JAVA7:常量、抽象方法，JAVA8:默认方法、静态方法，JAVA9：私有方法;
4. JAVA8开始默认方法接口：public default Void 方法名() {},实现体：接口名.方法名();
5. JAVA9开始私有方法:
- 普通私有：private 返回值类型方法名(参数列表) {方法体};
- 静态私有：private static 返回值类型方法名(参数列表) {方法体};
1. 接口常量：public static final 数据类型数据名称 = 数据值(可以省略初学不建议,必须大写|必须赋值);
多态：
1. 格式：父类名称 = new 子类名称()或者接口名称 = new 实现类名称();
2. 成员变量：编译看父类,运行看父类;
3. 成员方法：编译看父类,运行看子类;
4. 转型：
- 向上转型：父类名称对象名 = new 子类名称()
- 向下转型：子类名称对象名 = (子类名称) 父类对象() [ 还原动作 ]
- 检测引用对象：instanceof 类名称;
关键字：
1. final不允许有任何子类继承:
- public final class 类名称 {};
内部类：
1. 成员内部类：
- 对象名 = new 类名称();
- 外部名称.内部名称对象名 = new 外部名称().new 内部类;
- 匿名内部类：接口名称对象名 = new 接口名称(){};
Objects 类：
1. equals判断地址值内容(返回布尔值);
Date 类：
1. Date date = new Date() 获取当前系统时间 [util包];
2. Date date = new Date(Long Date) 毫秒值转换成日期格式;
3. Date.getTime() 把日期转换成毫秒值 [相当于: System.currentTimeMillis()];
DateFormat 类(抽象类)：
1. SimpleDateFormat sdf = new SimpleDateFormat(时间格式：yyyy-mm-dd-mm-ss);
2. sdf.format() 把日期格式转换成文本;
3. sdf.parse(时间格式) 把字符串解析成日期;
Calemdar 类(日历类抽象类)：
1. Calendar c = Calendar.getInstance ();
2. c.get(Calendar.YEAR)返回日历字段的值 [Calendar.[YEAR\MONTH\DAY_OF_MONTH]];
3. c.set(int fieid, int value) 设置指定字段的值[格式, 值]有重载方法:[set(2020, 03, 23)];
4. c.add(int fieid, int value) 设置指定字段的值增加/减少指定的值[格式, 值];
5. c.getTime() 把日历转换成日期格式;
System 类(字符串缓冲区)：
1. System.currentTimeMillis() 获取当前时间毫秒值(Long 类型值);
2. System.arraycopy(原数组, 起始索引, 目标数组起始索引, 复制数量)将数组指定的数据拷贝到另一个数组;
StringBuilder 类：
1. StringBuilder sbu = new StringBuilder();
2. sbu.append(字符串) 添加数据;
3. sbu.toStribg() StringBuilder对象转String对象;
包装类：
1. 手动包装：
  1. 装箱：例如 Integer：
  - 构造方法：Integer int = new Integer();
  - 静态方法：Integer int = Integer.valueOf();
  1. 拆箱：int i = int.intValue()
2. 自动包装：
  1. 装箱：
  - Integer in = 1;
  1. 拆箱：
  - in = in + 2;
3. 基本类型转字符串：
  1. 基本类型值 + " ";
  2. xxx.toString();
  3. String.valueOf();
4. 字符串转基本类型：
  1. Integer.parseInt() [parse];
集合：
1. Vector集合、ArrayList集合、LinkedList集合、TreeSet集合、HashSet集合、LinkedHashSet集合;
Collection 集合常用功能：
1. add() 添加对象到集合;
2. clear() 清空集合;
3. remove() 删除指定集合;
4. contains() 判断当前集合是否包含;
5. isEmpty() 判断集合是否为空;
6. size() 集合中元素个数;
7. toArray() 把集合中元素,存到数组上;
8. Collections.shuffle(); 打乱集合;
Iterator 迭代器(接口类型)：
使用方法：
1. Collection<String> coll = new Collection<>()创建集合;
2. coll.add()添加集合;
3. Iterator<String> it = new Iterator();获取迭代器多态 ;
4. boolean b = it.hasNext();判断是否有元素,使用while(it.hasNext()) { it.next() }循环;
5. it.next();开始迭代获取元素
6. hasNext() 判断仍有迭代则返回true;
7. next() 返回迭代下一个元素;
增强 for：
1. for (集合类型\数组类型变量名 : 数组名\集合名) {};
泛型：
1. 定义类泛型：public class 类名<E> {};
2. 定义方法泛型：修饰符 <泛型> 返回值类型方法名(参数列表) {方法体};public <E> void xx (E e) {};
3. 定义接口泛型：public interface xxx``<E>{ public abstract void xxx(E e); // 抽象方法};
- 使用接口泛型 1：
```
 `public` `class` `xxx` `implements` `xxx``<String>`{覆盖重写};
 `xxx` `xx` = `new` `xxx`();
```
- 使用接口泛型 2：
```
 `public` `class` `xxx``<E>` `implements` `xxx``<E>`{覆盖重写};
 `xxx``<String>` `xx` = `new` `xxx`<>();
```
1. 泛型通配符：<?>;
List：
1. .add() 添加元素;
2. .REMOVE() 移除元素;
3. .get() 替换元素
可变参数：
1. 修饰符返回值类型方法名(参数类型... 形参名){ };
Collections：
1. addAll() 往集合中添加一些元素
2. shuffle() 打乱顺序 :打乱集合顺序
3. sort() 将集合中元素按照默认规则排序
4. sort(List``<T> list, Comparator<? super T> ) 将集合中元素按照指定规则排序;
Map 集合：
Map<String, String> map = new HashMap<>();
1. put() 把指定的键与指定的值添加到 Map 集合中;
2. remove() 把指定的键所对应的键值对元素在 Map 集合中删除，返回被删除元素的值;
3. get() 根据指定的键，在 Map 集合中获取对应的值;
4. containsKey() 查询集合是否包含[返回boolean类型];
5. keySet() 获取 Map 集合中所有的键，存储到 Set 集合中[遍历集合先执行];
6. entrySet() 获取到 Map 集合中所有的键值对对象的集合Set 集合;getKey() 获取对象key 例如：[Set<Entry<String,String>> entrySet = map.entrySet()];getValue() 获取对象值;
7. 自定义类型键值：必须重写hashCode和equals方法;
异常：
1. Throwable中的常用方法：
  1. printStackTrace() :打印异常的详细信息;
  2. getMessage() :获取发生异常的原因;
  3. toString() :获取异常的类型和异常描述信息(不用);
2. 异常(Exception)的分类:
  1. 编译时期异常:checked异常(如日期格式化异常);
  2. 运行时期异常:runtime异常。在运行时期,检查异常.在编译;
3. Error:严重错误Error,无法通过处理的错误;
4. 异常处理：
  1. Java 异常处理的五个关键字：try、catch、ﬁnally、throw、throws;
  2. 抛出异常throw[throw new xxxException(异常产生的原因)];
    1. 注意：必须写在方法内部;
  3. 声明异常throws: 修饰符返回值类型方法名(参数)throws异常类名{},[throw new xxxException("文件不存在")或者 try…catch];
  4. 捕获异常try…catch[try{}catch(Exception e){}];
  5. ﬁnally 代码块配合try{}catch(){}finally{};
  6. Objects非空判断:Object.requireNonNull(参数名, "");
  7. 自定义异常：extends Exception 子类;
线程：
1. 创建线程类：extends Thread 重写run()方法,调用new对象的start()方法启动该线程;
Thread 类：
1. 构造方法：
  1. public Thread() 分配一个新的线程对象;
  2. public Thread(String name) 分配一个指定名字的新的线程对象;
  3. public Thread(Runnable target) 分配一个带有指定目标新的线程对象;
  4. public Thread(Runnable target,String name) 分配一个带有指定目标新的线程对象并指定>名字;
2. 常用方法：
  1. getName() 获取当前线程名称;
  2. start() 导致此线程开始执行;Java虚拟机调用此线程的run()方法;
  3. run() 此线程要执行的任务在此处定义代码;
  4. sleep(long millis) 使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行);
  5. public static Thread currentThread() 返回对当前正在执行的线程对象的引用;
3. 创建线程：
  1. 创建方法 1：
    1. extends Thread 重写run()方法,测试类new父类调用start()方法;
  2. 创建方法 2：
    1. 定义 Runnable 接口的实现类，并重写该接口的 run()方法，该 run()方法的方法体同样是该线程的线程执行体;
    2. 创建 Runnable 实现类的实例，并以此实例作为 Thread 的 target 来创建 Thread 对象，该 Thread 对象才是真正的线程对象;
    3. 调用线程对象的 start()方法来启动线程;
  3. 线程安全：
    1. 同步代码块：synchronized(同步锁){} [同步锁：Object lock = new Object()]
    2. 同步方法：public synchronized void method(){}
    3. lock锁：Lock lock = new ReentrantLock() [方法:lock() 加同步锁,unlock() 释放同步锁]
  4. 线程状态：
    1. Waiting(无限等待):
      
      创建锁对象：Object lock = new Object();
      
      消费者：new Thread().start() {重写run()方法;run(){synchronized(锁对象){锁对象.wait()}[同步代码块]}}
      
      生产者：new Thread().start() {重写run()方法;run(){synchronized(锁对象){锁对象.notify()}[同步代码块]}}
    2. 方法：
      
      wait()等待唤醒;
      
      notify()随机唤醒;
      
      notifyAll()全部唤醒;
  5. TimedWaiting(计时等待)：
    1. sleep(long e);
    2. wait(long e);
4. 线程池：
  1. ExecutorService xxx = Executors.newFixedThreadPool(线程数量);
  2. 创建类 implements ExecutorService 实现接口,重写run()方法;
  3. 实现类 x = new 实现类()[调用: xxx.submit(x)];
  4. 销毁线程池：xxx.shutdown();
Lambda 表达式：
1. 借助Java8的全新语法:() -> {方法体};
File 类：[file、directory、path]
1. 构造方法：
  1. public File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File 实例;
  2. public File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的 File 实例;
  3. public File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File 实例;
2. 获取功能的方法：
  1. getAbsolutePath() 返回此File的绝对路径名字符串;
  2. getPath() 将此File转换为路径名字符串;
  3. getName() 返回由此File表示的文件或目录的名称;
  4. length() 返回由此File表示的文件的长度;
3. 判断功能的方法:
  1. exists() 此File表示的文件或目录是否实际存在;
  2. isDirectory() 此File表示的是否为目录;
  3. isFile() 此File表示的是否为文件;
4. 创建删除功能的方法:
  1. createNewFile() 当且仅当具有该名称的文件尚不存在时，创建一个新的空文件;
  2. delete() 删除由此File表示的文件或目录;
  3. mkdir() 创建由此File表示的目录;
  4. mkdirs() 创建由此File表示的目录，包括任何必需但不存在的父目录;
5. 路径:
  1. File.pathSeparator 路径分隔符;
  2. File.separator 文件名称分隔符;
Io 流：
1. 字节输出流OutputStream[超类]：
  1. close() 关闭此输出流并释放与此流相关联的任何系统资源;
  2. flush() 刷新此输出流并强制任何缓冲的输出字节被写出;
  3. write(byte[] b) 将 b.length字节从指定的字节数组写入此输出流;
  4. write(byte[] b, int off, int len) 从指定的字节数组写入 len字节,从偏移量 oﬀ开始输出到此输出流;
  5. write(int b) 将指定的字节输出流;
- 1.2 FileOutputStream类：
  - public FileOutputStream(File file) 创建文件输出流以写入由指定的File对象表示的文件;
  - public FileOutputStream(String name) 创建文件输出流以指定的名称写入文件;
1. 字节输入流InputStream[超类]:
  1. close() 关闭此输入流并释放与此流相关联的任何系统资源;
  2. read() 从输入流读取数据的下一个字节;
  3. read(byte[] b) 从输入流中读取一些字节数，并将它们存储到字节数组 b 中;
- 2.1 FileInputStream类：
  - FileInputStream(File file) 通过打开与实际文件的连接来创建一个 FileInputStream,该文件由文件系统中的 File对象 ﬁle命名;
  - FileInputStream(String name) 通过打开与实际文件的连接来创建一个 FileInputStream,该文件由文件系统中的路径名 name命名;
1. 字符输入流Reader[超类]：
  1. public void close() 关闭此流并释放与此流相关联的任何系统资源;
  2. public int read() 从输入流读取一个字符;
  3. public int read(char[] cbuf) 从输入流中读取一些字符，并将它们存储到字符数组cbuf中;
- 3.1 FileReader 类：
  - FileReader(File file) 创建一个新的FileReader,给定要读取的 File 对象;
  - FileReader(String fileName) 创建一个新的FileReader,给定要读取的文件的名称;
1. 字符输出流Writer[超类]:
  1. write(int c) 写入单个字符;
  2. write(char[] cbuf) 写入字符数组;
  3. write(char[] cbuf, int off, int len) 写入字符数组的某一部分,oﬀ 数组的开始索引,len 写的字符个数;
  4. write(String str) 写入字符串;
  5. write(String str, int off, int len) 写入字符串的某一部分,oﬀ 字符串的开始索引,len 写的字符个数;
  6. flush() 刷新该流的缓冲;
  7. close() 关闭此流，但要先刷新它;
- 4.1 FileWriter类：
  - FileWriter(File file) 创建一个新的FileWriter,给定要读取的File对象;
  - FileWriter(String fileName) 创建一个新的FileWriter,给定要读取的文件的名称;
1. Properties类:
  1. 基本的存储方法
    1. setProperty(String key, String value) 保存一对属性;
    2. getProperty(String key) 获取列表中指定的键搜索属性值;
    3. stringPropertyNames() 所有键的名称的集合;
  2. 方法:
    1. store() 把集合临时数据写到硬盘中;
    2. load(InputStream inStream) 从字节输入流中读取键值对;
    3. load(InputStream inStream) 从字节输入流中读取键值对;
1. 缓冲流、转换流、序列化流:
  1. 缓冲流:
    - 字节缓冲流：BufferedInputStream BufferedOutputStream;
    - 字符缓冲流：BufferedReader BufferedWriter;
  - 构造方法:
    - public BufferedInputStream(InputStream in) 创建一个新的缓冲输入流;
    - public BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流;
- 1.1 字符缓冲流:
- 构造方法：
  - public BufferedReader(Reader in) 创建一个新的缓冲输入流;
  - ublic BufferedWriter(Writer out) 创建一个新的缓冲输出流;
- 方法：
  - BuﬀeredReader：public String readLine() 读一行文字;
  - BuﬀeredWriter：public void newLine() 分隔符,由系统属性定义符号;
1. 转换流:
- 2.1 InputStreamReader类:
- 构造方法
  - InputStreamReader(InputStream in) 创建一个使用默认字符集的字符流;
  - InputStreamReader(InputStream in, String charsetName) 创建一个指定字符集的字符流;
- 2.2 OutputStreamWriter类:
- 构造方法
  - OutputStreamWriter(OutputStream in) 创建一个使用默认字符集的字符流;
  - OutputStreamWriter(OutputStream in, String charsetName) 创建一个指定字符集的字符流;
1. 序列化:
- 3.1 ObjectOutputStream类:
- 构造方法:
  - public ObjectOutputStream(OutputStream out) 创建一个指定OutputStream的ObjectOutputStream;
- 方法：
  - writeObject (Object obj) 将指定的对象写出;
- 3.2 ObjectInputStream类:
- 构造方法:
  - public ObjectInputStream(InputStream in) 创建一个指定InputStream的ObjectInputStream;
- 方法：
  - readObject() 读取一个对象;
网络编程:
1. Socket 类：
  1. public Socket(String host, int port) 创建套接字对象并将其连接到指定主机上的指定端口号;
  2. public InputStream getInputStream() 返回此套接字的输入;
  3. public OutputStream getOutputStream() 返回此套接字的输出;
  4. public void close() 关闭此套接字;
  5. public void shutdownOutput() 禁用此套接字的输出流;
2. ServerSocket 类:
  1. public ServerSocket(int port) 参数port就是端口号;
  2. public Socket accept() ：侦听并接受连接，返回一个新的Socket对象，用于和客户端实现通信;
3. 文件上传优化:
  1. shutdownOutput() 禁用此套接字的输出流,任何先前写出的数据将被发送，随后终止输出流;
注解:
1. @FunctionalInterface: 检测是否是(1 个)函数式接口;
2. @Override: 检测重写方法;
函数式编程 Lambda:
1. 使用Lambda必然需要一个函数式接口：
2. Supplier参数: T get()用来获取一个泛型参数指定类型的对象数据;
常用函数式接口
1. Supplier接口:
  1. get()用来获取一个泛型参数指定类型的对象数据;
2. Consumer接口:
  1. 抽象方法：accept [意为消费一个指定泛型的数据];
  2. 默认方法：andThen [消费数据的时首先做一个操作,然后再做一个操作实现组合];
3. Predicate接口:
  1. 抽象方法：test [用于条件判断的场景];
  2. 默认方法：and [将两个Predicate条件使用"与"逻辑连接起来实现"并且"的效果时，可以使用default方法 and ]
  3. 默认方法：or [与 and 的"与"类似，默认方法 or 实现逻辑关系中的"或"]
  4. 默认方法：negate ["与"|"或"已经了解了，剩下的"非"(取反)也会简单。]
  5. 条件判断的标准是传入的Lambda表达式逻辑;
4. Function接口: [ private static void method(Function<String, Integer> function) {}]
  1. 抽象方法：apply [根据类型 T 的参数获取类型 R 的结果]
  2. 默认方法：andThen [默认的 andThen 方法,用来进行组合操作]
Stream 流、方法引用:
1. Stream 流:
- 1.1 获取流: 所有的Collection集合都可以通过stream默认方法获取流;
- 1.2 Stream接口的静态方法of可以获取数组对应的流;
- 1.3 逐一处理forEach: 该方法接收一个 Consumer 接口函数,会将每一个流元素交给该函数进行处理[stream.forEach(name‐> System.out.println(name))]
- 1.4 过滤ﬁlter: 可以通过 filter 方法将一个流转换成另一个子集流;[Stream<T> filter(Predicate<? super T> predicate)]
- 1.5 映射map: 如果需要将流中的元素映射到另一个流中,可以使用map方法[<R> Stream<R> map(Function<? super T, ? extends R> mapper)]
- 1.6 统计个数count: 正如旧集合 Collection 当中的 size 方法一样,流提供 count 方法来数一数其中的元素个数
- 1.7 取用前几个limit: limit 方法可以对流进行截取,只取用前 n 个[Stream<T> limit(long maxSize)]
- 1.8 跳过前几个skip: 如果希望跳过前几个元素,可以使用 skip 方法获取一个截取之后的新流[Stream<T> skip(long n)]
- 1.9 组合 concat: 如果有两个流,希望合并成为一个流,那么可以使用 Stream 接口的静态方法[static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)]
1. 方法引用:
- 2.1 方法引用符: 双冒号::为引用运算符,而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中,那么则可以通过双冒号来引用该方法作为Lambda的替代者
- 2.2 通过对象名引用成员方法:
- 2.3 通过类名称引用静态方法:
- 2.4 通过 super 引用成员方法: [如果存在继承关系,当Lambda中需要出现super调用时,也可以使用方法引用进行替代。首先是函数式接口]
- 2.5 通过 this 引用成员方法: [his 代表当前对象,如果需要引用的方法就是当前类中的成员方法,那么可以使用"`this::成员方法"的格式来使用方法引用。首先是简单的函数式接口]
- 2.6 类的构造器引用: [由于构造器的名称与类名完全一样,并不固定。所以构造器引用使用类名称::new 的格式表示。首先是一个简单的 Person 类]
- 2.7 数组的构造器引用: [数组也是 Object 的子类对象,所以同样具有构造器,只是语法稍有不同。如果对应到 Lambda 的使用场景中时,需要一个函数式接口]
- 2.7.1 Lambda表达式： length -> new int[length] 或方法引用: int[]::new
Junit 单元测试：
1. 给方法加@Test
  1. 导入junit依赖环境
反射：
- 获取Class对象的方式：
1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
  - 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2. 类名.class：通过类名的属性class获取
  - 多用于参数的传递
3. 对象.getClass()：getClass()方法在Object类中定义着。
  - 多用于对象的获取字节码的方式
- 结论：同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。
- Class对象功能：
- 获取功能：
  1. 获取成员变量们
    - Field[] getFields() ：获取所有public修饰的成员变量
    - Field getField(String name) 获取指定名称的 public修饰的成员变量
    - Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
    - Field getDeclaredField(String name)
  2. 获取构造方法们
    - Constructor<?>[] getConstructors()
    - Constructor<T> getConstructor(类<?>... parameterTypes)
    - Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
    - Constructor<?>[] getDeclaredConstructors()
  3. 获取成员方法们：
    - Method[] getMethods()
    - Method getMethod(String name, 类<?>... parameterTypes)
    - Method[] getDeclaredMethods()
    - Method getDeclaredMethod(String name, 类<?>... parameterTypes)
    1. 获取全类名
    - String getName()
- Field：成员变量
- 操作：
  1. 设置值
    - void set(Object obj, Object value)
  2. 获取值
    - get(Object obj)
  3. 忽略访问权限修饰符的安全检查
    - setAccessible(true):暴力反射
- Constructor:构造方法
- 创建对象：
  - T newInstance(Object... initargs)
  - 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法
  - Method：方法对象
- 执行方法：
  - Object invoke(Object obj, Object... args)
- 获取方法名称：
  - String getName:获取方法名
注解：
- JDK中预定义的一些注解
  - @Override：检测被该注解标注的方法是否是继承自父类(接口)的
- @Deprecated：该注解标注的内容，表示已过时
- @SuppressWarnings：压制警告
  - 一般传递参数all @SuppressWarnings("all")
- 自定义注解
- 格式：元注解public @interface 注解名称{
```
属性列表;
```
  }
- 本质：注解本质上就是一个接口，该接口默认继承Annotation接口
  - public interface MyAnno extends java.lang.annotation.Annotation {}
- 属性：接口中的抽象方法
  - 要求：
    1. 属性的返回值类型有下列取值
      - 基本数据类型
      - String
      - 枚举
      - 注解
      - 以上类型的数组
    2. 定义了属性，在使用时需要给属性赋值
      1. 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
      2. 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。
      3. 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略
- 元注解：用于描述注解的注解
  - @Target：描述注解能够作用的位置
    - ElementType取值：
      - TYPE：可以作用于类上
      - METHOD：可以作用于方法上
      - FIELD：可以作用于成员变量上
  - @Retention：描述注解被保留的阶段
    - @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
  - @Documented：描述注解是否被抽取到api文档中
  - @Inherited：描述注解是否被子类继承
  - 在程序使用(解析)注解：获取注解中定义的属性值
1. 获取注解定义的位置的对象（Class，Method,Field）
2. 获取指定的注解
  - getAnnotation(Class)//其实就是在内存中生成了一个该注解接口的子类实现对象
```
  
```
```
public class ProImpl implements Pro{
        public String className(){
            return "cn.itcast.annotation.Demo1";
        }
        public String methodName(){
            return "show";
        }
    }
```
3. 调用注解中的抽象方法获取配置的属性值

posted @ 2020-06-09 14:40 皮一皮很开心阅读(260) 评论(0) 收藏举报

刷新页面返回顶部

皮一皮很开心

Java常用方法

JAVA 基础 [ 持续更新中 ]

解决异常：

Scanner：

Random：

ArrayList：

String：

Arrays：

Math：

继承(extends 父类名称)：

权限(修饰符)：

抽象 abstract：

接口 interface：

多态：

关键字：

内部类：

Objects 类：

Date 类：

DateFormat 类(抽象类)：

Calemdar 类(日历类 抽象类)：

System 类(字符串缓冲区)：

StringBuilder 类：

包装类：

集合：

Collection 集合常用功能：

Iterator 迭代器(接口类型)：

增强 for：

泛型：

List：

可变参数：

Collections：

Map 集合：

异常：

线程：

Thread 类：

Lambda 表达式：

File 类：[file、directory、path]

Io 流：

网络编程:

注解:

函数式编程 Lambda:

常用函数式接口

Stream 流、方法引用:

Junit 单元测试：

反射：

注解：

公告

Calemdar 类(日历类抽象类)：