3-JavaAdvanced

最新推荐文章于 2024-06-05 17:31:42 发布

Goinhn

最新推荐文章于 2024-06-05 17:31:42 发布

阅读量142

点赞数

文章标签： Java

本文链接：https://blog.csdn.net/Goinhn/article/details/102553462

版权

JavaLearning 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Java语言高级

异常

异常：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

异常根类：
java.lang.Throwable
- java.lang.Error：无法处理，尽量避免
- java.lang.Exception：由于使用不当导致，可以避免

根类中的方法：
public void printStackTrace() :打印异常的详细信息。
包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。
public String getMessage() :获取发生异常的原因。
提示给用户的时候,就提示错误原因。
public String toString() :获取异常的类型和异常描述信息(不用)。

在这里插入图片描述

异常的处理：

抛出异常：throw
throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
声明异常throws
将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。
捕获异常：try…catch
Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。
finally代码块：
有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而ﬁnally就是解决这个问题的，在ﬁnally代码块中存放的代码都是一定会被执行的。
当只有在try或者catch中调用退出JVM的相关方法,此时ﬁnally才不会执行,否则ﬁnally永远会执行。

异常注意事项

多个异常分别处理。
多个异常一次捕获，多次处理。
多个异常一次捕获一次处理。

一次捕获多次处理:
注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

运行时异常被抛出可以不处理。即不捕获也不声明抛出。
如果ﬁnally有return语句,永远返回ﬁnally中的结果,避免该情况.

如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出

自定义的异常

在开发中根据自己业务的异常情况来定义异常类.

自定义一个编译期异常: 自定义类并继承于 java.lang.Exception 。
自定义一个运行时期的异常类:自定义类并继承于 java.lang.RuntimeException 。

多线程

并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。

注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

进程调度：
分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

线程类

java.lang.Thread
所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。

Thread类：
构造方法：
public Thread() :分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

常用方法：
public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。 public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

线程接口

java.lang.Runnable

Thread和Runable的对比

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

多线程原理

多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。
由JVM开启新的内存栈空间
在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。

线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

线程同步

ava中提供了同步机制(synchronized)来解决。
1、同步代码块
synchronized(同步锁) {
需要同步操作的代码
}
同步锁:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.
1. 锁对象可以是任意类型。
2. 多个线程对象要使用同一把锁。
注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。
2、同步方法
同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
对于非static方法,同步锁就是this。
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。
3、锁机制
Lock锁
java.util.concurrent.locks.Lock
public void lock() :加同步锁。
public void unlock() :释放同步锁。

线程状态

java.lang.Thread.State
在这里插入图片描述

等待唤醒机制

线程间通信：
多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。

等待唤醒机制：
通过一定的手段使各个线程能有效的利用资源

wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先入座。
notifyAll：则释放所通知对象的 wait set 上的全部线程。

线程池

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
顶级接口：
java.util.concurrent.Executor
提供了一些静态工厂：
java.util.concurrent.Executors

使用线程池对象：
创建线程池对象。
创建Runnable接口子类对象。(task)
提交Runnable接口子类对象。(take task)
关闭线程池(一般不做)。

Lambda 表达式

(参数类型参数名称) -> { 代码语句 }
省略写法：

小括号内参数的类型可以省略；
如果小括号内有且仅有一个参，则小括号可以省略；
如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

注意事项：

使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
使用Lambda必须具有上下文推断。
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

File类

java.io.File类
构造方法：
public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。 public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例。 public File(File parent, String child) ：从父抽象路径名和子路径名字符串创建新的 File实例。

一个File对象代表硬盘中实际存在的一个文件或者目录。
无论该路径下是否存在文件或者目录，都不影响File对象的创建。

成员方法：
public String getAbsolutePath() ：返回此File的绝对路径名字符串。
public String getPath() ：将此File转换为路径名字符串。
public String getName() ：返回由此File表示的文件或目录的名称。
public long length() ：返回由此File表示的文件的长度。

判断功能的方法：
public boolean exists() ：此File表示的文件或目录是否实际存在。
public boolean isDirectory() ：此File表示的是否为目录。
public boolean isFile() ：此File表示的是否为文件。

创建删除功能的方法：
public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
public boolean delete() ：删除由此File表示的文件或目录。
public boolean mkdir() ：创建由此File表示的目录。
public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。

目录的遍历：
public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
调用listFiles方法的File对象，表示的必须是实际存在的目录，否则返回null，无法进行遍历。

文件过滤器优化：
java.io.FileFilter
boolean accept(File pathname)

要么是.java文件。
要么是目录，用于继续遍历。

IO

以内存为核心
输入流和输出流
输入流：把数据从其他设备上读取到内存中的流。
输出流：把数据从内存中写出到其他设备上的流。

字节流和字符流
字节流：以字节为单位，读写数据的流。
字符流：以字符为单位，读写数据的流。

顶级父类：
字节流：
输入流：InputStream
输出流：OutputStream
字符流：
输入流：Reader
输出流：Writer

字节流

java.io.OutputStream：
public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
public void write(byte[] b) ：将 b.length字节从指定的字节数组写入此输出流。
public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 oﬀ开始输出到此输出流。
public abstract void write(int b) ：将指定的字节输出流。

	java.io.FileOutputStream 
	public FileOutputStream(File file) ：创建文件输出流以写入由指定的 File对象表示的文件。
	public FileOutputStream(String name) ： 创建文件输出流以指定的名称写入文件。 
	写出字节：
	write（int b）
	写出字节数组：
	write(byte[] b) 
	写出指定长度字节数组：
	write(byte[] b, int off, int len)

	数据追加写：
	public FileOutputStream(File file, boolean append) ： 创建文件输出流以写入由指定的 File对象表示的文件。 
	public FileOutputStream(String name, boolean append) ： 创建文件输出流以指定的名称写入文件。 
	append为true追加数据

java.io.InputStream
public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
public abstract int read() ：从输入流读取数据的下一个字节。
public int read(byte[] b) ：从输入流中读取一些字节数，并将它们存储到字节数组 b中。

	java.io.FileInputStream
	FileInputStream(File file) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 ﬁle命名。 
	FileInputStream(String name) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。 
	读取字节：
	read
	字节数组读取：
	read（byte[] b）

字符流

字符输入流：
java.io.Reader
public void close() ：关闭此流并释放与此流相关联的任何系统资源。
public int read() ：从输入流读取一个字符。
public int read(char[] cbuf) ：从输入流中读取一些字符，并将它们存储到字符数组 cbuf中。

	java.io.FileReader 类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
	FileReader(File file) ： 创建一个新的 FileReader ，给定要读取的File对象。  FileReader(String fileName) ： 创建一个新的 				FileReader ，给定要读取的文件的名称。 
	读取字符：
	read
	使用字符数组读取：
	read（char[] cbuf）

字符输出流：
java.io.Writer
void write(int c) 写入单个字符。
void write(char[] cbuf) 写入字符数组。
abstract void write(char[] cbuf, int off, int len) 写入字符数组的某一部分,oﬀ数组的开始索引,len写的字符个数。
void write(String str) 写入字符串。
void write(String str, int off, int len) 写入字符串的某一部分,oﬀ字符串的开始索引,len写的字符个数。
void flush() 刷新该流的缓冲。
void close() 关闭此流，但要先刷新它。
java.io.FileWriter 类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
FileWriter(File file) ：创建一个新的 FileWriter，给定要读取的File对象。
FileWriter(String fileName) ：创建一个新的 FileWriter，给定要读取的文件的名称。
写书字符：
write
flush ：刷新缓冲区，流对象可以继续使用。
close :先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。
write(char[] cbuf)
write(char[] cbuf, int off, int len)
write(String str)
write(String str, int off, int len)

属性集

java.util.Properties
public Object setProperty(String key, String value) ：保存一对属性。
public String getProperty(String key) ：使用此属性列表中指定的键搜索属性值。
public Set stringPropertyNames() ：所有键的名称的集合。
public void load(InputStream inStream) ：从字节输入流中读取键值对。

缓冲流

字节缓冲流： BufferedInputStream ， BufferedOutputStream
字符缓冲流： BufferedReader ， BufferedWriter

字节缓冲流：
public BufferedInputStream(InputStream in) ：创建一个新的缓冲输入流。
public BufferedOutputStream(OutputStream out) ：创建一个新的缓冲输出流。
字符缓冲流：
public BufferedReader(Reader in) ：创建一个新的缓冲输入流。
public BufferedWriter(Writer out) ：创建一个新的缓冲输出流。

BuﬀeredReader： public String readLine() : 读一行文字。
BuﬀeredWriter： public void newLine() : 写一行行分隔符,由系统属性定义符号。

转换流

在这里插入图片描述
解决不同编码之间问题转换：
以字节流为核心创建
java.io.InputStreamReader
InputStreamReader(InputStream in) : 创建一个使用默认字符集的字符流。
InputStreamReader(InputStream in, String charsetName) : 创建一个指定字符集的字符流。

java.io.OutputStreamWriter
OutputStreamWriter(OutputStream in) : 创建一个使用默认字符集的字符流。 OutputStreamWriter(OutputStream in, String charsetName) : 创建一个指定字符集的字符流。

序列化&&反序列化

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

序列化操作条件：
该类必须实现 java.io.Serializable 接口， Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出 NotSerializableException 。
该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

public final void writeObject (Object obj) : 将指定的对象写出。

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。
public final Object readObject () : 读取一个对象。
对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个ClassNotFoundException 异常。
另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个 InvalidClassException 异常。
该类的序列版本号与从流中读取的类描述符的版本号不匹配
该类包含未知数据类型
该类没有可访问的无参数构造方法

打印流

public PrintStream(String fileName) ：使用指定的文件名创建一个新的打印流。
System.setOut():设置系统的打印流流向

网络编程

软件结构
C/S结构：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件。
B/S结构：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。

网络通信协议：通信协议是对计算机必须遵守的规则，只有遵守这些规则，计算机之间才能进行通信。这就好比在道路中行驶的汽车一定要遵守交通规则一样，协议中对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守，最终完成数据交换。
TCP/IP协议：传输控制协议/因特网互联协议( Transmission Control Protocol/Internet Protocol)，是Internet最基本、最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议，并采用了4层的分层模型，每一层都呼叫它的下一层所提供的协议来完成自己的需求。

TCP：传输控制协议 (Transmission Control Protocol)。TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。
UDP：用户数据报协议(User Datagram Protocol)。UDP协议是一个面向无连接的协议。传输数据时，不需要建立连接，不管对方端服务是否启动，直接将数据、数据源和目的地都封装在数据包中，直接发送。每个数据包的大小限制在64k以内。它是不可靠协议，因为无连接，所以传输速度快，但是容易丢失数据。日常应用中,例如视频会议、QQ聊天等。

网络编程三要素：
协议：
IP地址：
端口号：

TCP通信：

客户端： java.net.Socket 类表示。创建 Socket 对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。
服务端： java.net.ServerSocket 类表示。创建 ServerSocket 对象，相当于开启一个服务，并等待客户端的连接。

public Socket(String host, int port) :创建套接字对象并将其连接到指定主机上的指定端口号。如果指定的host是null ，则相当于指定地址为回送地址。

Socket 类：该类实现客户端套接字，套接字指的是两台设备之间通讯的端点。
ServerSocket 类：这个类实现了服务器套接字，该对象等待通过网络的请求。
public Socket accept() ：侦听并接受连接，返回一个新的Socket对象，用于和客户端实现通信。该方法会一直阻塞直到建立连接。

函数式接口

函数式接口在Java中是指：有且仅有一个抽象方法的接口。
函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。

Java 8中专门为函数式接口引入了一个新的注解： @FunctionalInterface 。该注解可用于一个接口的定义上：

Lambda表达式延迟执行

SLF4J是应用非常广泛的日志框架，它在记录日志时为了解决这种性能浪费的问题，并不推荐首先进行字符串的拼接，而是将字符串的若干部分作为可变参数传入方法中，仅在日志级别满足要求的情况下才会进行字符串拼接。例如： LOGGER.debug(“变量{}的取值为{}。”, “os”, “macOS”) ，其中的大括号 {} 为占位符。如果满足日志级别要求，则会将“os”和“macOS”两个字符串依次拼接到大括号的位置；否则不会进行字符串拼接。这也是一种可行解决方案，但Lambda可以做到更好。

常用函数式接口：
Supplier接口
java.util.function.Supplier
包含一个无惨方法：
T get()
产生数据

Consumer接口：
java.util.function.Consumer
void accept(T t)
消费数据
andThen

Predicate接口
java.util.function.Predicate
test
and
or
negate

Function接口
apply
andThen

Stream流

流式思想
“Stream流”其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素（或其地址值）。

Pipelining: 中间操作都会返回流对象本身。这样多个操作可以串联成一个管道，如同流式风格（ﬂuent style）。这样做可以对操作进行优化，比如延迟执行(laziness)和短路( short-circuiting)。
内部迭代：以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代，这叫做外部迭代。 Stream提供了内部迭代的方式，流可以直接调用遍历方法。

java.util.stream.Stream
所有的** Collection** 集合都可以通过 stream 默认方法获取流；
java.util.Map 接口不是 Collection 的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流需要分key、value或entry等情况：
Stream接口的静态方法可以获取数组对应的流
常用方法：
forEach
filter
map
count
limit
skip
concat

方法引用

::方法引用符

Junit单元测试

测试分类：
1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。
2. 白盒测试：需要写代码的。关注程序具体的执行流程。
Junit使用：白盒测试
- 步骤：
  1. 定义一个测试类(测试用例)
    - 建议：
      - 测试类名：被测试的类名Test CalculatorTest
      - 包名：xxx.xxx.xx.test cn.itcast.test
  2. 定义测试方法：可以独立运行
    - 建议：
      - 方法名：test测试的方法名 testAdd()
      - 返回值：void
      - 参数列表：空参
  3. 给方法加@Test
  4. 导入junit依赖环境
- 判定结果：
  - 红色：失败
  - 绿色：成功
  - 一般我们会使用断言操作来处理结果
    - Assert.assertEquals(期望的结果,运算的结果);
- 补充：
  - @Before:
    - 修饰的方法会在测试方法之前被自动执行
  - @After:
    - 修饰的方法会在测试方法执行之后自动被执行

反射

框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
反射：将类的各个组成部分封装为其他对象，这就是反射机制
- 好处：
  1. 可以在程序运行过程中，操作这些对象。
  2. 可以解耦，提高程序的可扩展性。
获取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 getConstructor(类<?>… parameterTypes)
    - Constructor 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:获取方法名
案例：
- 需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
  - 实现：
    1. 配置文件
    2. 反射
  - 步骤：
    1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
    2. 在程序中加载读取配置文件
    3. 使用反射技术来加载类文件进内存
    4. 创建对象
    5. 执行方法

注解

概念：说明程序的。给计算机看的
注释：用文字描述程序的。给程序员看的
定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。
概念描述：
- JDK1.5之后的新特性
- 说明程序的
- 使用注解：@注解名称
作用分类：
①编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
②代码分析：通过代码里标识的注解对代码进行分析【使用反射】
③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】
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. 调用注解中的抽象方法获取配置的属性值
案例：简单的测试框架
小结：
1. 以后大多数时候，我们会使用注解，而不是自定义注解
2. 注解给谁用？
  1. 编译器
  2. 给解析程序用
3. 注解不是程序的一部分，可以理解为注解就是一个标签

MySql

DDL
DQL
DML
DCL
事务

JDBC

c3p0
durid

Goinhn

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
3-JavaAdvanced

Java语言高级异常异常：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。异常根类：java.lang.Throwable- java.lang.Error：无法处理，尽量避免- java.lang.Exception：由于使用不当导致，可以避免根类中的方法：public void printStackTrace() :打印异常的详细信息。包含了异常的...
复制链接

扫一扫

专栏目录