基础之java知识

ゞ浴缸里的玫瑰 2023-06-01 12:50 51阅读 0赞

### 1.面向对象和面向过程的区别 ###

*  **面向过程** ：**面向过程性能比面向对象高。** 因为类调用时需要实例化，开销比较大，比较消耗资源，所以当性能是最重要的考量因素的时候，比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发。但是，**面向过程没有面向对象易维护、易复用、易扩展。**
 *  **面向对象** ：**面向对象易维护、易复用、易扩展。** 因为面向对象有封装、继承、多态性的特性，所以可以设计出低耦合的系统，使系统更加灵活、更加易于维护。但是，**面向对象性能比面向过程低**。

### 2.java语言有哪些特点 ###

面向对象（封装，基础，多态），平台无关性（java虚拟机实现平台无关性），可靠性，安全性等

### 3.java和c++的区别 ###

*  都是面向对象的语言，都支持封装、继承和多态
 *  Java 不提供指针来直接访问内存，程序内存更加安全
 *  Java 的类是单继承的，C++ 支持多重继承；虽然 Java 的类不可以多继承，但是接口可以多继承。
 *  Java 有自动内存管理机制，不需要程序员手动释放无用内存

### 4.字符型常量和字符串常量的区别 ###

1.  形式上: 字符常量是单引号引起的一个字符; 字符串常量是双引号引起的若干个字符
2.  含义上: 字符常量相当于一个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置)
3.  占内存大小 字符常量只占2个字节; 字符串常量占若干个字节(至少一个字符结束标志) (**注意： char在Java中占两个字节**)

### 5.重载和重写的区别 ###

*  **重载：** 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。 　　
 *  **重写：** 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为 private 则子类就不能重写该方法。

### 6.封装 继承 多态 ###

封装：封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法。

继承：继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能。

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

多态：程序中定义的引用变量所指向的具体类型和发出的方法调用在编程时并不确定，而是在程序运行期间才确定。

> 继承（多个子类对同一方法的重写）和接口（实现接口并覆盖接口中同一方法）都可以实现多态

### 7.String StringBuffer StringBuilder的区别 ###

**可变性**：  
String类中使用final关键字修饰字符数组来保存字符串，private　final　char　value\[\]，是不可变的；  
StringBuilder与StringBuffer都继承AbstractBuilder类，也是使用字符数组保存字符串，但没有用final修饰，所以都是可变的。

AbstractStringBuilder.java

abstract class AbstractStringBuilder implements Appendable, CharSequence {
        char[] value;
        int count;
        AbstractStringBuilder() {
        }
        AbstractStringBuilder(int capacity) {
            value = new char[capacity];
        }
    }

**线程安全性**：

String对象是不可变的，线程安全；  
AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些公共方法。StringBuffer对方法加了同步锁，线程安全；StringBuilder没有对方法进行加同步锁，非线程安全。

**性能**：

每次对String类型进行改变时，都会生成一个新的String对象，然后将指针指向新的String对象；  
StringBuffer每次都会对StringBuffer对象本身进行操作，而不是生成新的对象并改变对象引用；  
StringBuilder比使用StringBuffer性能块一点，但多线程不安全。

**总结**：

1.  操作少量的数据: 适用String
2.  单线程操作字符串缓冲区下操作大量数据: 适用StringBuilder
3.  多线程操作字符串缓冲区下操作大量数据: 适用StringBuffer

### 8.接口和抽象类的区别 ###

1.  接口的方法默认是 public，所有方法在接口中不能有实现(Java 8 开始接口方法可以有默认实现），而抽象类可以有非抽象的方法。
2.  接口中除了static、final变量，不能有其他变量，而抽象类中则不一定。
3.  一个类可以实现多个接口，但只能继承一个抽象类。接口可以extends多个接口。
4.  接口方法默认修饰符是public，抽象方法可以有public、protected和default这些修饰符（抽象方法就是为了被重写所以不能使用private关键字修饰！）。
5.  从设计层面来说，抽象是对类的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为的规范。

备注：在JDK8中，接口也可以定义静态方法，可以直接用接口名调用。实现类和实现是不可以调用的。如果同时实现两个接口，接口中定义了一样的默认方法，则必须重写，不然会报错。

### 9.成员变量和局部变量的区别 ###

1.  从语法形式上看:成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。
2.  从变量在内存中的存储方式来看:如果成员变量是使用`static`修饰的，那么这个成员变量是属于类的，如果没有使用`static`修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
3.  从变量在内存中的生存时间上看:成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。
4.  成员变量如果没有被赋初值:则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。

### 10.==与equals ###

**==** : 判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象(基本数据类型比较的是值，引用数据类型比较的是内存地址)。

**equals()** : 判断两个对象是否相等。但它一般有两种使用情况：

*  情况1：类没有覆盖 equals() 方法。则比较的是内存地址；
 *  情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来比较两个对象的内容是否相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。

**说明：**

*  String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是比较的对象的内存地址，而 String 的 equals 方法比较的是对象的值。
 *  当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。

参考：[equals和==的区别小结][equals]

### 11.hashCode与equals ###

**hashCode（）介绍：**

hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。

散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）

**为什么要有 hashCode：**

**我们先以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：** 当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 `equals（）`方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。

**hashCode（）与equals（）的相关规定：**

1.  如果两个对象相等，则hashcode一定也是相同的
2.  两个对象相等,对两个对象分别调用equals方法都返回true
3.  两个对象有相同的hashcode值，它们也不一定是相等的
4.  **因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖**
5.  hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

**为什么两个对象有相同的hashcode值，它们也不一定是相等的：**

因为hashCode() 所使用的杂凑算法也许刚好会让多个对象传回相同的杂凑值。越糟糕的杂凑算法越容易碰撞，但这也与数据值域分布的特性有关（所谓碰撞也就是指的是不同的对象得到相同的 hashCode）。

我们刚刚也提到了 HashSet,如果 HashSet 在对比的时候，同样的 hashcode 有多个对象，它会使用 equals() 来判断是否真的相同。也就是说 hashcode 只是用来缩小查找成本。

推荐阅读：[Java hashCode() 和 equals()的若干问题解答][Java hashCode_ _ equals]

### 12.java中为什么只有值传递 ###

Java程序设计语言总是采用按值调用。也就是说，方法得到的是所有参数值的一个拷贝，也就是说，方法不能修改传递给它的任何参数变量的内容。  
**Java中方法参数的使用情况**：  
一个方法不能修改一个基本数据类型的参数（即数值型或布尔型）。(参数值的拷贝)  
一个方法可以改变一个对象参数的状态。（对象引用的拷贝）  
一个方法不能让对象参数引用一个新的对象。

参考：[JAVA中值传递和引用传递的三种情况][JAVA]

### 13.线程 程序 进程 ###

**线程**与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

**程序**是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。

**进程**是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。  
线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。

### 14.线程有哪些基本状态 ###

Java 线程在运行的生命周期中的指定时刻只可能处于下面6种不同状态的其中一个状态

![Java线程的状态][Java]

线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换

![Java线程状态变迁][Java 1]

由上图可以看出：

线程创建之后它将处于 **NEW（新建）** 状态，调用 `start()` 方法后开始运行，线程这时候处于 **READY（可运行）** 状态。可运行状态的线程获得了 cpu 时间片（timeslice）后就处于 **RUNNING（运行）** 状态。

当线程执行 `wait()`方法之后，线程进入 **WAITING（等待）**状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而 **TIME\_WAITING(超时等待)** 状态相当于在等待状态的基础上增加了超时限制，比如通过 `sleep（long millis）`方法或 `wait（long millis）`方法可以将 Java 线程置于 TIMED WAITING 状态。当超时时间到达后 Java 线程将会返回到 RUNNABLE 状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到 **BLOCKED（阻塞）** 状态。线程在执行 Runnable 的`run()`方法之后将会进入到 **TERMINATED（终止）** 状态。

### 14.final关键字总结 ###

final关键字主要用在三个地方：变量、方法、类。

1.  对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
2.  当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。
3.  使用final修饰方法，把方法锁定，以防任何继承类修改它的含义。类中所有的private方法都隐式地指定为final。

### 15.异常处理 ###

**Java异常类层次结构图**

![Java异常类层次结构图][Java 2]

在 Java 中，所有的异常都有一个共同的祖先java.lang包中的 **Throwable类**。Throwable： 有两个重要的子类：**Exception（异常）** 和 **Error（错误）** ，二者都是 Java 异常处理的重要子类，各自都包含大量子类。

**Error（错误）:是程序无法处理的错误**，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。

**Exception（异常）:是程序本身可以处理的异常**。Exception 类有一个重要的子类 **RuntimeException**。RuntimeException 异常由Java虚拟机抛出。**NullPointerException**（要访问的变量没有引用任何对象时，抛出该异常）、**ArithmeticException**（算术运算异常，一个整数除以0时，抛出该异常）和 **ArrayIndexOutOfBoundsException** （下标越界异常）。

**注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。**

**Throwable类常用方法**：

*  **public string getMessage()**:返回异常发生时的详细信息
 *  **public string toString()**:返回异常发生时的简要描述
 *  **public string getLocalizedMessage()**:返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
 *  **public void printStackTrace()**:在控制台上打印Throwable对象封装的异常信息

**异常处理总结**：

*  **try 块：**用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
 *  **catch 块：**用于处理try捕获到的异常。
 *  **finally 块：**无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。

**注意：** 当try语句和finally语句中都有return语句时，在方法返回之前，finally语句的内容将被执行，并且finally语句的返回值将会覆盖原始的返回值。

**在以下4种特殊情况下，finally块不会被执行：**

1.  在finally语句块第一行发生了异常。 因为在其他行，finally块还是会得到执行
2.  在前面的代码中用了System.exit(int)已退出程序。 exit是带参函数 ；若该语句在异常语句之后，finally会执行
3.  程序所在的线程死亡。
4.  关闭CPU。

### 16.获取键盘输入的方法 ###

方法1：通过 Scanner

Scanner input = new Scanner(System.in);
    String s  = input.nextLine();
    input.close();

方法2：通过 BufferedReader

BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); 
    String s = input.readLine();

### 17.IO流分类及BIO,NIO,AIO区别 ###

**java 中 IO 流分为几种?**

*  按照流的流向分，可以分为输入流和输出流；
 *  按照操作单元划分，可以划分为字节流和字符流；
 *  按照流的角色划分为节点流和处理流。

Java Io流共涉及40多个类，这些类看上去很杂乱，但实际上很有规则，而且彼此之间存在非常紧密的联系， Java I0流的40多个类都是从如下4个抽象类基类中派生出来的。

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

按操作方式分类结构图：

![IO-操作方式分类][IO-]

按操作对象分类结构图：

![IO-操作对象分类][IO- 1]

**BIO,NIO,AIO 有什么区别?**

*  **BIO (Blocking I/O):** 同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的 I/O 并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。因此，我们需要一种更高效的 I/O 处理模型来应对更高的并发量。
 *  **NIO (New I/O):** NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了NIO框架，对应 java.nio 包，提供了 Channel , Selector，Buffer等抽象。NIO中的N可以理解为Non-blocking，不单纯是New。它支持面向缓冲的，基于通道的I/O操作方法。 NIO提供了与传统BIO模型中的 `Socket` 和 `ServerSocket` 相对应的 `SocketChannel` 和 `ServerSocketChannel` 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞I/O来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞模式来开发
 *  **AIO (Asynchronous I/O):** AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。AIO 是异步IO的缩写，虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是同步的。对于 NIO 来说，我们的业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程自行进行 IO 操作，IO操作本身是同步的。查阅网上相关资料，我发现就目前来说 AIO 的应用还不是很广泛，Netty 之前也尝试使用过 AIO，不过又放弃了。

转载于:https://www.cnblogs.com/itzlg/p/11374831.html

[equals]: https://www.cnblogs.com/Eason-S/p/5524837.html
[Java hashCode_ _ equals]: https://www.cnblogs.com/skywang12345/p/3324958.html
[JAVA]: https://blog.csdn.net/zhzhao999/article/details/53449504
[Java]: /images/20230601/04c1eb042aaf4a35a19081b1713c5e5e.png
[Java 1]: /images/20230601/6da1cfc816384e50a5a6e7bb0d21bd2c.png
[Java 2]: /images/20230601/109852a5a42f49ff8236bf56c6a87a80.png
[IO-]: /images/20230601/1d0ce4c8d0e3442fbe1d3eb5c78d5743.png
[IO- 1]: /images/20230601/12ceac97aec34d70ba5013157f5779c3.png