1. Java语言概述
1.1 JDK、JRE、JVM三者的关系
- JVM（Java Virtual Machine）java虚拟机，实现 “一次编译，到处运行”
- JRE（Java Runtime Environment）java运行环境，包含JVM标准实现以及Java核心类库
- JDK（Java Development Kit）java开发工具包，是整个java的核心，包括java运行环境JRE、java工具和java基础类库
1.2 数据类型
基本类型对应的包装类：
基本类型与包装类之间的转换：
温馨提示：在JDK5.0之后，基本类型和包装类之间的转换可以使用自动装箱和自动拆箱
1.3 JDK中主要的包：
2. 面向对象
面向对象和面向过程的理解：
- 面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做
- 面向对象：强调的是具备了功能的对象，以类或者对象为最小单位，考虑谁来做
几个概念的多种说法：
- 属性 = 成员变量 = field = 域，字段
- 方法 = 成员方法 = 函数 = method
- 创建类的对象 = 类的实例化 = 实例化类
所谓的匿名对象：就是在创建对象的时候没有显示的赋给一个变量名，特点是只能调用一次，通俗来讲就是所说的临时new一个对象（比如在函数的形参里）
类的属性有默认的初值
整型（byte、short、int、long：0）
浮点型（float、double：0.0）
字符型（char：0 （或'\u0000'））
布尔型（boolean：false）
引用数据类型（类、数组、接口：null）
局部变量没有初值，所以局部变量在声明时要显示的赋一个初值，特别说明：形参不用赋初值，在调用时赋值即可。
Java规定的四种权限修饰符：
权限从小到大顺序为：private < 缺省 < protected < public
具体的修饰范围：
注意：4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public
什么是方法的重写：
子类继承父类以后，可以对父类中同名的同参数的方法进行覆盖操作，重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
重写的规则：
- 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
- 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
- 特殊情况：子类不能重写父类中声明为private权限的方法
- 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
- 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
- 父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
- 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）
重写和重载的区别
重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。
所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”
而对于多态，只等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。
Java的多态：
多态的字面意思就是一个引用拥有多种形态，以继承为基础，根据引用的具体指向不同，使用该引用的操作也会有所不同。在编译时期，只能调用父类中声明的方法，但是在运行期，我们实际执行的是子类重写父类的方法。
总结：编译看（=）左边，运行看（=）右边
多态的三个必要条件：
- 要有继承
- 要有重写
- 向上转型：父类的引用指向子类的对象
多态代码示例：
public class Person {
String name;
int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void eat(){
System.out.println(name+"吃饭");
}
}
public class Student extends Person {
public Student (String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println(name+"吃面包");
}
}
public class Chinese extends Person {
public Chinese (String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println(name+"吃水果");
}
}
//测试方法
public class Test {
/*
编译器在编译代码的时候，并不知道要调用Chinese还是Student中eat的方法
等程序运行起来之后，形参a引用的具体对象确定后，才知道调用哪个方法
此时要注意：此处的形参类型必须是父类类型才可以，也就是向上转型
*/
public static void eat(Person person){
person.eat();
}
public static void main(String[] args){
Chinese p1 = new Chinese("张三",2);
Person p2 = new Person("李四",1);
eat(p1);
eat(p2);
}
}
向下转型：
有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。如何才能调用子类特的属性和方法？使用向下转型。
如何实现：使用强制类型转换符
注意点：
为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof判断转型对象a是否是类A的实例，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
super关键字
super关键字可以理解为：父类的
super调用属性和方法
- 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
- 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
- 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
super调用构造器
- 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
- 使用"super(形参列表)"时，必须声明在子类构造器的首行！
- 在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二一，不能同时出现
- 在构造器的首行，没显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()
- 在类的多个构造器中，至少一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器
static关键字
static关键字可以用来修饰属性、方法、代码块、内部类
1. static修饰属性
当类的属性被static修饰时，当创建了类的多个对象，多个对象共享同一个该静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，也是被修改过了的。
static修饰属性的其他说明：
- 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
- 静态变量的加载要早于对象的创建。
- 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
2. static修饰方法
随着类的加载而加载，可以通过"类.静态方法"的方式进行调用，静态方法中，只能调用静态的方法或属性非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
注意点：在静态的方法内，不能使用this关键字、super关键字
代码块
作用：用来初始化类、对象的信息
静态代码块：
随着类的加载而执行，而且只执行一次，用来初始化类的信息
如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
静态代码块的执行要优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
非静态代码块：
随着对象的创建而执行，每创建一个对象，就执行一次非静态代码块，可以在创建对象时，对对象的属性等进行初始化
如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法
final关键字
可以用来修饰：类、方法、变量
- final 用来修饰一个类:此类不能被其他类所继承。比如：String类、System类、StringBuffer类
- final 用来修饰方法：表明此方法不可以被重写
- final 用来修饰变量：此时的"变量"就称为是一个常量
abstract关键字
用来修饰：类、方法
1. abstract修饰类：抽象类
- 此类不能实例化
- 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
- 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
2. abstract修饰方法：抽象方法
- 抽象方法只方法的声明，没有方法体
- 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
- 若子类重写了父类中的所的抽象方法后，此子类方可实例化
- 若子类没重写父类中的所的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
注意点：
abstract不能用来修饰：属性、构造器等结构
abstract不能用来修饰私方法、静态方法、final的方法、final的类
interface接口
接口使用interface来定义，Java中，接口和类是并列的两个结构，接口中不能定义构造器的！意味着接口不可以实例化。接口的具体使用，体现多态性。
如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化，如果实现类没覆盖接口中所的抽象方法，则此实现类仍为一个抽象类。
Java类可以实现多个接口，弥补了Java单继承性的局限性
接口与接口之间可以继承，而且可以多继承
接口中变量默认的修饰符是：public static final ， 方法：public abstract
内部类
Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
如何创建成员内部类的对象？
创建静态的Dog内部类的实例(静态的成员内部类)：
Person.Dog dog = new Person.Dog();创建非静态的Bird内部类的实例(非静态的成员内部类):
Person.Bird bird = new Person.Bird();//错误的
//正确写法
Person p = new Person();
Person.Bird bird = p.new Bird();
如何在成员内部类中调用外部类的结构？
class Person{
String name = "小明";
public void eat(){
}
//非静态成员内部类
class Bird{
String name = "杜鹃";
public void display(String name){
System.out.println(name);//方法的形参
System.out.println(this.name);//内部类的属性
System.out.println(Person.this.name);//外部类的属性
//Person.this.eat();
}
}
}3. 异常的体系结构
* java.lang.Throwable
* |-----java.lang.Error:一般不编写针对性的代码进行处理。
* |-----java.lang.Exception:可以进行异常的处理
* |------编译时异常(checked)
* |-----IOException
* |-----FileNotFoundException
* |-----ClassNotFoundException
* |------运行时异常(unchecked,RuntimeException)
* |-----NullPointerException
* |-----ArrayIndexOutOfBoundsException
* |-----ClassCastException
* |-----NumberFormatException
* |-----InputMismatchException
* |-----ArithmeticException
3.1 异常的处理：
处理方式一：try-catch-finally ，可能出现异常的代码放在try代码块里，抛出的异常类型在catch里，finally是一定能执行的代码
处理方式二："throws + 异常类型"
写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。异常代码后续的代码，就不再执行！
两种方式的对比：
try-catch-finally:真正的将异常给处理掉了。
throws的方式只是将异常抛给了方法的调用者。并没真正将异常处理掉。
在开发中，如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，如果子类重写的方法中有异常只能用try-catch-finally
4. 多线程
4.1 几个概念
1. 程序（program）：
是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。
2. 进程（process）：
程序的一次执行过程，或是正在运行的一个程序。进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
3. 线程（thread）：
进程可进一步细化为线程，是一个程序内部的一条执行路径。线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小。
一个java运行程序java.exe，至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。
4. 并行和并发的理解：
并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀
4.2 创建多线程的方式
方式一：继承Thread类
步骤：
1. 创建一个继承于Thread类的子类
2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
3. 创建Thread类的子类的对象
4. 通过此对象调用start()：①启动当前线程 ② 调用当前线程的run()（自动调用）
方式二：实现Runnable接口
1. 创建一个实现了Runnable接口的类
2. 实现类去实现Runnable中的抽象方法：run()
3. 创建实现类的对象
4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5. 通过Thread类的对象调用start()
两种方式的对比：
开发中优先选择：实现Runnable接口的方式，原因：
- 实现的方式没有类单继承的局限性
- 实现的方式更适合处理多个线程共享数据的情况
相同点：
- 两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
- 目前两种方式，要想启动线程，都是调用的Thread类中的start()。
线程的优先级：
* MAX_PRIORITY：10
* MIN _PRIORITY：1
* NORM_PRIORITY：5 默认优先级
方式三：实现Callable接口 （JDK5.0新增）
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
new Thread(futureTask).start();
try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println("总和为：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
- call()可以返回值的。
- call()可以抛出异常，被外面的操作捕获，获取异常的信息
- Callable是支持泛型的
方式四：使用线程池
经常创建和销毁使用量特别大的资源，比如并发情况下的线程对性能影响很大。提前创建好多个线程，放入线程池中，使用时直接 获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
- 便于线程管理
关键参数：
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没任务时最多保持多长时间后会终止
代码示例：
class NumberThread implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
//1. 提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//设置线程池的属性
// System.out.println(service.getClass());
// service1.setCorePoolSize(15);
// service1.setKeepAliveTime();
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());//适合适用于Runnable
// service.submit(Callable callable);//适合使用于Callable
//3.关闭连接池
service.shutdown();
}
}4.3 Thread类中常用的方法
- start():启动当前线程；调用当前线程的run()
- run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
- currentThread():静态方法，返回执行当前代码的线程
- getName():获取当前线程的名字
- setName():设置当前线程的名字
- yield():释放当前cpu的执行权
- join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
- stop():已过时。当执行此方法时，强制结束当前线程。
- sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
- isAlive():判断当前线程是否存活
- getPriority():获取线程的优先级
- setPriority(int p):设置线程的优先级
4.4 线程的生命周期
4.5 线程的同步机制
通过线程的同步机制来解决线程的安全问题
方式一：同步代码块
synchronized(同步监视器){
//需要被同步的代码
}说明：
需要被同步的代码：操作共享数据的代码
同步监视器：俗称 “锁” 任何一个类的对象，都可以充当锁，多个线程必须共用同一把锁
方式二：同步方法
如果操作共享数据的代码完整的声明在一个方法中，并且方法中没有多余的代码，我们可以将此方法声明为同步方法
- 同步方法仍然涉及到同步监视器，只是不需要我们显示的声明
- 非静态的同步方法，同步监视器是：this
- 静态的同步方法，同步监视器是：当前类本身
方式三：Lock锁
从 JDK 5.0 开始 Java 提供了更强大的线程同步机制 通过显式定义同步锁对象来实现同步。同步锁使用 Lock 对象充当 。
class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m(){
lock.lock();
try{
// 保证线程安全的代码
}
finally{
lock.unlock();
}
}
}synchronized 与 Lock的异同？
相同点：二者都可以解决线程安全问题
不同点：
- synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
- Lock是显示锁需要手动的启动同步（lock()，同时结束同步也需要手动的实现（unlock()）
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且有较好的扩展性（提供更多的子类）
4.6 线程的通信
线程的通信涉及到三个方法：
- wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
- notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
- notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
说明：
- 三个方法必须使用在synchronized同步代码块或者同步方法中
- 三个方法的调用者必须是同步代码块或者同步方法中的同步监视器， 否则会出现IllegalMonitorStateException异常
- 三个方法是定义在java.lang.Object类中。
sleep和wait()的异同？
相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
不同点：
- 两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
- 调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
- 如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。
总结释放锁的操作：
总结不释放锁的操作：
5. Java常用类
5.1 String类中的常用方法
- int length()：返回字符串的长度： return value.length
- char charAt(int index)： 返回某索引处的字符return value[index]
- boolean isEmpty()：判断是否是空字符串：return value.length == 0
- String toLowerCase()：使用默认语言环境，将 String 中的所字符转换为小写
- String toUpperCase()：使用默认语言环境，将 String 中的所字符转换为大写
- String trim()：返回字符串的副本，忽略前导空白和尾部空白
- boolean equals(Object obj)：比较字符串的内容是否相同
- boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写
- String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”
- int compareTo(String anotherString)：比较两个字符串的大小
- String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
- String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
- boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
- boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
- boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
- boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
- int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
- int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
- int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
- int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
注：indexOf和lastIndexOf方法如果未找到都是返回-1
替换：
- String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所 oldChar 得到的。
- String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所匹配字面值目标序列的子字符串。
- String replaceAll(String regex, String replacement)：使用给定的 replacement 替换此字符串所匹配给定的正则表达式的子字符串。
- String replaceFirst(String regex, String replacement)：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
匹配:
- boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
切片：
- String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
- String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
String类和基本数据类型和包装类之间的转换
String --> 基本数据类型、包装类：调用包装类的静态方法：parseXxx(str)
基本数据类型、包装类 --> String: 调用String重载的valueOf(xxx)
@Test
public void test1(){
String str1 = "123";
// int num = (int)str1;//错误的
int num = Integer.parseInt(str1);
String str2 = String.valueOf(num);//"123"
String str3 = num + "";
System.out.println(str1 == str3);
}与字符数组之间的转换：
String --> char[]:调用String的toCharArray()
char[] --> String:调用String的构造器
@Test
public void test2(){
String str1 = "abc123"; //题目： a21cb3
char[] charArray = str1.toCharArray();
for (int i = 0; i < charArray.length; i++) {
System.out.println(charArray[i]);
}
char[] arr = new char[]{'h','e','l','l','o'};
String str2 = new String(arr);
System.out.println(str2);
}与字节数组之间的转换：
编码：String --> byte[]:调用String的getBytes()
解码：byte[] --> String:调用String的构造器
String、StringBuffer、StringBuilder三者的对比：
- String:不可变的字符序列；底层使用char[]存储
- StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
- StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储
三者的执行效率：
从高到低排列：StringBuilder > StringBuffer > String
StringBuffer、StringBuilder中的常用方法：
增：append(xxx)
删：delete(int start,int end)
改：setCharAt(int n ,char ch) / replace(int start, int end, String str)
查：charAt(int n )
插：insert(int offset, xxx)
长度：length();
6. Java集合（容器）
数组存储的弊端：
- 一旦初始化以后，其长度就不可修改。
- 数组中提供的方法非常限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
- 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
- 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。
6.1 Collection接口
|----Collection接口：单列集合，用来存储一个一个的对象
* |----List接口：存储序的、可重复的数据。 -->“动态”数组
* |----ArrayList、LinkedList、Vector
*
* |----Set接口：存储无序的、不可重复的数据 -->高中讲的“集合”
* |----HashSet、LinkedHashSet、TreeSet
遍历Collection的两种方式：
- 使用迭代器Iterator
- foreach循环（也叫增强for循环）
示例代码：
Iterator iterator = coll.iterator();
//hasNext():判断是否还下一个元素
while(iterator.hasNext()){
//next():①指针下移 ②将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}注意：增强for循环内部仍然调用了迭代器
6.1.1 List接口
List接口存储的数据特点：存储有序、可重复的数据
常用的方法：
增：add(Object obj)
删：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：① Iterator迭代器方式
② 增强for循环
③ 普通的循环
List接口常用的实现类：
- ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
- LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
- Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储
说明：
ArrayList的初始化容量大小为0，当执行add方法的时候扩容为10，随后每次扩容都变为原来的1.5倍左右（当oldCapacity为偶数的时候就是1.5倍，否则就是1.5倍左右，因为奇数的计算会丢掉小数点）
6.1.2 Set接口
存储的数据特点：无序的、不可重复的元素
Set接口中没有额外的新方法，与Collection中声明过的一样
元素添加的过程：（以HashSet为例）
- 我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，
- 此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置，判断
- 数组此位置上是否已经元素：
- 如果此位置上没其他元素，则元素a添加成功。 --->情况1
- 如果此位置上其他元素b(或以链表形式存在的多个元素，则比较元素a与元素b的hash值：
- 如果hash值不相同，则元素a添加成功。--->情况2
- 如果hash值相同，进而需要调用元素a所在类的equals()方法：
- equals()返回true,元素a添加失败
- equals()返回false,则元素a添加成功。--->情况2
Set接口常用的实现类：
- HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值，底层是数组加链表的结构（HashMap）
- LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历，元素的插入和取出顺序满足FIFO，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。对于频繁的遍历操作，LinkedHashSet效率高于HashSet。底层是链表和哈希表。
- TreeSet：可以照添加对象的指定属性，进行排序。
6.2 Map接口
|----Map:双列数据，存储key-value对的数据 ---类似于高中的函数：y = f(x)
* |----HashMap:作为Map的主要实现类；线程不安全的，效率高；存储null的key和value
* |----LinkedHashMap:保证在遍历map元素时，可以照添加的顺序实现遍历。
* 原因：在原的HashMap底层结构基础上，添加了一对指针，指向前一个和后一 个元素。对于频繁的遍历操作，此类执行效率高于HashMap。
*
* |----TreeMap:保证照添加的key-value对进行排序，实现排序遍历。此时考虑key的 自然排序或定制排序，底层使用红黑树
*
* |----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value
* |----Properties:常用来处理配置文件。key和value都是String类型
HashMap的底层：数组+链表 （jdk7及之前) ；数组+链表+红黑树 （jdk 8)
存储结构的理解：
- >Map中的key:无序的、不可重复的，使用Set存储所的key ---> key所在的类要重写equals()和hashCode() （以HashMap为例)
- >Map中的value:无序的、可重复的，使用Collection存储所的value --->value所在的类要重写equals()
- > 一个键值对：key-value构成了一个Entry对象。
- >Map中的entry:无序的、不可重复的，使用Set存储所的entry
Map常用的方法：
- * 添加：put(Object key,Object value)
- * 删除：remove(Object key)
- * 修改：put(Object key,Object value)
- * 查询：get(Object key)
- * 长度：size()
- * 遍历：keySet() / values() / entrySet()
6.3 Collectiions工具类的使用
作用：操作Collection和Map的工具类
常用方法：
- reverse(List)：反转 List 中元素的顺序
- shuffle(List)：对 List 集合元素进行随机排序
- sort(List)：根据元素的自然顺序对指定 List 集合元素升序排序
- sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
- swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
- Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
- Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
- Object min(Collection)
- Object min(Collection，Comparator)
- int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
- void copy(List dest,List src)：将src中的内容复制到dest中
- boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所旧值
7. IO流
7.1 File类
File类的理解：
- File类声明在java.io包下
- File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹)
- File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。
- File类的对象常作为参数传递到流的构造器中，指明读取或写入的"终点"
File类的实例化，常用构造器：
File(String filePath)
File(String parentPath,String childPath)
File(File parentFile,String childPath)
File类的常用方法
7.2 IO流概述
流的分类：
- 操作数据单位：字节流、字符流
- 数据的流向：输入流、输出流
- 流的角色：节点流、处理流
体系结构：
流的输入、输出标准化过程：
输入过程：
① 创建File类的对象，指明读取的数据的来源。（要求此文件一定要存在）
② 创建相应的输入流，将File类的对象作为参数，传入流的构造器中
③ 具体的读入过程：创建相应的byte[] 或 char[]。
④ 关闭流资源
输出过程：
① 创建File类的对象，指明写出的数据的位置。（不要求此文件一定要存在）
② 创建相应的输出流，将File类的对象作为参数，传入流的构造器中
③ 具体的写出过程：write(char[]/byte[] buffer,0,len)
④ 关闭流资源
7.2.1 FilerReader/FileWriter/FileInputStream/FileOutputStream 文件流(节点流)
对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理
对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,...)，使用字节流处理
FileReader的使用：
@Test
public void testFileReader1() {
FileReader fr = null;
try {
//1.File类的实例化
File file = new File("hello.txt");
//2.FileReader流的实例化
fr = new FileReader(file);
//3.读入的操作
//read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
char[] cbuf = new char[5];
int len;
while((len = fr.read(cbuf)) != -1){
//方式一：
//错误的写法
// for(int i = 0;i < cbuf.length;i++){
// System.out.print(cbuf[i]);
// }
//正确的写法
// for(int i = 0;i < len;i++){
// System.out.print(cbuf[i]);
// }
//方式二：
//错误的写法,对应着方式一的错误的写法
// String str = new String(cbuf);
// System.out.print(str);
//正确的写法
String str = new String(cbuf,0,len);
System.out.print(str);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fr != null){
//4.资源的关闭
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}FileWriter的使用：
从内存中写出数据到硬盘的文件里。File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。File对应的硬盘中的文件如果存在：
如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原文件的覆盖
如果流使用的构造器是：FileWriter(file,true):不会对原文件覆盖，而是在原文件基础上追加内容
@Test
public void testFileWriter() {
FileWriter fw = null;
try {
//1.提供File类的对象，指明写出到的文件
File file = new File("hello1.txt");
//2.提供FileWriter的对象，用于数据的写出
fw = new FileWriter(file,false);
//3.写出的操作
fw.write("I have a dream!\n");
fw.write("you need to have a dream!");
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.流资源的关闭
if(fw != null){
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}FileInputStream / FileOutputStream的使用：
代码示例：对图片的复制操作：
@Test
public void testFileInputOutputStream() {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//1.造文件
File srcFile = new File("爱情与友情.jpg");
File destFile = new File("爱情与友情2.jpg");
//2.造流
fis = new FileInputStream(srcFile);
fos = new FileOutputStream(destFile);
//3.复制的过程
byte[] buffer = new byte[5];
int len;
while((len = fis.read(buffer)) != -1){
fos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fos != null){
//4.关闭流
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
7.2.2 缓冲流的使用
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter
作用：内部提供了一个缓冲区，默认情况下是8kb来提高流的读取、写入的速度
典型代码示例：
使用BufferedInputStream和BufferedOutputStream:处理非文本文件
//实现文件复制的方法
public void copyFileWithBuffered(String srcPath,String destPath){
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//1.造文件
File srcFile = new File(srcPath);
File destFile = new File(destPath);
//2.造流
//2.1 造节点流
FileInputStream fis = new FileInputStream((srcFile));
FileOutputStream fos = new FileOutputStream(destFile);
//2.2 造缓冲流
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
//3.复制的细节：读取、写入
byte[] buffer = new byte[1024];
int len;
while((len = bis.read(buffer)) != -1){
bos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.资源关闭
//要求：先关闭外层的流，再关闭内层的流
if(bos != null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bis != null){
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
// fos.close();
// fis.close();
}
}使用BufferedReader和BufferedWriter：处理文本文件
@Test
public void testBufferedReaderBufferedWriter(){
BufferedReader br = null;
BufferedWriter bw = null;
try {
//创建文件和相应的流
br = new BufferedReader(new FileReader(new File("dbcp.txt")));
bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));
//读写操作
//方式一：使用char[]数组
// char[] cbuf = new char[1024];
// int len;
// while((len = br.read(cbuf)) != -1){
// bw.write(cbuf,0,len);
// // bw.flush();
// }
//方式二：使用String
String data;
while((data = br.readLine()) != null){
//方法一：
// bw.write(data + "\n");//data中不包含换行符
//方法二：
bw.write(data);//data中不包含换行符
bw.newLine();//提供换行的操作
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭资源
if(bw != null){
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(br != null){
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
7.2.3 转换流的使用
转换流属于字符流
InputStreamReader：将一个字节的输入流转换为字符的输入流
相当于解码：字节、字节数组------>字符数组、字符串
OutputStreamWriter：将一个字符的输出流转换为字节的输出流
相当于编码：字符数组、字符串 ------> 字节、字节数组
7.2.4 对象流
ObjectInputStream 和 ObjectOutputStream
作用：
ObjectOutputStream:内存中的对象--->存储中的文件、通过网络传输出去：序列化过程
ObjectInputStream:存储中的文件、通过网络接收过来 --->内存中的对象：反序列化过程
对象的序列化机制：
对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。/当其它程序获取了这种二进制流，就可以恢复成原来的Java对象
示例代码：
序列化代码实现：
@Test
public void testObjectOutputStream(){
ObjectOutputStream oos = null;
try {
//1.
oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
//2.
oos.writeObject(new String("我爱北京天安门"));
oos.flush();//刷新操作
oos.writeObject(new Person("王铭",23));
oos.flush();
oos.writeObject(new Person("张学良",23,1001,new Account(5000)));
oos.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(oos != null){
//3.
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}反序列化代码实现：
@Test
public void testObjectInputStream(){
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream("object.dat"));
Object obj = ois.readObject();
String str = (String) obj;
Person p = (Person) ois.readObject();
Person p1 = (Person) ois.readObject();
System.out.println(str);
System.out.println(p);
System.out.println(p1);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if(ois != null){
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}实现序列化的对象所属的类需要满足：
- 需要实现接口：Serializable
- 当前类提供一个全局常量：serialVersionUID
- 除了当前Person类需要实现Serializable接口之外，还必须保证其内部所属性也必须是可序列化的。（默认情况下，基本数据类型可序列化）
- ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
8. 网络编程：
8.1 Socket
利用套接字 Socket) 开发网络应用程序早已被广泛的采用，以至于成为事实上的标准 。IP地址和端口号组成一个唯一能识别的标识符套接字，通信的两端都要有Socket，是两台机器通信的端点，网络通信其实就是两个Socket之间的通信，Socket允许程序把网络连接成一个流，数据在两个Socket间通过IO传输
Socket的分类：
- 流套接字（ stream socket ）：使用 TCP 提供可依赖的字节流服务
- 数据报套接字（ datagram socket ）：使用 UDP 提供“尽力而为”的数据报服务
9. Java反射机制
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)。接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例。加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为: 反射。换句话说，Class的实例就对应着一个运行时类（对应的是一个加载到JVM中的一个.class文件）。
9.1 Java反射机制提供的功能：
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时获取泛型信息
- 在运行时调用任意一个对象的成员变量和 方法
- 在运行时处理 注解
- 生成动态代理
获取Class实例的几种方式：
//方式一：调用运行时类的属性：.class
Class clazz1 = Person.class;
System.out.println(clazz1);
//方式二：通过运行时类的对象,调用getClass()
Person p1 = new Person();
Class clazz2 = p1.getClass();
System.out.println(clazz2);
//方式三：调用Class的静态方法：forName(String classPath)
Class clazz3 = Class.forName("java.lang.String");
System.out.println(clazz3);
System.out.println(clazz1 == clazz2);
System.out.println(clazz1 == clazz3);
//方式四：使用类的加载器：ClassLoader (了解)
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class clazz4 = classLoader.loadClass("com.atguigu.java.Person");
System.out.println(clazz4);
System.out.println(clazz1 == clazz4);
创建类对象的方式：
- 方式一：new + 构造器
- 方式二：要创建Xxx类的对象，可以考虑：Xxx、Xxxs、XxxFactory、XxxBuilder类中查看是否有静态方法的存在。可以调用其静态方法，创建Xxx对象。
- 方式三：通过反射
代码示例：使用Class类的方法newInstance()创建类对象
Class<Person> clazz = Person.class;
Person obj = clazz.newInstance();
System.out.println(obj);
说明：
newInstance():调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器。要想此方法正常的创建运行时类的对象，要求：运行时类必须提供空参的构造器，空参的构造器的访问权限得够，通常设置为public。这也是为什么平时在创建java类的时候要创建一个空参构造器的原因，便以通过反射机制来创建运行时类的对象。
Class类的常用方法：
9.2 通过反射获取运行时类的完整结构
我们可以通过反射，获取对应的运行时类中所有的属性、方法、构造器、父类、接口、父类的泛型、包、注解、异常等......
典型代码示例：
@Test
public void test1(){
Class clazz = Person.class;
//获取属性结构
//getFields():获取当前运行时类及其父类中声明为public访问权限的属性
Field[] fields = clazz.getFields();
for(Field f : fields){
System.out.println(f);
}
System.out.println();
//getDeclaredFields():获取当前运行时类中声明的所属性。（不包含父类中声明的属性
Field[] declaredFields = clazz.getDeclaredFields();
for(Field f : declaredFields){
System.out.println(f);
}
}
@Test
public void test1(){
Class clazz = Person.class;
//getMethods():获取当前运行时类及其所父类中声明为public权限的方法
Method[] methods = clazz.getMethods();
for(Method m : methods){
System.out.println(m);
}
System.out.println();
//getDeclaredMethods():获取当前运行时类中声明的所方法。（不包含父类中声明的方法
Method[] declaredMethods = clazz.getDeclaredMethods();
for(Method m : declaredMethods){
System.out.println(m);
}
}
/*
获取构造器结构
*/
@Test
public void test1(){
Class clazz = Person.class;
//getConstructors():获取当前运行时类中声明为public的构造器
Constructor[] constructors = clazz.getConstructors();
for(Constructor c : constructors){
System.out.println(c);
}
System.out.println();
//getDeclaredConstructors():获取当前运行时类中声明的所的构造器
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
for(Constructor c : declaredConstructors){
System.out.println(c);
}
}
/*
获取运行时类的父类
*/
@Test
public void test2(){
Class clazz = Person.class;
Class superclass = clazz.getSuperclass();
System.out.println(superclass);
}
/*
获取运行时类的带泛型的父类
*/
@Test
public void test3(){
Class clazz = Person.class;
Type genericSuperclass = clazz.getGenericSuperclass();
System.out.println(genericSuperclass);
}
/*
获取运行时类的带泛型的父类的泛型
代码：逻辑性代码 vs 功能性代码
*/
@Test
public void test4(){
Class clazz = Person.class;
Type genericSuperclass = clazz.getGenericSuperclass();
ParameterizedType paramType = (ParameterizedType) genericSuperclass;
//获取泛型类型
Type[] actualTypeArguments = paramType.getActualTypeArguments();
// System.out.println(actualTypeArguments[0].getTypeName());
System.out.println(((Class)actualTypeArguments[0]).getName());
}
/*
获取运行时类实现的接口
*/
@Test
public void test5(){
Class clazz = Person.class;
Class[] interfaces = clazz.getInterfaces();
for(Class c : interfaces){
System.out.println(c);
}
System.out.println();
//获取运行时类的父类实现的接口
Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
for(Class c : interfaces1){
System.out.println(c);
}
}
/*
获取运行时类所在的包
*/
@Test
public void test6(){
Class clazz = Person.class;
Package pack = clazz.getPackage();
System.out.println(pack);
}
/*
获取运行时类声明的注解
*/
@Test
public void test7(){
Class clazz = Person.class;
Annotation[] annotations = clazz.getAnnotations();
for(Annotation annos : annotations){
System.out.println(annos);
}
}9.3 通过反射调用运行时类的指定结构
9.3.1 调用指定的属性
@Test
public void testField1() throws Exception {
Class clazz = Person.class;
//创建运行时类的对象
Person p = (Person) clazz.newInstance();
//1. getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
Field name = clazz.getDeclaredField("name");
//2.保证当前属性是可访问的
name.setAccessible(true);
//3.获取、设置指定对象的此属性值
name.set(p,"Tom");
System.out.println(name.get(p));
}9.3.2 调用指定的方法
@Test
public void testMethod() throws Exception {
Class clazz = Person.class;
//创建运行时类的对象
Person p = (Person) clazz.newInstance();
/*
1.获取指定的某个方法
getDeclaredMethod():参数1 ：指明获取的方法的名称 参数2：指明获取的方法的形参列表
*/
Method show = clazz.getDeclaredMethod("show", String.class);
//2.保证当前方法是可访问的
show.setAccessible(true);
/*
3. 调用方法的invoke():参数1：方法的调用者 参数2：给方法形参赋值的实参
invoke()的返回值即为对应类中调用的方法的返回值。
*/
Object returnValue = show.invoke(p,"CHN"); //String nation = p.show("CHN");
System.out.println(returnValue);
System.out.println("*************如何调用静态方法*****************");
// private static void showDesc()
Method showDesc = clazz.getDeclaredMethod("showDesc");
showDesc.setAccessible(true);
//如果调用的运行时类中的方法没返回值，则此invoke()返回null
// Object returnVal = showDesc.invoke(null);
Object returnVal = showDesc.invoke(Person.class);
System.out.println(returnVal);//null
}9.3.3 调用指定的构造器
@Test
public void testConstructor() throws Exception {
Class clazz = Person.class;
//private Person(String name)
/*
1.获取指定的构造器
getDeclaredConstructor():参数：指明构造器的参数列表
*/
Constructor constructor = clazz.getDeclaredConstructor(String.class);
//2.保证此构造器是可访问的
constructor.setAccessible(true);
//3.调用此构造器创建运行时类的对象
Person per = (Person) constructor.newInstance("Tom");
System.out.println(per);
}9.4 反射的应用：动态代理
代理模式的原理：
使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
静态代理的缺点：
① 代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。
② 每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。
9.4.1 动态代理：
动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。动态代理的源码时在程序运行期间有JVM根据反射等机制动态的生成，所以在运行前并不存在代理类的字节码文件。
动态代理使用场合：
- 调试
- 远程方法的调用
动态代理的实现：
主要解决两个问题：
- 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。（通过Proxy.newProxyInstance()实现）
- 问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。(通过InvocationHandler接口的实现类及其方法invoke())
代码实现：
在java的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过这个类和这个接口可以生成JDK动态代理类和动态代理对象。
/**
*
* 动态代理的举例
*
* @author shkstart
* @create 2019 上午 10:18
*/
interface Human{
String getBelief();
void eat(String food);
}
//被代理类
class SuperMan implements Human{
@Override
public String getBelief() {
return "I believe I can fly!";
}
@Override
public void eat(String food) {
System.out.println("我喜欢吃" + food);
}
}
class HumanUtil{
public void method1(){
System.out.println("====================通用方法一====================");
}
public void method2(){
System.out.println("====================通用方法二====================");
}
}
class ProxyFactory{
//调用此方法，返回一个代理类的对象。解决问题一
public static Object getProxyInstance(Object obj){//obj:被代理类的对象
MyInvocationHandler handler = new MyInvocationHandler();
handler.bind(obj);
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
}
}
class MyInvocationHandler implements InvocationHandler{
private Object obj;//需要使用被代理类的对象进行赋值
public void bind(Object obj){
this.obj = obj;
}
//当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
//将被代理类要执行的方法a的功能就声明在invoke()中
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
HumanUtil util = new HumanUtil();
util.method1();
//method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
//obj:被代理类的对象
Object returnValue = method.invoke(obj,args);
util.method2();
//上述方法的返回值就作为当前类中的invoke()的返回值。
return returnValue;
}
}
public class ProxyTest {
public static void main(String[] args) {
SuperMan superMan = new SuperMan();
//proxyInstance:代理类的对象
Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
//当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
String belief = proxyInstance.getBelief();
System.out.println(belief);
proxyInstance.eat("四川麻辣烫");
System.out.println("*****************************");
NikeClothFactory nikeClothFactory = new NikeClothFactory();
ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
proxyClothFactory.produceCloth();
}
}10. Java8新特性
10.1 Lambda表达式
Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
Lambda表达式的基本语法：
“—>”：lambda操作符
“—>”左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表）
“—>”右边：lambda体 （其实就是重写的抽象方法的方法体）
语法格式：
10.1.1 函数式接口
如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。
Lambda表达式的本质：作为函数式接口的实例
Java8中关于Lambda表达式提供的4个基本的函数式接口：
何时使用Lambda表达式？
当需要对一个函数式接口实例化的时候，可以使用lambda表达式。
何时使用给定的函数式接口？
如果我们开发中需要定义一个函数式接口，首先看看在已有的jdk提供的函数式接口是否提供了
能满足需求的函数式接口。如果有，则直接调用即可，不需要自己再自定义了。
10.1.2 方法引用 、构造器引用
当传递给Lambda体的操作已经有实现的方法了，就可以使用方法引用，通过方法的名字来指向一个方法。
要求：接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同！
主要分为下面三种情况：
- 对象::示例方法名
- 类::静态方法名
- 类::示例方法名
构造器引用：
和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类的类型
格式：ClassName::new
数组引用：
格式：type[]::new
10.2 Stream API
Stream API的理解：
Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。Stream关注的是对数据的运算，与CPU打交道，集合关注的是数据的存储，与内存打交道
注意点：
Stream 自己不会存储元素。
Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
Stream的使用流程：
① Stream的实例化
② 一系列的中间操作（过滤、映射、...)
③ 终止操作
10.3 Optional类
Optional<T> 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。如果值存在则 isPresent() 方法会返回 true ，调用 get() 方法会返回该对象。
常用方法：
扫一扫
1173
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
