Java基础面试题

1.&和&&的区别？

都可以用作逻辑与的运算符，表示逻辑与（ and ），当运算符两边的表达式的结果都为 true 时，整个运算结果才为 true ， 否则，只要有一方为 false ，则结果为 false 。

&& 还具有短路的功能，即如果第一个表达式为 false ，则不再计算第二个表达式.

2.八种基本数据类型的大小，以及他们的封装类

基本类型         大小（字节）        默认值      封装类

byte                   1                         (byte)0        Byte

short                  2                        (short)0      Short

int                      4                             0           Integer

long                   8                            0L           Long

float                   4                           0.0f          Float

double               8                          0.0d         Double

boolean             ~                         false         Boolean

char                   2                   \u0000(null)   Character

3.switch 是否能作用在 byte 上，是否能作用在 long 上，是否能作用在 String 上?

在Java五版本前可以作用在bytr. short . char . int 上，在Java7 版本后加人了String 

long 在目前版本都不可以

4.short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

s1+1 运算时会自动提升表达式的类型，所以结果是 int 型，再赋值给 short 类型 s1 时，编译器将

报告需要强制转换类型的错误。

+= 是 java 语言规定的运算符， java 编译器会对它进行特殊处理，因此可以正确编译。

5.char 型变量中能不能存贮一个中文汉字?为什么?

char 型变量是用来存储 Unicode 编码的字符的，unicode 编码字符集中包含了汉字，所以可以

6. 使用 final 关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

使用 final 关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的

7."=="和 equals 方法究竟有什么区别？

== 操作符用于比较两个变量的值是否相等。

1.在比较基本数据类型时，== 比较的是它们的值是否相同。

2.在比较引用类型时，== 比较的是它们在内存中的地址是否相同，即两个引用是否指向同一个对象

equals()：用来检测两个对象是否相等，即两个对象的内容是否相等。

8.静态变量和实例变量的区别？

在语法定义上的区别：静态变量前要加 static 关键字，而实例变量前则不加。

初始化时机的区别：
静态变量：随着类的加载而初始化。这意味着，当类被JVM（Java虚拟机）加载到内存中时，静态变量就会被分配空间并初始化（如果指定了初始值）。
实例变量：在创建类的实例（即对象）时初始化。每当使用new关键字创建类的实例时，都会为实例变量分配空间并初始化（如果指定了初始值或构造函数中进行了初始化）

内存位置的区别：
静态变量：存储在静态变量区（也称为方法区或永久代，但在现代JVM中可能有所不同，如Java 8及以后版本中的元空间）。这些变量在类的整个生命周期内都存在，且所有实例共享同一份静态变量。
实例变量：存储在堆内存区。每个对象都有自己独立的实例变量副本，这些变量随着对象的创建而分配空间，随着对象的销毁而失去引用，最终等待垃圾回收。

调用方式
静态变量：可以通过类名直接访问，无需创建类的实例。
实例变量：必须通过类的实例（对象）来访问。

生命周期

静态变量：随着类的加载而加载，直到JVM停止运行时才销毁。静态变量的生命周期与类的生命周期相同。

实例变量：随着对象的创建而产生，随着对象的销毁而失去引用，最终等待垃圾回收。实例变量的生命周期与对象的生命周期相同。

9.Integer 与 int 的区别？

1.Integer是int的包装类，int则是java的一种基本的数据类型；

2.Integer变量必须实例化之后才能使用，而int变量不需要实例化；

3.Integer实际是对象的引用，当new一个Integer时，实际上生成一个指针指向对象，而int则直接存储数值

4.Integer的默认值是null，而int的默认值是0。

10.作用域 public，private，protected，以及不写时的区别？

作用域            当前类   同一 package     子孙类      其他 package

public               √               √                        √                      √

protected           √             √                         √                      ×

friendly              √             √                          ×                      ×

private              √              ×                          ×                      ×

11.Overload 和 Override 的区别。Overloaded 的方法是否可以改变返回值的类型?

Overload（重载）：指在同一个类中，有多个方法拥有相同的名称，但参数列表不同。重载的方法可以有不同的返回值类型。重载的目的是为了提供更多的方法选择，以适应不同的参数类型和个数。应用：构造方法重载

Override（覆盖/重写）：指在子类中重新定义（覆盖/重写）从父类继承而来的方法。被覆盖的方法必须具有相同的名称、参数列表和返回类型。通过覆盖，子类可以改变继承方法的实现，使其符合子类的特定需求。应用：方法的重写（private修饰的方法不能被重写）

Overload 强调的是方法的多样性，在同一类中通过参数列表的不同来实现方法的重载。

Override 强调的是方法的重新定义，在子类中重新实现从父类继承而来的方法，要求方法的名称、参数列表和返回类型都相同。

12.构造器 Constructor 是否可被 override?

• 构造器不能被重写（Override）：由于构造器不被继承，因此无法在子类中提供不同的实现。
• 构造器可以被重载（Overload）：同一个类中可以定义多个构造器，只要它们的参数列表不同。重载的构造器允许在创建对象时使用不同的参数。
• 构造器 Constructor 不能被继承，因此不能重写 Override，但可以被重载 Overload。

13.面向对象的特征有哪些方面

1、封装：隐藏了类的内部实现机制。对属性进行了封装：外界只能通过特定的方法进行访问。对方法进行了封装：外界只能通过定制好的方式调用，不用了解方法内部逻辑，方便使用。保护了数据。便于修改，增强了代码的可维护性和复用性

2.继承：是从已有的类中派生出新的类，即子类继承自父类。当子类通过extends关键字继承了父类后，便继承了父类的属性和方法（注意：子类继承了父类的所有属性和方法。但父类的私有属性和方法，子类是不能直接访问的，只是拥有但无法使用）。同时子类还可以具备父类所不具备的属性或方法。

通过继承避免了对各个类中重复的属性和方法进行反复描述。增强了代码的复用性。代码更加简洁。

3.多态：是类和类的关系。多态必须具备三个条件：1.要有继承关系    2.要有方法的重写    3.父类的引用指向子类的对象。

正是因为两个类有继承关系，并存在方法的重写，才能在调用时有父类的引用指向子类的对象

通过多态可以是一个对象在不同载体中呈现不同的状态。即同一个父类引用在调用同一个方法时会得到不同的结果。多态减少了类的代码量，提高了代码的可维护性、可扩展性和复用性。

14.abstract class 和 interface 有什么区别?

抽象类 (Abstract Class) 和接口 (Interface) 都是在面向对象编程中用于实现抽象性的工具，它们之间有以下几个关键区别：

1. 实现方式：

   • 抽象类 可以包含属性（成员变量）、默认方法实现（非抽象方法）以及抽象方法（无方法体的方法）。一个类可以继承一个抽象类，并且可以选择实现部分或全部抽象方法。
   • 接口 只能包含常量（static final修饰的变量）和抽象方法（没有方法体）。一个类可以实现多个接口，但接口不允许有任何实现代码。

2. 实例化：

   • 抽象类不能直接创建实例，因为可能存在未实现的抽象方法。它通常作为基类提供给其他类继承。
   • 接口本身也不能被实例化，但是一个类可以同时实现多个接口，然后通过创建该类的实例间接实现接口的行为。

3. 访问修饰符：

   • 抽象类中的成员方法默认是非公有的（package-private），但在 Java 8 中引入了default关键字，允许其包含默认方法。
   • 接口中所有方法默认都是公共的（public）。

4. 目的：

   • 抽象类旨在提供一些基础功能和共享的行为，常用于表示具有共同特征的类的集合。
   • 接口更侧重于定义规范和行为契约，常用于实现多态性和行为的解耦。

15.String 是最基本的数据类型吗?

基本数据类型包括 byte 、 int 、 char 、 long 、 float 、 double 、 boolean 和 short 。

java.lang.String 类 是 final 类型 的，因此 不可以继承这个类、不能修改这个类 。为了提高效率节省空间，我们应该用 StringBuffer 类

16.String   s = "Hello";s = s + " world!";这两行代码执行后，原始的 String 对象中的内容到底变了没有？

没有。因为 String 被设计成 不可变(immutable)类 ，所以它的所有对象都是不可变对象。

17.是否可以继承 String 类?

String 类是 final 类故不可以继承。

18.String s = new String("xyz");创建了几个 String Object? 二者之间有什么区 别？ xyz 是字面量

两个，一个放在常量区，不管写多少遍，都是同一个。 New String 每写一遍，就创建一个新。

19.String 和 StringBuffer 的区别

String 和 StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个 String 类提供了 数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改

1. 不可变性：

   • String 对象是不可变的。这意味着一旦创建了一个 String 对象，就不能改变它的内容，如果需要修改，会创建一个新的 String 对象。这使得 String 适合于频繁的拼接操作，但对大量改动的场景效率较低。
   • StringBuffer 和 StringBuilder 类则是可变的。每次对它们进行追加、插入或删除操作，它们都会在内部进行相应的内存调整，而不会生成新的对象。因此，对于频繁的修改操作，它们通常比 String 更高效。

2. 线程安全：

   • String 由于其不可变性，实际上是线程安全的，多个线程同时操作也不会导致数据冲突。
   • StringBuffer 是线程安全的，因为它在其内部同步了对字符序列的操作，所以在多线程环境下，如果你不确定是否会被并发访问，通常推荐使用 StringBuffer。
   • StringBuilder 则不是线程安全的，但它比 StringBuffer 更轻量级，当在单线程环境中时，使用 StringBuilder 可能得到更好的性能。

3. 性能：

   • 当涉及到大量字符串拼接时，StringBuilder 或 StringBuffer 性能优于 String，因为它们避免了大量的对象复制。
   • 如果只是获取字符串，String 提供了更快的访问速度，因为它不需要进行额外的同步操作。

20.try {}里有一个 return 语句，那么紧跟在这个 try 后的 finally {}里的 code 会 不会被执行，什么时候被执行，在 return 前还是后?

会执行，在 return 前执行。