mirror of
https://github.com/Snailclimb/JavaGuide
synced 2025-06-16 18:10:13 +08:00
336 lines
17 KiB
Markdown
336 lines
17 KiB
Markdown
---
|
||
title: Java基础知识&面试题总结(中)
|
||
category: Java
|
||
tag:
|
||
- Java基础
|
||
---
|
||
|
||
## 面向对象基础
|
||
|
||
### 面向对象和面向过程的区别
|
||
|
||
两者的主要区别在于解决问题的方式不同：
|
||
|
||
- 面向过程把解决问题的过程拆成一个个方法，通过一个个方法的执行解决问题。
|
||
- 面向对象会先抽象出对象，然后用对象执行方法的方式解决问题。
|
||
|
||
另外，面向对象开发的程序一般更易维护、易复用、易扩展。
|
||
|
||
相关 issue : [面向过程 ：面向过程性能比面向对象高？？](https://github.com/Snailclimb/JavaGuide/issues/431)
|
||
|
||
### 成员变量与局部变量的区别有哪些？
|
||
|
||
- **语法形式** ：从语法形式上看，成员变量是属于类的，而局部变量是在代码块或方法中定义的变量或是方法的参数；成员变量可以被 `public`,`private`,`static` 等修饰符所修饰，而局部变量不能被访问控制修饰符及 `static` 所修饰；但是，成员变量和局部变量都能被 `final` 所修饰。
|
||
- **存储方式** ：从变量在内存中的存储方式来看,如果成员变量是使用 `static` 修饰的，那么这个成员变量是属于类的，如果没有使用 `static` 修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
|
||
- **生存时间** ：从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。
|
||
- **默认值** ：从变量是否有默认值来看，成员变量如果没有被赋初，则会自动以类型的默认值而赋值（一种情况例外:被 `final` 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。
|
||
|
||
### 创建一个对象用什么运算符?对象实体与对象引用有何不同?
|
||
|
||
new 运算符，new 创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。
|
||
|
||
一个对象引用可以指向 0 个或 1 个对象（一根绳子可以不系气球，也可以系一个气球）;一个对象可以有 n 个引用指向它（可以用 n 条绳子系住一个气球）。
|
||
|
||
### 对象的相等与指向他们的引用相等,两者有什么不同?
|
||
|
||
- 对象的相等一般比较的是内存中存放的内容是否相等。
|
||
- 引用相等一般比较的是他们指向的内存地址是否相等。
|
||
|
||
### 一个类的构造方法的作用是什么? 若一个类没有声明构造方法，该程序能正确执行吗?
|
||
|
||
构造方法主要作用是完成对类对象的初始化工作。
|
||
|
||
如果一个类没有声明构造方法，也可以执行！因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。如果我们自己添加了类的构造方法（无论是否有参），Java 就不会再添加默认的无参数的构造方法了，这时候，就不能直接 new 一个对象而不传递参数了，所以我们一直在不知不觉地使用构造方法，这也是为什么我们在创建对象的时候后面要加一个括号（因为要调用无参的构造方法）。如果我们重载了有参的构造方法，记得都要把无参的构造方法也写出来（无论是否用到），因为这可以帮助我们在创建对象的时候少踩坑。
|
||
|
||
### 构造方法有哪些特点？是否可被 override?
|
||
|
||
构造方法特点如下：
|
||
|
||
- 名字与类名相同。
|
||
- 没有返回值，但不能用 void 声明构造函数。
|
||
- 生成类的对象时自动执行，无需调用。
|
||
|
||
构造方法不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况。
|
||
|
||
### 面向对象三大特征
|
||
|
||
#### 封装
|
||
|
||
封装是指把一个对象的状态信息（也就是属性）隐藏在对象内部，不允许外部对象直接访问对象的内部信息。但是可以提供一些可以被外界访问的方法来操作属性。就好像我们看不到挂在墙上的空调的内部的零件信息（也就是属性），但是可以通过遥控器（方法）来控制空调。如果属性不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。就好像如果没有空调遥控器，那么我们就无法操控空凋制冷，空调本身就没有意义了（当然现在还有很多其他方法 ，这里只是为了举例子）。
|
||
|
||
```java
|
||
public class Student {
|
||
private int id;//id属性私有化
|
||
private String name;//name属性私有化
|
||
|
||
//获取id的方法
|
||
public int getId() {
|
||
return id;
|
||
}
|
||
|
||
//设置id的方法
|
||
public void setId(int id) {
|
||
this.id = id;
|
||
}
|
||
|
||
//获取name的方法
|
||
public String getName() {
|
||
return name;
|
||
}
|
||
|
||
//设置name的方法
|
||
public void setName(String name) {
|
||
this.name = name;
|
||
}
|
||
}
|
||
```
|
||
|
||
#### 继承
|
||
|
||
不同类型的对象，相互之间经常有一定数量的共同点。例如，小明同学、小红同学、小李同学，都共享学生的特性（班级、学号等）。同时，每一个对象还定义了额外的特性使得他们与众不同。例如小明的数学比较好，小红的性格惹人喜爱；小李的力气比较大。继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承，可以快速地创建新的类，可以提高代码的重用，程序的可维护性，节省大量创建新类的时间 ，提高我们的开发效率。
|
||
|
||
**关于继承如下 3 点请记住：**
|
||
|
||
1. 子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，**只是拥有**。
|
||
2. 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
|
||
3. 子类可以用自己的方式实现父类的方法。（以后介绍）。
|
||
|
||
#### 多态
|
||
|
||
多态，顾名思义，表示一个对象具有多种的状态，具体表现为父类的引用指向子类的实例。
|
||
|
||
**多态的特点:**
|
||
|
||
- 对象类型和引用类型之间具有继承（类）/实现（接口）的关系；
|
||
- 引用类型变量发出的方法调用的到底是哪个类中的方法，必须在程序运行期间才能确定；
|
||
- 多态不能调用“只在子类存在但在父类不存在”的方法；
|
||
- 如果子类重写了父类的方法，真正执行的是子类覆盖的方法，如果子类没有覆盖父类的方法，执行的是父类的方法。
|
||
|
||
### 深拷贝和浅拷贝区别了解吗？什么是引用拷贝？
|
||
|
||
关于深拷贝和浅拷贝区别，我这里先给结论：
|
||
|
||
- **浅拷贝**：浅拷贝会在堆上创建一个新的对象（区别于引用拷贝的一点），不过，如果原对象内部的属性是引用类型的话，浅拷贝会直接复制内部对象的引用地址，也就是说拷贝对象和原对象共用同一个内部对象。
|
||
- **深拷贝** ：深拷贝会完全复制整个对象，包括这个对象所包含的内部对象。
|
||
|
||
上面的结论没有完全理解的话也没关系，我们来看一个具体的案例！
|
||
|
||
**浅拷贝**
|
||
|
||
浅拷贝的示例代码如下，我们这里实现了 `Cloneable` 接口，并重写了 `clone()` 方法。
|
||
|
||
`clone()` 方法的实现很简单，直接调用的是父类 `Object` 的 `clone()` 方法。
|
||
|
||
```java
|
||
public class Address implements Cloneable{
|
||
private final String name;
|
||
// 省略构造函数、Getter&Setter方法
|
||
@Override
|
||
public Address clone() {
|
||
try {
|
||
return (Address) super.clone();
|
||
} catch (CloneNotSupportedException e) {
|
||
throw new AssertionError();
|
||
}
|
||
}
|
||
}
|
||
|
||
public class Person implements Cloneable {
|
||
private Address address;
|
||
// 省略构造函数、Getter&Setter方法
|
||
@Override
|
||
public Person clone() {
|
||
try {
|
||
Person person = (Person) super.clone();
|
||
return person;
|
||
} catch (CloneNotSupportedException e) {
|
||
throw new AssertionError();
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
测试 ：
|
||
|
||
```java
|
||
Person person1 = new Person(new Address("武汉"));
|
||
Person person1Copy = person1.clone();
|
||
// true
|
||
System.out.println(person1.getAddress() == person1Copy.getAddress());
|
||
```
|
||
|
||
从输出结构就可以看出， `person1` 的克隆对象和 `person1` 使用的仍然是同一个 `Address` 对象。
|
||
|
||
**深拷贝**
|
||
|
||
这里我们简单对 `Person` 类的 `clone()` 方法进行修改，连带着要把 `Person` 对象内部的 `Address` 对象一起复制。
|
||
|
||
```java
|
||
@Override
|
||
public Person clone() {
|
||
try {
|
||
Person person = (Person) super.clone();
|
||
person.setAddress(person.getAddress().clone());
|
||
return person;
|
||
} catch (CloneNotSupportedException e) {
|
||
throw new AssertionError();
|
||
}
|
||
}
|
||
```
|
||
|
||
测试 ：
|
||
|
||
```java
|
||
Person person1 = new Person(new Address("武汉"));
|
||
Person person1Copy = person1.clone();
|
||
// false
|
||
System.out.println(person1.getAddress() == person1Copy.getAddress());
|
||
```
|
||
|
||
从输出结构就可以看出，虽然 `person1` 的克隆对象和 `person1` 包含的 `Address` 对象已经是不同的了。
|
||
|
||
**那什么是引用拷贝呢？** 简单来说，引用拷贝就是两个不同的引用指向同一个对象。
|
||
|
||
我专门画了一张图来描述浅拷贝、深拷贝、引用拷贝：
|
||
|
||
|
||
|
||
## Java 常见对象
|
||
|
||
### Object
|
||
|
||
#### Object 类的常见方法有哪些？
|
||
|
||
Object 类是一个特殊的类，是所有类的父类。它主要提供了以下 11 个方法：
|
||
|
||
```java
|
||
public final native Class<?> getClass()//native方法，用于返回当前运行时对象的Class对象，使用了final关键字修饰，故不允许子类重写。
|
||
|
||
public native int hashCode() //native方法，用于返回对象的哈希码，主要使用在哈希表中，比如JDK中的HashMap。
|
||
public boolean equals(Object obj)//用于比较2个对象的内存地址是否相等，String类对该方法进行了重写用户比较字符串的值是否相等。
|
||
|
||
protected native Object clone() throws CloneNotSupportedException//naitive方法，用于创建并返回当前对象的一份拷贝。一般情况下，对于任何对象 x，表达式 x.clone() != x 为true，x.clone().getClass() == x.getClass() 为true。Object本身没有实现Cloneable接口，所以不重写clone方法并且进行调用的话会发生CloneNotSupportedException异常。
|
||
|
||
public String toString()//返回类的名字@实例的哈希码的16进制的字符串。建议Object所有的子类都重写这个方法。
|
||
|
||
public final native void notify()//native方法，并且不能重写。唤醒一个在此对象监视器上等待的线程(监视器相当于就是锁的概念)。如果有多个线程在等待只会任意唤醒一个。
|
||
|
||
public final native void notifyAll()//native方法，并且不能重写。跟notify一样，唯一的区别就是会唤醒在此对象监视器上等待的所有线程，而不是一个线程。
|
||
|
||
public final native void wait(long timeout) throws InterruptedException//native方法，并且不能重写。暂停线程的执行。注意：sleep方法没有释放锁，而wait方法释放了锁 。timeout是等待时间。
|
||
|
||
public final void wait(long timeout, int nanos) throws InterruptedException//多了nanos参数，这个参数表示额外时间（以毫微秒为单位，范围是 0-999999）。 所以超时的时间还需要加上nanos毫秒。
|
||
|
||
public final void wait() throws InterruptedException//跟之前的2个wait方法一样，只不过该方法一直等待，没有超时时间这个概念
|
||
|
||
protected void finalize() throws Throwable { }//实例被垃圾回收器回收的时候触发的操作
|
||
```
|
||
|
||
### String
|
||
|
||
#### String、StringBuffer、StringBuilder 的区别？String 为什么是不可变的?
|
||
|
||
**可变性**
|
||
|
||
简单的来说：`String` 类中使用 `final` 关键字修饰字符数组来保存字符串，~~所以`String` 对象是不可变的。~~
|
||
|
||
```java
|
||
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
|
||
private final char value[];
|
||
//...
|
||
}
|
||
```
|
||
|
||
> 🐛 修正 ： 我们知道被 `final` 关键字修饰的类不能被继承，修饰的方法不能被重写，修饰的变量是基本数据类型则值不能改变，修饰的变量是引用类型则不能再指向其他对象。因此，`final` 关键字修饰的数组保存字符串并不是 `String` 不可变的根本原因，因为这个数组保存的字符串是可变的（`final` 修饰引用类型变量的情况）。
|
||
>
|
||
> `String` 真正不可变有下面几点原因：
|
||
>
|
||
> 1. 保存字符串的数组被 `final` 修饰且为私有的，并且`String` 类没有提供/暴露修改这个字符串的方法。
|
||
> 2. `String` 类被 `final` 修饰导致其不能被继承，进而避免了子类破坏 `String` 不可变。
|
||
>
|
||
> 相关阅读：[如何理解 String 类型值的不可变？ - 知乎提问](https://www.zhihu.com/question/20618891/answer/114125846)
|
||
>
|
||
> 补充（来自[issue 675](https://github.com/Snailclimb/JavaGuide/issues/675)）：在 Java 9 之后，`String` 、`StringBuilder` 与 `StringBuffer` 的实现改用 byte 数组存储字符串。
|
||
|
||
`StringBuilder` 与 `StringBuffer` 都继承自 `AbstractStringBuilder` 类，在 `AbstractStringBuilder` 中也是使用字符数组保存字符串，不过没有使用 `final` 和 `private` 关键字修饰，最关键的是这个 `AbstractStringBuilder` 类还提供了很多修改字符串的方法比如 `append` 方法。
|
||
|
||
```java
|
||
abstract class AbstractStringBuilder implements Appendable, CharSequence {
|
||
char[] value;
|
||
public AbstractStringBuilder append(String str) {
|
||
if (str == null)
|
||
return appendNull();
|
||
int len = str.length();
|
||
ensureCapacityInternal(count + len);
|
||
str.getChars(0, len, value, count);
|
||
count += len;
|
||
return this;
|
||
}
|
||
//...
|
||
}
|
||
```
|
||
|
||
**线程安全性**
|
||
|
||
`String` 中的对象是不可变的，也就可以理解为常量，线程安全。`AbstractStringBuilder` 是 `StringBuilder` 与 `StringBuffer` 的公共父类，定义了一些字符串的基本操作，如 `expandCapacity`、`append`、`insert`、`indexOf` 等公共方法。`StringBuffer` 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。`StringBuilder` 并没有对方法进行加同步锁，所以是非线程安全的。
|
||
|
||
**性能**
|
||
|
||
每次对 `String` 类型进行改变的时候，都会生成一个新的 `String` 对象，然后将指针指向新的 `String` 对象。`StringBuffer` 每次都会对 `StringBuffer` 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 `StringBuilder` 相比使用 `StringBuffer` 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。
|
||
|
||
**对于三者使用的总结：**
|
||
|
||
1. 操作少量的数据: 适用 `String`
|
||
2. 单线程操作字符串缓冲区下操作大量数据: 适用 `StringBuilder`
|
||
3. 多线程操作字符串缓冲区下操作大量数据: 适用 `StringBuffer`
|
||
|
||
#### 字符串拼接用“+” 还是 StringBuilder?
|
||
|
||
Java 语言本身并不支持运算符重载，“+”和“+=”是专门为 String 类重载过的运算符，也是 Java 中仅有的两个重载过的元素符。
|
||
|
||
```java
|
||
String str1 = "he";
|
||
String str2 = "llo";
|
||
String str3 = "world";
|
||
String str4 = str1 + str2 + str3;
|
||
```
|
||
|
||
对象引用和“+”的字符串拼接方式，实际上是通过 `StringBuilder` 调用 `append()` 方法实现的，拼接完成之后调用 `toString()` 得到一个 `String` 对象 。
|
||
|
||
|
||
|
||
不过，在循环内使用“+”进行字符串的拼接的话，存在比较明显的缺陷：**编译器不会创建单个 `StringBuilder` 以复用，会导致创建过多的 `StringBuilder` 对象**。
|
||
|
||
```java
|
||
String[] arr = {"he", "llo", "world"};
|
||
String s = "";
|
||
for (int i = 0; i < arr.length; i++) {
|
||
s += arr[i];
|
||
}
|
||
System.out.println(s);
|
||
```
|
||
|
||
`StringBuilder` 对象是在循环内部被创建的，这意味着每循环一次就会创建一个 `StringBuilder` 对象。
|
||
|
||
|
||
|
||
如果直接使用 `StringBuilder` 对象进行字符串拼接的话，就不会存在这个问题了。
|
||
|
||
#### String#equals() 和 Object#equals() 有何区别？
|
||
|
||
`String` 中的 `equals` 方法是被重写过的，比较的是 String 字符串的值是否相等。 `Object` 的 `equals` 方法是比较的对象的内存地址。
|
||
|
||
#### 字符串常量池的作用了解吗？
|
||
|
||
**字符串常量池** 是 JVM 为了提升性能和减少内存消耗针为字符串（String 类）专门开辟的一块区域，主要目的是为了避免字符串的重复创建。
|
||
|
||
```java
|
||
String aa = "ab"; // 放在常量池中
|
||
String bb = "ab"; // 从常量池中查找
|
||
System.out.println(aa==bb);// true
|
||
```
|
||
|
||
JDK1.7 之前运行时常量池逻辑包含字符串常量池存放在方法区。JDK1.7 的时候，字符串常量池被从方法区拿到了堆中。
|
||
|
||
你可以在 JVM 部分找到更多关于字符串常量池的介绍。
|