Java基础知识

一、Java语言特点

• 面向对象（封装，继承，多态）

• 多线程

• 网络编程

二、JVM、JDK、JRE

2.1 JVM（Java Virtual Machine）

Java 虚拟机是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。

2.2 JDK（Java Development Kit）

JDK它是功能齐全的 Java SDK。它拥有 JRE 所拥有的一切，还有编译器（javac）和工具（如 javadoc 和 jdb）。它能够创建和编译程序。

2.3 JRE（Java Runtime Environment）

JRE 是 Java 运行时环境。它是运行已编译 Java 程序所需的所有内容的集合，包括 Java 虚拟机（JVM），Java 类库，java 命令和其他的一些基础构件。但是，它不能用于创建新程序。

三、编译型、解释型语言

• 编译型 ：编译型语言会通过编译器将源代码一次性翻译成可被该平台执行的机器码。一般情况下，编译语言的执行速度比较快，开发效率比较低。常见的编译性语言有 C、C++、Go、Rust 等等。
• 解释型 ：解释型语言会通过解释器一句一句的将代码解释（interpret）为机器代码后再执行。解释型语言开发效率比较快，执行速度比较慢。常见的解释性语言有 Python、JavaScript、PHP 等等。

四、Java和C++的区别

• Java 不提供指针来直接访问内存，程序内存更加安全
• Java 的类是单继承的，C++ 支持多重继承；虽然 Java 的类不可以多继承，但是接口可以多继承。
• Java 有自动内存管理垃圾回收机制(GC)，不需要程序员手动释放无用内存。
• C ++同时支持方法重载和操作符重载，但是 Java 只支持方法重载（操作符重载增加了复杂性，这与 Java 最初的设计思想不符）。

五、重载和重写

• 重载就是同样的一个方法能够根据输入数据的不同，做出不同的处理
• 重写就是子类对父类方法的重新改造，外部样子不能改变，内部逻辑可以改变

六、自动装箱与拆箱

• 装箱：将基本类型用它们对应的引用类型包装起来
• 拆箱：将包装类型转换为基本数据类型

七、解决浮点数运算的精度丢失问题

• BigDecimal 可以实现对浮点数的运算，不会造成精度丢失。通常情况下，大部分需要浮点数精确运算结果的业务场景（比如涉及到钱的场景）都是通过 BigDecimal 来做的。

八、面向对象和面向过程的区别

• 面向过程把解决问题的过程拆成一个个方法，通过一个个方法的执行解决问题。
• 面向对象会先抽象出对象，然后用对象执行方法的方式解决问题。

九、继承

• 子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，只是拥有。
• 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。

十、多态

• 对象类型和引用类型之间具有继承（类）/实现（接口）的关系；
• 引用类型变量发出的方法调用的到底是哪个类中的方法，必须在程序运行期间才能确定；
• 多态不能调用“只在子类存在但在父类不存在”的方法；
• 如果子类重写了父类的方法，真正执行的是子类覆盖的方法，如果子类没有覆盖父类的方法，执行的是父类的方法。

十一、接口和抽象类

11.1 共同点

• 都不能被实例化。
• 都可以包含抽象方法。
• 都可以有默认实现的方法（Java 8 可以用 default 关键字在接口中定义默认方法）。

11.2 区别

• 接口主要用于对类的行为进行约束，你实现了某个接口就具有了对应的行为。抽象类主要用于代码复用，强调的是所属关系。
• 一个类只能继承一个类，但是可以实现多个接口。
• 接口中的成员变量只能是 public static final 类型的，不能被修改且必须有初始值，而抽象类的成员变量默认 default，可在子类中被重新定义，也可被重新赋值。

十二、深拷贝和浅拷贝

• 浅拷贝：浅拷贝会在堆上创建一个新的对象（区别于引用拷贝的一点），不过，如果原对象内部的属性是引用类型的话，浅拷贝会直接复制内部对象的引用地址，也就是说拷贝对象和原对象共用同一个内部对象。
• 深拷贝 ：深拷贝会完全复制整个对象，包括这个对象所包含的内部对象。

十三、注解

• Annotation （注解） 是 Java5 开始引入的新特性，可以看作是一种特殊的注释，主要用于修饰类、方法或者变量，提供某些信息供程序在编译或者运行时使用。
• 注解本质是一个继承了Annotation 的特殊接口

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {

}

public interface Override extends Annotation{

}

十四、I/O

• 如果我们需要持久化 Java 对象比如将 Java 对象保存在文件中，或者在网络传输 Java 对象，这些场景都需要用到序列化。
• 序列化： 将数据结构或对象转换成二进制字节流的过程
• **反序列化：**将在序列化过程中所生成的二进制字节流转换成数据结构或者对象的过程
• 序列化的主要目的是通过网络传输对象或者说是将对象存储到文件系统、数据库、内存中

十五、Java IO 流

IO 即 Input/Output，输入和输出。数据输入到计算机内存的过程即输入，反之输出到外部存储（比如数据库，文件，远程主机）的过程即输出。数据传输过程类似于水流，因此称为 IO 流。IO 流在 Java 中分为输入流和输出流，而根据数据的处理方式又分为字节流和字符流。

Java IO 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的

• InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流
• OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流

为什么要区分字节和字符

• 字符流是由 Java 虚拟机将字节转换得到的，这个过程还算是比较耗时
• 果我们不知道编码类型的话，使用字节流的过程中很容易出现乱码问题。

十六、语法糖

• 语法糖（Syntactic sugar） 代指的是编程语言为了方便程序员开发程序而设计的一种特殊语法，这种语法对编程语言的功能并没有影响。实现相同的功能，基于语法糖写出来的代码往往更简单简洁且更易阅读。
• JVM 其实并不能识别语法糖，Java 语法糖要想被正确执行，需要先通过编译器进行解糖，也就是在程序编译阶段将其转换成 JVM 认识的基本语法。
• Java 中最常用的语法糖主要有泛型、自动拆装箱、变长参数、枚举、内部类、增强 for 循环、try-with-resources 语法、lambda 表达式等。

十七、Java值传递

Java 中将实参传递给方法（或函数）的方式是 值传递 ：

• 如果参数是基本类型的话，很简单，传递的就是基本类型的字面量值的拷贝，会创建副本。
• 如果参数是引用类型，传递的就是实参所引用的对象在堆中地址值的拷贝，同样也会创建副本。

十八、序列化场景

• 对象在进行网络传输（比如远程方法调用 RPC 的时候）之前需要先被序列化，接收到序列化的对象之后需要再进行反序列化；
• 将对象存储到文件中的时候需要进行序列化，将对象从文件中读取出来需要进行反序列化。
• 将对象存储到缓存数据库（如 Redis）时需要用到序列化，将对象从缓存数据库中读取出来需要反序列化。

十九、序列化在OSI中的实现

• OSI 七层协议模型中，表示层做的事情主要就是对应用层的用户数据进行处理转换为二进制流

二十、代理模式

• 使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。
• 代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。

二十一、静态代理

• 静态代理中，我们对目标对象的每个方法的增强都是手动完成的，非常不灵活且麻烦。 实际应用场景非常非常少。

• 从 JVM 层面来说， 静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。

静态代理实现步骤：

1. 定义一个接口及其实现类；
2. 创建一个代理类同样实现这个接口
3. 将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。

二十二、动态代理

22.1 简介

• 相比于静态代理来说，动态代理更加灵活。我们不需要针对每个目标类都单独创建一个代理类，并且也不需要我们必须实现接口，我们可以直接代理实现类( CGLIB 动态代理机制)。
• 从 JVM 角度来说，动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。
• Spring AOP、RPC 框架的实现都依赖了动态代理。

22.2 JDK动态代理机制

22.2.1 介绍

• 在 Java 动态代理机制中 InvocationHandler 接口和 Proxy 类是核心。
• Proxy 类中使用频率最高的方法是：newProxyInstance() ，这个方法主要用来生成一个代理对象。

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
    throws IllegalArgumentException
{
    ......
}

这个方法一共有 3 个参数：

• loader ：类加载器，用于加载代理对象。
• interfaces : 被代理类实现的一些接口；
• h : 实现了 InvocationHandler 接口的对象；

要实现动态代理的话，还必须需要实现InvocationHandler 来自定义处理逻辑。 当我们的动态代理对象调用一个方法时，这个方法的调用就会被转发到实现InvocationHandler 接口类的 invoke 方法来调用。

public interface InvocationHandler {
    /**
     * 当你使用代理对象调用方法的时候实际会调用到这个方法
     */
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

invoke() 方法有下面三个参数：

• proxy：动态生成的代理类
• method：与代理类对象调用的方法相对应
• args：当前 method 方法的参数

也就是说：你通过Proxy 类的 newProxyInstance() 创建的代理对象在调用方法的时候，实际会调用到实现InvocationHandler 接口的类的 invoke()方法。 你可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情。

22.2.2 JDK 动态代理类使用步骤

1. 定义一个接口及其实现类
2. 自定义 InvocationHandler 并重写invoke方法，在 invoke 方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑
3. 通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象

22.2.3 代码示例

1. 定义发送短信的接口

   public interface SmsService {
       String send(String message);
   }
   

2. 实现发送短信的接口

   public class SmsServiceImpl implements SmsService {
       public String send(String message) {
           System.out.println("send message:" + message);
           return message;
       }
   }
   

3. 定义一个JDK动态代理类

   import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.InvocationTargetException;
   import java.lang.reflect.Method;
   
   public class DebugInvocationHandler implements InvocationHandler {
       /**
        * 代理类中的真实对象
        */
       private final Object target;
   
       public DebugInvocationHandler(Object target) {
           this.target = target;
       }
   
       public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
           //调用方法之前，我们可以添加自己的操作
           System.out.println("before method " + method.getName());
           //调用方法
           Object result = method.invoke(target, args);
           //调用方法之后，我们同样可以添加自己的操作
           System.out.println("after method " + method.getName());
           return result;
       }
   }
   

   invoke() 方法: 当我们的动态代理对象调用原生方法的时候，最终实际上调用到的是 invoke() 方法，然后 invoke() 方法代替我们去调用了被代理对象的原生方法。

4. 获取代理对象的工厂类

   public class JdkProxyFactory {
       public static Object getProxy(Object target) {
           return Proxy.newProxyInstance(
                   target.getClass().getClassLoader(), // 目标类的类加载
                   target.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个
                   new DebugInvocationHandler(target)   // 代理对象对应的自定义 InvocationHandler
           );
       }
   }
   

   getProxy() ：主要通过Proxy.newProxyInstance（）方法获取某个类的代理对象

5. 实际使用

   SmsService smsService = (SmsService) JdkProxyFactory.getProxy(new SmsServiceImpl());
   smsService.send("java");
   

22.3 CGLIB动态代理机制

22.3.1 介绍

• JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。

• 为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。

• CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。很多知名的开源框架都使用到了CGLIB， 例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。

22.4 静态代理和动态代理的对比

• 灵活性 ：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。另外，静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的！
• JVM 层面 ：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。

二十三、Java语法糖

• switch 支持 String 与枚举
• 泛型
• 自动装箱与拆箱
• 可变长参数
• 枚举
• 内部类
• 条件编译
• 断言
• 数值字面量
• for-each
• try-with-resource
• Lambda 表达式