一 什么是Java关键字
Java关键字是Java编程语言中保留的词汇，它们具有特殊的意义和用途，用于定义数据类型、控制程序的流程、声明类和方法等。在Java中，关键字不能作为变量名、方法名、类名或任何其他标识符使用。
二 Java关键字有哪些
访问控制相关
- public：公开的，可以被所有类访问。
- protected：受保护的，可以被同一包中的类以及子类访问。
- private：私有的，只能被声明它的类访问。
定义类、接口、抽象类和实现接口、继承类的关键字、实例化对象
- class：定义一个类。
- interface：定义一个接口。
- abstract：声明抽象类或抽象方法。
- implements：声明一个类实现一个或多个接口。
- extends：表示一个类是另一个类的子类（继承）。
- new：用来创建新实例对象。
包的关键字
- import：引入其他包中的类或接口。
- package：声明类所在的包。
数据类型相关
- boolean：布尔类型，取值为true或false。
- byte：8位整数类型。
- char：16位Unicode字符。
- short：16位整数类型。
- int：32位整数类型。
- long：64位整数类型。
- float：32位单精度浮点数。
- double：64位双精度浮点数。
- void：声明方法没有返回值。
- null：空值，表示无值，不能将null赋给原始类型（byte、short、int、long、char、float、double、boolean）变量。
- true、false：布尔类型的两个合法值。
流程控制
- if：定义条件语句。
- else：与if语句配合使用，定义条件为false时的执行代码。
- switch：定义多分支选择结构。
- case：定义switch语句中的一个分支。
- default：定义switch语句中的默认分支。
- while：定义while循环。
- do：定义do-while循环的开始。
- for：定义for循环。
- break：跳出当前循环或switch语句。
- continue：跳过当前循环的剩余部分并开始下一次循环。
修饰方法、类、属性和变量
- final：声明最终类、方法或变量，不能被继承、重写或修改。
- static：声明类的静态成员，属于类而不是实例。
- strictfp：用于限制浮点计算，使其在所有平台上有一致的结果。
- synchronized：用于方法或代码块，表示同步，防止线程干扰。
- transient：声明不序列化的变量。
- volatile：声明易变的变量，防止编译器进行优化。
错误处理
- try：定义一个异常处理块的开始。
- catch：定义捕获异常的代码块。
- finally：定义在try-catch结构中总是执行的代码块。
- throw：抛出一个异常。
- throws：声明一个方法可能抛出的异常。
其他关键字
- super：引用父类的成员。
- this：引用当前对象的成员。
- assert：断言，用来进行程序调试（注意：在生产代码中可能会被禁用）。
- enum：枚举。
- native：声明本地方法，用于与本地代码（如C/C++）进行交互。
需要注意的是，Java中总共有53个关键字（包括两个保留字goto和const，以及三个特殊直接量true、false、null），并且Java的关键字都是小写的。
三 访问控制相关的三个关键字有什么区别（public、private、protected ）
Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
-
default (即默认）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
-
private : 在同一类内可见。使用对象：变量、方法，不能修饰类（外部类）
-
public : 对所有类可见。使用对象：类、接口、变量、方法
-
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法， 不能修饰类（外部类）。
四 抽象类和接口的区别是什么？
1. 实现方式
- 抽象类：是一个具体的类，可以有成员变量、方法的具体实现以及抽象方法。抽象类可以包含构造方法，用于初始化成员变量。
- 接口：是一种完全抽象的类型，只能定义方法的签名（即方法名和参数列表），不能包含任何方法的实现。接口也不能包含构造方法，因为接口不能直接实例化。
2. 继承关系
- 抽象类：Java中的类只能继承一个抽象类，因为Java不支持多继承（即一个类不能同时继承多个类）。
- 接口：一个类可以实现多个接口，这允许类具有多个类型的特性，从而弥补Java单继承的局限性。
3. 方法的定义
- 抽象类：可以包含抽象方法和具体方法。抽象方法是没有方法体的方法，必须由子类实现；具体方法则包含实现代码，可以直接在抽象类中使用。
- 接口：接口中的所有方法都是抽象的，没有默认实现。在Java 8及以后版本中，接口可以包含默认方法（使用default关键字修饰）和静态方法，但这些方法仍然是抽象的，只是提供了默认的实现供实现类选择性地使用。
4. 成员变量
- 抽象类：可以定义成员变量，包括常量和普通变量。这些变量可以被抽象类及其子类访问和修改。
- 接口：只能定义常量，即被final修饰的成员变量。这些常量在接口中被隐式声明为public static final，且必须被赋值。
5. 访问修饰符
- 抽象类：其方法和成员变量的访问修饰符可以是public、protected、默认（即包级私有）或private。但抽象方法通常被声明为public或protected，以便子类能够访问和实现。
- 接口：其方法默认是public的，且不能声明为其他访问修饰符。接口中的常量默认是public static final的，也不能声明为其他修饰符。
6. 使用场景
- 抽象类：主要用于定义类的结构，提供一些共同的属性和方法，作为多个子类的父类。它适用于需要部分实现和部分抽象的场景，如模板方法模式。
- 接口：主要用于定义一组行为规范或契约，即一组方法的声明。实现接口的类必须遵循这些行为规范。接口适用于定义类的行为，实现类可以根据需要实现多个接口，以实现多态和解耦合。
五 Java中的数据类型
| 基本类型 | 位数 | 字节 | 默认值 |
|---|---|---|---|
| int | 32 | 4 | 0 |
| short | 16 | 2 | 0 |
| long | 64 | 8 | 0L |
| byte | 8 | 1 | 0 |
| char | 16 | 2 | 'u0000' |
| float | 32 | 4 | 0f |
| double | 64 | 8 | 0d |
| boolean | 1 | false |
六 break continue return的区别
1. break
break语句用于完全终止最近的循环（for、while、do-while）或switch语句的执行。当break语句被执行时，程序会立即退出包含它的循环或switch语句，并继续执行循环或switch之后的下一条语句。
for (int i = 0; i < 10; i++) {
if (i == 5) {
break; // 当i等于5时，退出循环
}
System.out.println(i);
}int number = 2;
switch (number) {
case 1:
System.out.println("One");
break;
case 2:
System.out.println("Two");
break; // 即使没有这条break，由于后面没有case，也会自然退出
case 3:
System.out.println("Three");
// 如果没有break，则会继续执行下一个case的代码，即case穿透
}2. continue
continue语句用于跳过当前循环的剩余部分，并继续下一次循环迭代（如果有的话）。continue不会完全退出循环，只是跳过当前迭代中continue之后的语句，直接开始下一次迭代。
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
continue; // 跳过偶数
}
System.out.println(i);
}3. return
return语句用于从当前方法返回一个值（如果有的话）给调用者，并结束当前方法的执行。如果方法没有返回值（即返回类型为void），则可以使用不带任何值的return语句来提前退出方法。
public int getMax(int a, int b) {
if (a > b) {
return a; // 返回a并退出方法
}
return b; // 返回b并退出方法
}public void printNumbers() {
for (int i = 0; i < 10; i++) {
if (i == 5) {
return; // 直接退出方法
}
System.out.println(i);
}
}七 static关键字
在Java中，static 关键字是一个非常重要的修饰符，它用于声明属于类的成员（变量和方法），而不是属于类的任何特定对象。使用 static 修饰的成员可以通过类名直接访问，而无需创建类的实例。
静态变量（Static Variables）：静态变量属于类，而不是类的任何对象。因此，无论创建多少个类的对象，静态变量都只有一份拷贝，被类的所有实例共享。静态变量在类加载到JVM时初始化，而不是在创建类的实例时。
静态方法（Static Methods）：静态方法属于类，不依赖于类的任何特定对象。它们不能访问类的非静态成员（变量和方法），因为非静态成员依赖于类的具体对象。但是，静态方法可以访问其他静态成员。静态方法通常用于工具类中的方法，这些类只包含静态成员。
静态块（Static Blocks）：静态块在类加载到JVM时执行，且只执行一次。它们通常用于初始化静态变量或执行仅需执行一次的静态初始化代码。
静态导入（Static Import）：Java允许使用
import static语句来导入静态成员（如静态方法和静态变量），从而可以在不使用类名的情况下直接引用它们。
需要注意的是静态成员不能访问类的非静态成员，因为非静态成员依赖于具体的对象实例，而静态成员属于类本身，不依赖于任何对象实例。虽然静态成员很方便，但过度使用会导致代码难以理解和维护，特别是当静态成员依赖于类的其他静态成员时，可能会引入难以发现的初始化顺序问题（也称为初始化依赖问题）。
八 this 关键字
在Java中，this 是一个关键字，它是对当前对象的引用。它主要用于以下几种情况：
1.访问当前对象的属性和方法：当在类的方法内部需要引用当前对象的属性或调用其他方法时，可以使用 this 关键字。虽然在很多情况下可以省略 this，但在某些情况下（如区分局部变量和成员变量时）必须使用。
public class Person {
private String name;
public Person(String name) {
this.name = name; // 使用this来区分成员变量name和参数name
}
public void setName(String name) {
this.name = name; // 同样，这里使用this来区分
}
public String getName() {
return this.name; // 虽然这里可以省略this，但加上可以明确是访问成员变量
}
} 2.在构造函数中调用另一个构造函数：在同一个类中，一个构造函数可以调用另一个构造函数，以避免代码重复。这是通过 this() 语法实现的，但需要注意的是，这种调用必须是构造函数中的第一条语句。
public class Rectangle {
private double width;
private double height;
public Rectangle() {
this(1.0, 1.0); // 调用下面的构造函数
}
public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
} 3.返回当前对象的引用：在某些情况下，如链式调用（fluent interface）中，方法可能会返回当前对象的引用（this），以支持连续调用。
public class StringBuilderExample {
private String text = "";
public StringBuilderExample append(String str) {
this.text += str;
return this; // 返回当前对象的引用，支持链式调用
}
public String toString() {
return this.text;
}
public static void main(String[] args) {
StringBuilderExample sbe = new StringBuilderExample().append("Hello, ").append("World!");
System.out.println(sbe); // 输出: Hello, World!
}
}
273
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
