Java 快速入门 知识精简（2）基础知识-关键字
关键字
定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）。
特点：关键字中所有字母都为小写。
用于定义数据类型的关键字：
类的类型定义 class interface enum
方法返回值的类型定义 void
数据类型定义 byte short int long float double char boolean
public class MyClass {
// 类 类名: MyClass
}
public interface MyInterface {
// 接口 接口名: MyInterface
}
public enum Day {
// 枚举 枚举名: Day
MONDAY, TUESDAY, WEDNESDAY;
}
public class TestClass{
public void doSomething() { // 方法 方法名: doSomething
// void: 不返回任何值
}
// byte：8位有符号整数
byte b = 100;
// short：16位有符号整数。
short s = 10000;
// int：32位有符号整数。
int i = 1000000;
// long：64位有符号整数。
long l = 100000000000L;
// float：单精度浮点数。
float f = 1.23F;
// double：双精度浮点数。
double d = 1.23;
// char：单字符。
char ch = 'A';
// boolean：布尔值。
boolean flag = true;
}
}
用于定义流程控制的关键字：
if else switch case default do while for
break continue return
public class testClass{ // 类 testClass
public String test(){ // 方法 test 定义了String字符串类型的返回值
// if-else：条件控制
if (condition) {
// 条件为真时执行
} else {
// 条件为假时执行
}
// switch-case-default：多条件选择
switch (day) {
case MONDAY:
// day = MONDAY时, 执行代码
break;
default:
// 默认执行的代码
break;
// do-while：循环控制
do {
a += 1; // a = a + 1
} while (a < 10); // 先执行一次do{}中的代码 , 再判断while()
// while：循环控制
while (a < 10) { // 当 a < 10 执行while(){}
System.out.println("a小于10");
}
// for：循环控制
for (int i = 0; i < 10; i++) {
// 循环体
}
// break：跳出循环
for (int i = 0; i < 10; i++) {
if (i == 5) {
break; // 跳出循环
}
}
// continue：跳过当前循环
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
continue; // 跳过偶数
}
// 执行奇数的代码
}
// return：结束方法
return "返回值"; // 返回字符串
}
}用于定义访问权限修饰符的关键字：
public protected private 默认无修饰符 default
// public：公共访问权限。
public class PublicClass {
// 类体
}
// protected：受保护的访问权限。
protected int protectedVar;
// private：私有访问权限。
private void privateMethod() {
// 方法体
}
// default（无修饰符）：包访问权限。
class DefaultAccessClass {
// 默认包访问权限的成员
}用于定义类、函数、变量修饰符的关键字：
abstract final static synchronized
// abstract：抽象的
public abstract class AbstractClass {
// 抽象类不能被实例化
}
// final：最终的，不可改变的
final int CONSTANT = 100;
public class MyClass {
// static：静态的
public static void staticMethod() {
// 静态方法
}
// synchronized：同步的
public synchronized void synchronizedMethod() {
// 同步方法
}
}用于定义类与类之间关系的关键字：
extends implements
// extends：继承
public class SubClass extends SuperClass {
// 子类 继承 父类
}
// implements：实现
public class MyClass implements MyInterface {
// 类 实现 接口
}用于定义建立实例与引用实例，判断实例的关键字：
new this super instanceof
// new：创建新实例
MyClass obj = new MyClass();
// this：指向当前对象的引用
public class MyClass {
public void print() {
System.out.println(this);
}
}
// super：指向父类的引用
public class SubClass extends SuperClass {
public void method() {
super.someMethod(); // 调用父类的方法
}
}
// instanceof：判断实例类型
if (obj instanceof MyClass) {
// obj是MyClass类型或其子类的实例
boolean isMyClass = true
}用于异常处理的关键字：
try catch finally throw throws
public void method() throws Exception {
try-catch-finally：异常处理。
try {
// 尝试执行的代码
} catch (Exception e) {
// 异常发生时执行的代码
throw new Exception("Error occurred"); // throw：抛出异常。
} finally {
// 无论是否发生异常都会执行的代码
}
}
// throws：方法可能抛出的异常。
public void method() throws IOException {
// 可能会抛出IOException的方法体
}用于包的关键字：
package import
package com.example; // package：定义包
// import：导入类或包
import com.example.MyClass;
import java.util.*;其他修饰符关键字：
native strictfp transient volatile
public class TestClass {
// native：方法用其他语言实现
public native void nativeMethod();
// strictfp：严格模式浮点数计算
public strictfp double strictfpMethod(double a, double b) {
return a + b;
}
// transient：对象序列化时忽略该变量
public transient int transientVar;
// volatile：确保变量的读写操作的原子性，保证内存可见性
private volatile int counter;
}用于定义数据类型值的字面值
true false null
public class TestClass {
// true 和 false：布尔值。
boolean isTrue = true;
boolean isFalse = false;
// null：空引用。
String str = null;
}保留字（reserved word）：
goto const