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 返回值类型 方法名(参数列表) {方法体};

  6. 接口常量：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();

     2. 拆箱：int i = int.intValue()

  2. 自动包装：

     1. 装箱：

     • Integer in = 1;

     2. 拆箱：

     • 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`<>();
  

  4. 泛型通配符：<?>;

• 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、finally、throw、throws;

     2. 抛出异常throw[throw new xxxException(异常产生的原因)];

        1. 注意：必须写在方法内部;

     3. 声明异常throws: 修饰符   返回值类型   方法名(参数)throws异常类名{},[throw new xxxException("文件不存在")或者 try…catch];

     4. 捕获异常try…catch[try{}catch(Exception e){}];

     5. finally 代码块配合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(无限等待):

           1. 创建锁对象：Object lock = new Object();

           2. 消费者：new Thread().start() {重写run()方法;run(){synchronized(锁对象){锁对象.wait()}[同步代码块]}}

           3. 生产者：new Thread().start() {重写run()方法;run(){synchronized(锁对象){锁对象.notify()}[同步代码块]}}

        2. 方法：

           1. wait()等待唤醒;

           2. notify()随机唤醒;

           3. 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字节,从偏移量 off开始输出到此输出流;

     5. write(int b) 将指定的字节输出流;

  • 1.2 FileOutputStream类：

    • public FileOutputStream(File file) 创建文件输出流以写入由指定的File对象表示的文件;

    • public FileOutputStream(String name) 创建文件输出流以指定的名称写入文件;

  2. 字节输入流InputStream[超类]:

     1. close() 关闭此输入流并释放与此流相关联的任何系统资源;

     2. read() 从输入流读取数据的下一个字节;

     3. read(byte[] b) 从输入流中读取一些字节数，并将它们存储到字节数组 b 中;

  • 2.1 FileInputStream类：

    • FileInputStream(File file) 通过打开与实际文件的连接来创建一个 FileInputStream,该文件由文件系 统中的 File对象 file命名;

    • FileInputStream(String name) 通过打开与实际文件的连接来创建一个 FileInputStream,该文件由文件 系统中的路径名 name命名;

  3. 字符输入流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,给定要读取的文件的名称;

  4. 字符输出流Writer[超类]:

     1. write(int c) 写入单个字符;

     2. write(char[] cbuf) 写入字符数组;

     3. write(char[] cbuf, int off, int len) 写入字符数组的某一部分,off 数组的开始索引,len 写的字符个数;

     4. write(String str) 写入字符串;

     5. write(String str, int off, int len) 写入字符串的某一部分,off 字符串的开始索引,len 写的字符个数;

     6. flush() 刷新该流的缓冲;

     7. close() 关闭此流，但要先刷新它;

  • 4.1 FileWriter类：

    • FileWriter(File file) 创建一个新的FileWriter,给定要读取的File对象;

    • FileWriter(String fileName) 创建一个新的FileWriter,给定要读取的文件的名称;

  5. 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) 从字节输入流中读取键值对;

  6. 缓冲流、转换流、序列化流:

     1. 缓冲流:

        • 字节缓冲流：BufferedInputStream BufferedOutputStream;

        • 字符缓冲流：BufferedReader BufferedWriter;

     • 构造方法:

       • public BufferedInputStream(InputStream in) 创建一个新的缓冲输入流;

       • public BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流;

  • 1.1 字符缓冲流:

  • 构造方法：

    • public BufferedReader(Reader in) 创建一个新的缓冲输入流;

    • ublic BufferedWriter(Writer out) 创建一个新的缓冲输出流;

  • 方法：

    • BufferedReader：public String readLine() 读一行文字;

    • BufferedWriter：public void newLine() 分隔符,由系统属性定义符号;

  2. 转换流:

  • 2.1 InputStreamReader类:

  • 构造方法

    • InputStreamReader(InputStream in) 创建一个使用默认字符集的字符流;

    • InputStreamReader(InputStream in, String charsetName) 创建一个指定字符集的字符流;

  • 2.2 OutputStreamWriter类:

  • 构造方法

    • OutputStreamWriter(OutputStream in) 创建一个使用默认字符集的字符流;

    • OutputStreamWriter(OutputStream in, String charsetName) 创建一个指定字符集的字符流;

  3. 序列化:

  • 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 过滤filter: 可以通过 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)]

  2. 方法引用:

  • 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

     2. 导入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)

       4. 获取全类名

       • 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. 调用注解中的抽象方法获取配置的属性值