Java 关键字 – 基础数据类型

Java 是面向对象语言, 但有几个特例,就是基础数据类型。

Java定义了八种基本的数据类型,分为四类:

整数类型:

  • byte:占用1个字节(8位),取值范围从-128到127。
  • short:占用2个字节(16位),取值范围从-32,768到32,767。
  • int:占用4个字节(32位),取值范围从-2^31到2^31-1。这是最常用的整数类型。
  • long:占用8个字节(64位),取值范围从-2^63到2^63-1。

浮点数类型:

  • float:占用4个字节(32位),是单精度浮点数类型。
  • double:占用8个字节(64位),是双精度浮点数类型。这是最常用的浮点数类型。

字符类型:

  • char:占用2个字节(16位),用于表示单个Unicode字符。

布尔类型:

  • boolean:理论上占用1个比特,但实际大小取决于虚拟机实现。只有两个取值:true和false。
//下面是一些声明基本类型变量的例子:
byte byteVar = 100;
short shortVar = 1000;
int intVar = 10000;
long longVar = 100000L; // 注意末尾的L,表示这是一个long类型的字面量

float floatVar = 10.0F; // 注意末尾的f,表示这是一个float类型的字面量
double doubleVar = 10.0;

char charVar = 'A';
boolean booleanVar = true;


基本类型有一些特点:

  • 它们的大小是固定的,不会因为不同的机器而改变。
  • 它们不是对象,因此不具备对象的属性和方法。 因此他们间比较时需要直接使用 ==
  • 基本类型都有对应的包装类,包装类和基础类型间可以进行自动装箱和拆箱。例如:int的包装类是Integer,double的包装类是Double等。
Integer a = 1; //自动装箱,将a 转换为 包装类。
Integer b = 2;
int b = a;   //自动拆箱
if(b > a ){//自动拆箱
//...
}

Java 关键字 – for, while

for, while都是循环结构关键字,作用为支持重复执行相同代码,掌握了这两个关键字的使用,基本各种数据循环都可以实现。

示例: 按序输出26个字母

for(char c='a'; a<='z'; a++){
     System.out.println(a);
}
char c='a';
while (a<='z'){
   System.out.println(a);
}

for

for 语法结构有两种:条件for 及for-each 结构

//for 结构
for (初始化表达式; 条件表达式; 步进表达式) {
    // 循环体:当条件表达式为true时执行
}。

初始化表达式 一般为循环控制变量的初始化,只在循环开始时执行一次, 可为空。
条件表达式 循环控制表达式,可以为空,如果有则必须为布尔表达式,每次循环前都会执行,且只有表达为true 时,循环才会执行
步进表达式 循环体执行完后执行的表达式, 一般用户循环控制变量的修改。 可为空。

for (int i = 1; i <= 5; i++) {
    System.out.println(i);
}
for (;;) {
    System.out.println("-");
    break;
}

注意: 这个三个表达式可以部分为空,也可以都为空的,都为空时,则循环的结束需在循环体中控制, 如使用break 或return 进行退出循环,等效while(true){//循环}

for-each 结构, 这是Java 5 引入了一种特殊类型的for循环,称为”增强for循环”或”for-each循环”,它简化了对数组或集合的遍历。增强for循环的语法如下:

for (数据类型 变量名 : 数组或实现了 Iterable 接口的任何集合类) {
    // 使用变量名进行操作
}

for-each 循环可以被视为Java语法糖。语法糖(Syntactic Sugar)是指在编程语言中添加的某种语法,这种语法让人们写代码时更加方便,但它并不提供新的功能,而是提供了一种更简洁易读的方法来表达已有的操作。也就是所有for-each 实现的代码都可以转换为for 循环结构实现,只是代码会复杂点。实际底层实现也是这么做的,如果遍历对象是实现了 Iterable 接口的任何集合类, 则使用了 Iterator 进行元素的遍历。如果你使用的是数组,它就会被编译成一个常规的 for 循环,使用索引来访问每个元素。

// 使用 for-each 循环
for (String item : listOfStrings) {
    System.out.println(item);
}
// 等价的使用 Iterator 的代码
for (Iterator<String> i = listOfStrings.iterator(); i.hasNext(); ) {
    String item = i.next();
    System.out.println(item);
}
// 如果是数组,则等价于常规的 for 循环
String[] arrayOfStrings = new String[] {"a", "b", "c"};
for (int i = 0; i < arrayOfStrings.length; i++) {
    System.out.println(arrayOfStrings[i]);
}

while

也有两种语法: while 及 do…while , 不过都是比较简单的。

while (condition) {
    // 循环体
    // 在这里编写需要重复执行的代码
}
do {
    // 循环体
    // 在这里编写需要重复执行的代码
}while(condition);

condition 是一个布尔表达式。在每次循环开始之前,都会评估这个条件。如果条件为 true,循环体内的代码块将被执行。完成循环体内的代码块后,条件将再次被评估,如果仍为 true,循环将继续执行。这个过程会一直重复,直到条件表达式的结果为 false

如果条件从一开始就是 false,那么循环体内的代码块一次也不会执行。

continue, break

这几个关键字出现在循环体,会影响循环体的执行。

continue (label): 执行到continue, 则结束本次循环,直接开始下次(label)循环。 label 为空则退出当前最近的循环。

break (label): 执行到break, 则结束退出(label)指定的循环, label 为空则退出当前最近的循环。

label 是可选的,通常循环嵌套时,用于退出多个循环时。

     first: for(int i =0; i< 10; i++){
          for (int j = 0; j < 10; j++){
              if(j== 5){
                  continue first;
              }
              if(j == 9){
                  break;
              }
              System.out.println("i="+i+",j="+j);
          }
      }

Java 关键字 — switch

Java 中的 switch 语句是一种多分支选择结构,它允许基于不同的情况执行不同的代码块。通常结合break, default, case 等关键字一起使用。

switch (expression) {
    case value1:
        // 代码块
        break; // 可选
    case value2:
        // 代码块
        break; // 可选
    // 可以有任意数量的case语句
    default: // 可选
        // 默认情况下的代码块
}

expression:这是一个必须的表达式,它的结果被用来与 case 语句中的值进行比较。这个表达式可以是 byte、short、char、int 类型,枚举(Java 5 开始支持),或者是 String 类型(Java 7 开始支持),
任意类型(Java 12).

case value:这是与 expression 结果进行匹配的值。如果匹配成功,紧随其后的代码块将被执行。
value 必须为一个常量表达式。  JAVA 12 开始支持类型推断。
JAVA 21 开始支持 when.

break:这是一个可选关键字,用来终止 switch 语句的执行。如果没有 break,程序将会继续执行下一个 case 中的代码,直到遇到 break 或者 switch 语句的结尾。

default:这也是一个可选部分,当没有任何 case 与 expression 的值匹配时,将执行 default 部分的代码。
示例:
final static class User{public String name;}

	private static final char m = 'm';
	private static final User user = new User();
	
	static void switchSen(Object v) {
		Character c = 1;
		User u = new User();
		switch(v) {
			case Integer i: System.out.println(i);
				break;
			//case c: System.out.println(1);
			//case 1: System.out.println(1);
			case User us: System.out.println(us);
			default: 
				System.out.println("default");
		}
		
		
		switch(c) {
			case 2: System.out.println(2);
			case m: System.out.println(m);
			default: 
				System.out.println("default");
		}
		
		switch(u) {
			case User i when u.name.equals("abc"): System.out.println(i);
	//		case user: System.out.println(2);
			default: 
				System.out.println("default");
		}
		
	}

switch 表达式
在 Java 12 及以后的版本中,switch 可以用作表达式,这意味着它可以返回一个值。switch 表达式使用 -> 来代替case 后的 :. 另外每个case 不需要使用break , 只返回因为表达式是有返回值的,因此其中的case 必须涵盖传入表达式的所有值。

switch (expression) {
    case value1 -> {
        // 代码块
        yield value; // 可选
    }
    case value2 -> value:
    // 可以有任意数量的case语句
    default -> default value // 可选
        // 默认情况下的代码块
}

case value:这是与 expression 结果进行匹配的值。如果匹配成功,紧随其后的代码块将被执行。
value 必须为一个常量表达式。 JAVA 12 开始支持类型推断。
JAVA 21 开始支持 when.

示例:

static String switchWhen(Object v) {
		//int when = 1; 
		//int yield = 3;//任然可以作为变量

		return switch(v) {
			case Integer i ->  i.toString();
			case String s when s.equalsIgnoreCase("yes") ->{
				yield s.toUpperCase();
			}
			case String s when s.equalsIgnoreCase("yeap") -> "yep";
			default ->  "EMPTY";
		};
	}
	
	static String switchNull(Object v) {
		return switch(v) {
			case Integer i ->  i.toString();
			case String s when s.equalsIgnoreCase("yes") ->{
				yield s.toUpperCase();
			}
			case String s -> "NO";
			case null,default ->  "EMPTY";
		};
	}
	
	static String switchString(CharSequence v) {
		return switch(v) {
			case String s -> "String";
			case CharSequence s -> "CS";
//			case String s when s.equalsIgnoreCase("yes") ->{
//				yield s.toUpperCase();
//			}
//			default ->  "EMPTY";  //前面两个case 已处理所有情况
		};
	}


为什么使用Switch
   从使用语法可知,switch 能实现的功能,if else 也是能实现的,但使用switch 有以下几大优势:


可读性: 当你需要基于同一个变量的不同值来执行不同的代码块时,switch语句比多个if-else语句更加清晰和易读。

效率: 对于包含许多case的情况,switch语句通常比if-else语句更高效,因为switch语句可以转化为跳转表,这意味着不需要按顺序检查每个条件。

可维护性: 当需要修改或者增加新的条件分支时,switch语句的结构使得这些变更更加集中和简单。

Java 关键字

Java关键字是指在Java编程语言中具有特定含义的保留单词。这些关键字代表了Java语言的基本构建块,它们用于定义数据类型、流程控制语句、访问权限等。由于这些单词被Java语言赋予了特殊的意义,不能用作标识符,例如类名、方法名或变量名等。 随着Java 发展及保证向后兼容性需求,新版本出现了可用于做标识符的局部关键字, 他们只在特定表达式或语法中做为关键字识别, 其他地方仍可作为标识符使用。

Java 总共包含53个关键字,详情如下表:

关键字类型关键字类型
abstract类、方法和变量修饰符native类、方法和变量修饰符
assert错误处理new变量引用
boolean数据类型package包定义
break程序控制结构private访问控制,私有
byte数据类型protected访问控制,保护
case程序控制结构public访问控制,公开
catch错误处理return程序控制结构
char数据类型short数据类型
class类、方法和变量修饰符static类、方法和变量修饰符
continue程序控制结构strictfp类、方法和变量修饰符
default程序控制结构super变量引用
do程序控制结构switch程序控制结构
double数据类型synchronized类、方法和变量修饰符
else程序控制结构this变量引用
enum类、方法和变量修饰符throw错误处理
extends类、方法和变量修饰符throws错误处理
final类、方法和变量修饰符transient类、方法和变量修饰符
finally错误处理try错误处理
float数据类型void变量引用
for程序控制结构volatile类、方法和变量修饰符
if程序控制结构while程序控制结构
implements类、方法和变量修饰符goto保留关键字
import包引入const保留关键字
int数据类型null特殊常量
interface类、方法和变量修饰符false特殊常量
instanceof程序控制结构true特殊常量
long数据类型

局部关键字:

关键字说明引入版本
var用于局部变量类型推断10
record 用于声明记录类12
sealed用于密封类和接口, 定义密封类或接口17
non-sealed用于密封类和接口,定义非密封类或接口17
permits用于密封类和接口,定义密封类或接口的可实现类范围17
yieldswitch 表达式值返回12
whenswitch 增强,case 扩展21

京ICP备12026520号-3