一文带你复习java--java基础知识篇

系列文章目录：

面试直击：一文带你复习java--jvm篇

一.Java语言具有哪些特点？

1. Java为纯面向对象的语言。它能够直接反应现实生活中的对象。

2. 具有平台无关性。java利用Java虚拟机运行字节码，无论是在Windows、Linux还是MacOS等其它 平台，只要安装了jdk就能对Java程序进行编译，编译后的程序可在其它平台运行。或者只要有jre就能运行编译后的java程序。

3. 具有很好的可移植性。因为Java为解释型语言，编译器把Java代码编译成平台无关的中间代码，然后在JVM上解释运行，不依赖其他环境。

4. 功能强大。Java提供了很多内置类库。如对多线程支持，对网络通信支持，最重要的一点是提供了垃圾回收器 ，保证了程序对资源的可持续利用。

5. Java具有较好的安全性和健壮性。Java提供了异常处理和垃圾回收机制，去除了C++中难以理解的 指针特性。

6. Java语言提供了对Web应用开发的支持,如基于java开发的web中间件 tomcat。

7.Java的生态环境十分完善，社区活跃度在所有开发语言里居高不下。

二.jdk,jre,jvm是什么？

1. jdk(Java Development Kit)：java语言的开发工具包(SDK)。包括了jre,java工具和基础类库

2. jre(Java Runtime Environment):java运行环境，包含jvm标准实现和java核心类库；因不是开发环境所以不包含编译器和调试器

3. jvm(java Virtual Machine ):java虚拟机；是一种计算设备的规范，它是虚拟构建出来的计算机。具有硬体架构，如处理器，堆栈，寄存器以及指令操作系统。特点：与平台无关性；使得java程序只需生成在java虚拟机运行的字节码，即可实现在多个平台运行。

4. JDK包含了JRE。如果只运行Java程序，安装JRE即可。要编写Java程序需安装JDK

三.java三大特性

1. 封装：将客观事物抽象成类，将类的信息隐藏在内部，不允许外部直接访问，而是通过该类提供的公有方法从而对其隐藏的信息进行操作和访问。一定程度上保证了数据的安全性。

2. 继承：指的是类与类之间的关系，派生类可以继承父类的public,protected所修饰的成员，包括方法和实例变量。当然如果是在同一包下还可以继承默认修饰符所修饰的成员。且派生类可以根据特殊需求，对父类方法进行重写或者新增本类方法。提高了代码的复用性，解决了一定代码冗余。并且java只支持单继承。

3. 多态：指的是在继承关系的前提下，对象的多种引用形态。即一个特定变量可以引用不同类型的对象，对同一消息做出响应，他们调用的方法方法名可能相同，参数列表相同，但是最终表现的行为是不一样的。多态提高了代码的扩展性和可维护性。

1. 形成条件:

1. 继承

2. 方法重写

3. 向上转型（子类到父类的转换）

4. 向下转型（父类到子类的转换）

四.java八大基本数据类型

a. 浮点型：float，double

b. 字符型：char

c. 整型：byte，short，int, long

d. Boolean 型：boolean

数据类型	字节数	位数
byte	1	8
short	2	16
int	4	32
long	8	64
float	4	32
double	8	64
boolean	1	8
char	2	16

五.字节序定义以及Java属于哪种字节序？

字节序是指多字节数据在计算机内存中存储或网络传输时个字节的存储顺序。通常由小端和大端两组方 式。 1. 小端:低位字节存放在内存的低地址端，高位字节存放在内存的高地址端。 2. 大端：高位字节存放在内存的低地址端，低位字节存放在内存的高地址端。 Java语言的字节序是大 端方式

大端序的优点：

1. 适合人类阅读：大端序排列方式更符合我们通用的从左往右、从高到低的阅读/写作习惯，因此在存储时便于人们直接观察和判断数值大小。

2. 便于比对与处理：大端序可以方便地使用字符串进行排序和比较，同时也能够更容易进行累加等操作，因为数字的高位是放在内存低地址处的。

小端序的优点：

3. 易于扩展：小端序依赖的最低字节的下标始终相同，这使得在增加字长时只需要向高地址空间添加数据即可，不会影响已存在的低位内容。而在大端序中，增加长度需要向低地址添加新数据。

4. 对大多数算法有利：大多数加密、压缩、校验等操作通常从低位开始进行操作，而小端序能够连续的取出低位字节，因此在执行这些操作时小端序更容易产生解决方案。

综上所述，大端序更加人性化、稳定，而小端序则更加灵活和简便。不过在实际应用中，选择哪种字节序主要由硬件和软件的设计者决定，在保持兼容性的同时，更加重视优化性能。

六.构造方法、成员变量初始化以及静态成员变量三者的初始 化顺序？

先后顺序：静态成员变量、成员变量、构造方法。 详细的先后顺序：父类静态变量、父类静态代码块、子类静态变量、子类静态代码块、父类非静态变 量、父类非静态代码块、父类构造函数、子类非静态变量、子类非静态代码块、子类构造函数。

七.接口和抽象类的相同点和区别？

相同点: 1. 都不能被实例化。 2. 接口的实现类或抽象类的子类需实现接口或抽象类中相应的方法才能被实例化。 不同点： 1. 接口只能有方法定义，不能有方法的实现，而抽象类可以有方法的定义与实现。 2. 实现接口的关键字为implements,继承抽象类的关键字为extends。一个类可以实现多个接口，只能 继承一个抽象类。

3.构造函数：抽象类可以有构造函数；接口不能有。

4.main 方法：抽象类可以有 main 方法，并且我们能运行它；接口不能有main 方法。

5.访问修饰符：接口中的方法默认使用 public 修饰；抽象类中的方法可以是任意访问修饰符 6. 使用场景不同：当子类和父类之间存在逻辑上的层次结构，推荐使用抽象类，有利于功能的累积。当功能不需要， 希望支持差别较大的两个或更多对象间的特定交互行为，推荐使用接口。使用接口能降低软件系统 的耦合度，便于日后维护或添加删除方法。

八.为什么Java语言不支持多重继承？

1. 为了程序的结构能够更加清晰从而便于维护。假设Java语言支持多重继承，类C继承自类A和类B, 如果类A和B都有自定义的成员方法f(),那么当代码中调用类C的f()会产生二义性。Java语言通过实现 多个接口间接支持多重继承，接口由于只包含方法定义，不能有方法的实现，类C继承接口A与接 口B时即使它们都有方法f(),也不能直接调用方法，需实现具体的f()方法才能调用，不会产生二义 性。 2. 多重继承会使类型转换、构造方法的调用顺序变得复杂，会影响到性能。

九.重载与覆盖的区别？

1. 覆盖是父类与子类之间的关系，是垂直关系；重载是同一类中方法之间的关系，是水平关系。 2. 覆盖只能由一个方法或一对方法产生关系；重载是多个方法之间的关系。 3.方法重载：在同一个类中，多个方法名相同，但是参数列表不同（顺序，个数，类型）

4.方法重写：实现类所覆盖被实现类的方法，要求方法名相同，参数列表相同，返回类型相同，访问级别不能低于父类方法的访问级别，子类抛出异常级别不能超过父类的抛出异常级别

十.hashcode 与 equal，以及“==”的区别

1.“==”是运算符

• 运用于基本数据类型，比较的是它门的值

• 运用于引用类型，比较的是它们所指向对象的地址值

2.equals 方法比较的是它们所指向对象的地址值；不能用于比较基本数据类型；

一般情况下，类会重 写equals方法用来比较两个对象的内容是否相等。比如String类中的equals()是被重写了，比较的是对象的值。

String、Integer、Date这些类库中equals被重写

3.hashCode（）：返回的是对象的地址值，通过地址值来映射。

• equal()相等的两个对象他们的 hashCode()肯定相等，

• hashCode()相等的两个对象他们的 equal()不一定相等，

• 所有对于需要大量并且快速的对比的话如果都用 equal()去做显然效率太低，所以解决方式是，每当需要对比 的时候，首先用 hashCode()去对比，如果 hashCode()不一样，则表示这两个对象肯定不相等（也就是不必再用 equal()去再对比了）,如果 hashCode()相同，此时再对比他们的 equal()，如果 equal()也相同，则表示这两个对 象是真的相同了，这样既能大大提高了效率也保证了对比的绝对正确性

十一.final、finally和finalize的区别是什么？

1. final java内置关键字，用于定义属性，方法，类，分别表示属性不可变，方法不可重写，类不能继承。

2. finally 属于java异常处理的末尾部分，通常与try/catch语句块联合使用，一般用于关闭各种连接和释放资源。

1. Finally 一定会被执行吗？ 至少有两种情况下 finally 语句是不会被执行的： （1）try 语句没有被执行到，如在 try 语句之前就返回了，这样 finally 语句就不会执行，这也说 明了 finally 语句被执行的必要而非充分条件是：相应的 try 语句一定被执行到。 （2）在 try 块中有 System.exit(0);这样的语句，System.exit(0);是终止 Java 虚拟机 JVM 的， 连JVM 都停 止了，所有都结束了，当然 finally 语句也不会被执行到 2.finally 语句是在 try 的 return 之前执行还是之后执行？ finally 块语句在 try 或 catch 中 return 语句执行之后返回之前执行且 finally 里的修改语句不能 影响 try 或 catch 中 return 已经确定的返回值，若 finally 里有 return 语句则覆盖 try 或 catch 中的 return 语句直接返 回

c. finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的finalize()方法。

注意：finalize 方法是在垃圾收集器删除对象之前对这个对象调用的。其目的是将对象从内存中清楚出去之前做必要的清理工作。

当垃 圾回收器准备好释放对象占用空间时，首先会调用finalize()方法，并在下一次垃圾回收动作发生时 真正回收对象占用的内存。

十二.Java语言中关键字static的作用是什么？

主要有二个作用：

1. 为某种特点类型或对象分配与创建实例个数无关的单一内存存储空间

具体：被static所修饰的成员或类在JVM中的位置是在方法区（Method Area）或静态存储区（Static Storage Area），即非堆内存中。JVM会为每个类在方法区中创建一个运行时常量池，其中含有类的所有常量、静态变量和静态代码块等信息。当虚拟机加载类的过程中，这些静态成员会被初始化并存储在静态存储区，在整个程序的运行期间只会被分配一次内存。因此，如果多个对象共享一个静态变量，它们都会指向同一个内存地址。

2. 将方法或属性不依附于实例，而是直接与类关联，即通过类名可以直接调用被static定义的方法或属性。

1. 具体作用4个

1. 修饰成员变量。用static关键字修饰的静态变量在内存中只有一个副本。只要静态变量所在的类被加 载，这个静态变量就会被分配空间，可以使用''类.静态变量''和''对象.静态变量''的方法使用。

2. 修饰成员方法。static修饰的方法无需创建对象就可以被调用。static方法中不能使用this和super关 键字，不能调用非static方法，只能访问所属类的静态成员变量和静态成员方法。

3. 修饰代码块。JVM在加载类的时候会执行static代码块。static代码块只会被执行一次,同样与创建实例次数无关，static代码块常用于初始化静态变量。常用于程序调优。

4. 修饰内部类。static内部类可以不依赖外部类实例对象而被实例化。静态内部类不能与外部类有相同 的名字，不能访问普通成员变量，只能访问外部类中的静态成员和静态成员方法。

静态内部作用于实现单例设计模式。

单利模式的特点是该类只能有一个实例，为了实现这一功能，必须隐藏类的构造函数，即把构造函数声明为private,在静态内部类进行外部类的实例化

public class Singleton{
    private static Singleton instance=null;
    private Singleton(){}
    public static Singleton getInstance(){
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

十三.String StringBuilder StringBuffer 的区别

• String是字符串常量，string对象一旦创建不可更改；如果要修改，会重新开辟内存空间来存储修改之后的对象；而StringBuffer和StringBuilder对象的值是可以被修改的；

• String是被final修饰的类，不能被继承；

• String实现了Serializable和Comparable接口，表示String支持序列化和可以比较大小；

• String底层是通过char类型的数据实现的，并且被final修饰，所以字符串的值创建之后就不可以被修改，具有不可变性

• 为什么要把String设计为不变量？

1. 节省空间：字符串常量存储在JVM的字符串池中可以被用户共享。 2. 提高效率:String会被不同线程共享，是线程安全的。在涉及多线程操作中不需要同步操作。 3. 安全考虑：String常被用于用户名、密码、文件名等使用，由于其不可变，可避免黑客行为对其恶意修 改。

• StringBuilder是字符串变量，非线程安全

• StringBuffer是字符串变量，线程安全

• StringBuffer、StringBuilder和String类似，底层也是用一个数组来存储字符串的值，并且数组的默认长度为16，即一个空的StringBuffer对象数组长度为16。实例化一个StringBuffer对象即创建了一个大小为16个字符的字符串缓冲区。但是当我们调用有参构造函数创建一个StringBuffer对象时，数组长度就不再是16了，而是根据当前对象的值来决定数组的长度，数组的长度为“当前对象的值的长+16”。所以一个 StringBuffer 创建完成之后，有16个字符的空间可以对其值进行修改。如果修改的值范围超出了16个字符，会先检查StringBuffer对象的原char数组的容量能不能装下新的字符串，如果装不下则会对 char 数组进行扩容。

• 扩容机制

• 扩容的逻辑就是创建一个新的 char 数组，将现有容量扩大一倍再加上2，如果还是不够大则直接等于需要的容量大小。扩容完成之后，将原数组的内容复制到新数组，最后将指针指向新的 char 数组。

十四.Java反射机制是什么？

Java反射机制是指在程序的运行过程中可以构造任意一个类的对象、获取任意一个类的成员变量和成员 方法、获取任意一个对象所属的类信息、调用任意一个对象的属性和方法。反射机制使得Java具有动态 获取程序信息和动态调用对象方法的能力。可以通过以下类调用反射AP

Class类：可获得类属性方法 Field类：获得类的成员变量 Method类：获取类的方法信息 Construct类：获取类的构造方法等信息

十五.java注解以及元注解

1.注解：

Java 注解用于为 Java 代码提供元数据。作为元数据，注解不直接影响你的代码执行，但也有一些类型 的注解实际上可以用于这一目的。 其可以用于提供信息给编译器，在编译阶段时给软件提供信息进行相关的处理，在运行时处理写相应代 码，做对应操作。

2.元注解

可以理解为注解的注解，即在注解中使用，实现想要的功能。其具体分为： @Retention: 表示注解存在阶段是保留在源码，还是在字节码（类加载）或者运行期（JVM中运 行）。 @Target：表示注解作用的范围。 @Documented：将注解中的元素包含到 Javadoc 中去。 @Inherited /ɪnˈherɪtɪd/：一个被@Inherited注解了的注解修饰了一个父类，如果他的子类没有被其他注解修饰，则它的子类也继承了父类的注解。 @Repeatable/ rɪˈpiːtəbl/：被这个元注解修饰的注解可以同时作用一个对象多次，但是每次作用注解又可以代 表不同的含义。

十六.简述Java异常的分类

Java异常分为Error（程序无法处理的错误），和Exception（程序本身可以处理的异常）。这两个类均 继承Throwable。 Error常见的有StackOverFlowError,OutOfMemoryError等等。 表示由JVM所侦测到的无法预期的错误，由于这是属于JVM层次的严重错误，导致JVM无法继续执行 Exception可分为运行时异常和非运行时异常。对于运行时异常，可以利用try catch的方式进行处理，也 可以不处理。对于非运行时异常，必须处理，不处理的话程序无法通过编译 ,如IOException，SQLException等以及用户自定义的Exception异常

运行期异常有：

NullPointerException - 空指针引用异常 ClassCastException - 类型强制转换异常。 IllegalArgumentException - 传递非法参数异常。 ArithmeticException - 算术运算异常 IndexOutOfBoundsException - 下标越界异常 NumberFormatException - 数字格式异常

十七.简述throw与throws的区别

throw一般是用在方法体的内部，由开发者定义当程序语句出现问题后主动抛出一个异常。 throws一般用于方法声明上，代表该方法可能会抛出的异常列表。

十八.泛型以及泛型擦除

1.泛型，即“参数化类型”，解决不确定对象具体类型的问题。在编译阶段有效。在泛型使用过程中，操作 的数据类型被指定为一个参数，这种参数类型在类中称为泛型类、接口中称为泛型接口和方法中称为泛型方法

2.泛型擦除：Java编译器生成的字节码是不包涵泛型信息的，泛型类型信息将在编译处理是被擦除，这个过程被称为 泛型擦除

十九.简述Java序列化与反序列化的实现

序列化：将java对象转化为字节序列，由此可以通过网络对象进行传输。 反序列化：将字节序列转化为java对象。 具体实现：实现Serializable接口，或实现Externalizable接口中的writeExternal()与readExternal()方法。

二十.什么是单例模式？有几种？

单例模式：某个类的实例在 多线程环境下只会被创建一次出来。

单例模式有饿汉式单例模式、懒汉式单例模式和双检锁单例模式三种。

饿汉式：在类初始化时自行实例化，因此类加载速度相对懒汉模式较慢，不过第一次获取实 例的速度很快，不存在线程问题,线程安全.

懒汉式：在类加载时不创建其实例，而是被调用时再创建实例；非线程安全，延迟初始化。

双检锁：线程安全，延迟初始化。

二十一：BIO、NIO、AIO 有什么区别

1.BIO：

BlockIO 同步阻塞式 IO，就是我们平常使用的传统 IO，它的特点是模式简单使用方便，并发处理能力低。

同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善

2.NIO：

NewIO 同步非阻塞 IO，是传统 IO 的升级，客户端和服务器端通过 Channel（通道）通讯，实现了多路复用。

同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。

3.AIO：

AsynchronousIO 是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操作基于事件和回调机制。

异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。

二十二.手写冒泡排序

     int[] arr=new int[]{4,1,8,5,9,10,8,7,9,6};
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+",");//1,4,5,6,7,8,8,9,9,10,
        }

二十三.jdk1.8新特性

1 Lambda 表达式 ：Lambda 允许把函数作为一个方法的参数。

 new Thread(()->{
            System.out.println("你好，我是无欢以承");
        }).start();

又如简化字符串数组排序

List<String> list = Arrays.asList("apple", "orange", "banana");
Collections.sort(list, (s1, s2) -> s1.compareToIgnoreCase(s2));

2 方法引用 ：方法引用允许直接引用已有 Java 类或对象的方法或构造方法。

 List list=new ArrayList();
        list.add("aa");
        list.add("bb");
        list.add("cc");
    list.forEach(System.out::println);

3.接口中的默认方法：Java 1.8中允许接口中定义默认方法，这些方法可以在不破坏现有代码的情况下向接口添加新功能。例如：

public interface MyInterface {
    default void myDefaultMethod() {
        System.out.println("你好，这是一个接口中的默认方法");
    }
}

4 函数式接口 ：有且仅有一个抽象方法的接口叫做函数式接口，函数式接口可以被隐式转换为Lambda 表达式。通常函数式接口 上会添加@FunctionalInterface注解。

@FunctionalInterface
interface GreetingService 
{
    void sayMessage(String message);
}

GreetingService greetService1 = message -> System.out.println("Hello " + message);

此外jdk1.8新增的java.util.function包下提供丰富多样的函数式接口，以供使用，这里引用了了年芳单八兄的这篇jdk1.8新特性大全，详见菜鸟教程：Java 8 函数式接口 | 菜鸟教程 (runoob.com)

Consumer 《T》：消费型接口，有参无返回值

    @Test
    public void test(){
        changeStr("hello",(str) -> System.out.println(str));
    }

    /**
     *  Consumer<T> 消费型接口
     * @param str
     * @param con
     */
    public void changeStr(String str, Consumer<String> con){
        con.accept(str);
    }

Supplier 《T》：供给型接口，无参有返回值

    @Test
    public void test2(){
        String value = getValue(() -> "hello");
        System.out.println(value);
    }

    /**
     *  Supplier<T> 供给型接口
     * @param sup
     * @return
     */
    public String getValue(Supplier<String> sup){
        return sup.get();
    }

• Function 《T,R》：:函数式接口，有参有返回值

    @Test
    public void test3(){
        Long result = changeNum(100L, (x) -> x + 200L);
        System.out.println(result);
    }

    /**
     *  Function<T,R> 函数式接口
     * @param num
     * @param fun
     * @return
     */
    public Long changeNum(Long num, Function<Long, Long> fun){
        return fun.apply(num);
    }

• Predicate《T》： 断言型接口，有参有返回值，返回值是boolean类型

    @Test
     void test4(){
        boolean result = changeBoolean("hello", (str) -> str.length() > 5);
        System.out.println(result);
    }

    /**
     *  Predicate<T> 断言型接口
     * @param str
     * @param pre
     * @return
     */
    public boolean changeBoolean(String str, Predicate<String> pre){
        return pre.test(str);
    }

5 Stream API :新添加的 Stream API（java.util.stream）把真正的函数式编程风格引入到 Java 中。这种风格将要处理的元素集 合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等.

       List<String> list= Arrays.asList("abc","",null,"abc","efg","abcdf","dsf");
       list.stream().filter(string->string!=null&&!string.isEmpty())//过滤空字符串
               .distinct()//去重
               .sorted()//排序
               .forEach(System.out::print);//abc  abcdf dsf efg

6 日期/时间类改进 ：之前的 JDK 自带的日期处理类非常不方便，我们处理的时候经常是使用的第三方工具包，比如 commons-lang 包等。不过 JDK8 出现之后这个改观了很多，比如日期时间的创建、比较、调整、格式化、时间间隔等

这些类都在 java.time 包下，LocalDate/LocalTime/LocalDateTime

7 Optional 类 ：Optional 类是一个可以为 null 的容器对象。如果值存在则 isPresent()方法会返回 true，调用 get()方法会返回该对象。

        String string="你好";
        Optional<String> optional=Optional.of(string);
        boolean present = optional.isPresent();
        String value=optional.get();
        System.out.println(present+"\t"+value);//true    你好

8 Java8 Base64 实现 ：Java 8 内置了 Base64 编码的编码器和解码器。