javaSE学习笔记02-注释、关键字、标识符、数据类型、类型转换
注释
java里注释分为哪几种；
//单行注释
/*
多行注释
*/
/**JavaDoc
* 文档注释
*/
//注释并不会被执行，是给我们写代码的人看的
//平时写代码注意规范
关键字
Java 关键字是 Java 语言中预定义的、具有特殊含义的保留字，不能用作标识符（如变量名、类名、方法名等）。以下是 Java 的关键字列表：
1. 基本数据类型关键字
这些关键字用于声明变量或定义方法返回值的数据类型。
-
byte：8 位有符号整数。 -
short：16 位有符号整数。 -
int：32 位有符号整数。 -
long：64 位有符号整数。 -
float：32 位单精度浮点数。 -
double：64 位双精度浮点数。 -
char：16 位 Unicode 字符。 -
boolean：布尔类型，取值为true或false。示例：int age = 25; double salary = 5000.50; boolean isStudent = true;
2. 流程控制关键字
这些关键字用于控制程序的执行流程。
-
if：条件判断语句。 -
else：与if配合使用，表示条件不成立时执行的代码块。 -
switch：多分支选择语句。 -
case：与switch配合使用，表示一个分支。 -
default：与switch配合使用，表示默认分支。 -
while：循环语句，条件为真时重复执行。 -
do：与while配合使用，先执行一次循环体，再判断条件。 -
for：循环语句，通常用于遍历数组或集合。 -
break：跳出循环或switch语句。 -
continue：跳过当前循环的剩余代码，进入下一次循环。 -
return：从方法中返回值并结束方法。示例：if (age > 18) { System.out.println("You are an adult."); } else { System.out.println("You are a minor."); } for (int i = 0; i < 10; i++) { System.out.println(i); }3. 类和对象关键字
这些关键字用于定义类、接口、继承关系以及创建对象。
-
class：定义一个类。 -
interface：定义一个接口。 -
extends：表示类继承另一个类。 -
implements：表示类实现一个接口。 -
new：创建对象。 -
this：引用当前对象。 -
super：引用父类的对象或构造函数。 -
instanceof：检查对象是否是某个类的实例。示例：class Animal {} class Dog extends Animal { Dog() { super(); // 调用父类的构造函数 } } Animal myDog = new Dog(); if (myDog instanceof Dog) { System.out.println("It's a dog!"); }4. 访问控制关键字
这些关键字用于控制类、方法、变量的访问权限。
-
public：公开访问，任何类都可以访问。 -
protected：受保护访问，只有子类或同一包中的类可以访问。 -
private：私有访问，只有本类可以访问。示例：public class MyClass { private int secret = 123; public void display() { System.out.println(secret); } }5. 修饰符关键字
这些关键字用于修饰类、方法或变量的行为。
-
static：表示类级别的成员（静态成员）。 -
final：表示不可修改的常量或不可继承的类。 -
abstract：表示抽象类或抽象方法。 -
synchronized：表示同步方法或代码块，用于多线程。 -
transient：表示变量不会被序列化。 -
volatile：表示变量在多线程中可见。 -
native：表示方法由本地代码（如 C/C++）实现。 -
strictfp：表示浮点数计算严格遵守 IEEE 754 标准。示例：public static final double PI = 3.14; public abstract void draw();6. 异常处理关键字
这些关键字用于处理程序中的异常。
-
try：尝试执行可能抛出异常的代码。 -
catch：捕获并处理异常。 -
finally：无论是否发生异常，都会执行的代码块。 -
throw：手动抛出异常。 -
throws：声明方法可能抛出的异常。示例：try { int result = 10 / 0; } catch (ArithmeticException e) { System.out.println("Cannot divide by zero!"); } finally { System.out.println("This will always run."); }7. 包相关关键字
这些关键字用于管理 Java 包。
-
package：定义类所属的包。 -
import：导入其他包中的类。示例：package com.example; import java.util.ArrayList;8. 其他关键字
-
void：表示方法没有返回值。 -
enum：定义枚举类型。 -
assert：用于调试，检查条件是否为真。 -
const：保留字，未使用。 -
goto：保留字，未使用。示例：public void printMessage() { System.out.println("Hello, World!"); }9. 字面值
虽然不是关键字，但有特殊含义，不能用作标识符。
-
true：布尔值真。 -
false：布尔值假。 -
null：表示空引用。
标识符
包名：使用小写字母
类名和接口名：由具有含义的单词组成，单词首字母大写，如：HelloWorld
方法名：由具有含义的单词组成，首字母小写，其他首字母大写，如：numberSum
变量名：成员变量和方法相同，局部变量全部使用小写
常量名：全部使用大写，多个单词组成用下划线连接，如：VALUE_HELLO
1.标识符注意要点:所有的标识符都应该以字母(A-Z或
者a-z),美元符($),或者下划线(_)开始
2.首字符之后可以是字母(A-Z或者a-z),美元符($),下划线(_)或数字的任何字符组合
3.不能使用关键字作为变量名或方法名
4.标识符是大小写敏感的，严格区分大小写
5.合法的标识符举例: age、$salary、_value_、_1_value
6.非法的标识符举例:123abc、-salary、#abc等
7.标识符可以是中文、拼音，不建议这样做
用java编写第一个程序代码，输出“Hello，World！”
package com.chao.base;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello,World!");
}
}
//单行注释
/*
多行注释
*/
/**JavaDoc
* 文档注释
*/
//注释并不会被执行，是给我们写代码的人看的
//平时写代码注意规范
/*
1.标识符注意要点:所有的标识符都应该以字母(A-Z或者a-z),美元符($),或者下划线(_)开始
2.首字符之后可以是字母(A-Z或者a-z),美元符($),下划线(_)或数字的任何字符组合
3.不能使用关键字作为变量名或方法名
4.标识符是大小写敏感的
5.合法的标识符举例: age、$salary、_value_、_1_value
6.非法的标识符举例:123abc、-salary、#abc等
6.标识符可以是中文、拼音，不建议这样做，很low（代码编写的不美观，让别人觉得水平低下）
*/基本数据类型
在 Java 中，数据类型分为基本数据类型（8种）和引用类型（3种），基本数据类型（Primitive Data Types） 是编程中最基础的数据类型，它们不是对象，而是直接存储在栈内存中的简单数据。Java 提供了 8 种基本数据类型，分为以下四类：
1. 整数类型（4）
用于存储整数值，包括以下四种：
| 数据类型 | 大小（字节） | 取值范围 | 默认值 |
|---|---|---|---|
byte |
1 | -128 到 127 | 0 |
short |
2 | -32,768 到 32,767 | 0 |
int |
4 | -2³¹ 到 2³¹-1（约 -21 亿到 21 亿） | 0 |
long |
8 | -2⁶³ 到 2⁶³-1（约 -922 亿亿到 922 亿亿） | 0L |
2. 浮点类型（2）
用于存储小数值，包括以下两种：
| 数据类型 | 大小（字节） | 取值范围 | 默认值 |
|---|---|---|---|
float |
4 | 约 ±3.4e-38 到 ±3.4e38，精度为 6-7 位小数 | 0.0f |
double |
8 | 约 ±1.7e-308 到 ±1.7e308，精度为 15 位小数 | 0.0d |
3. 字符类型（1)
用于存储单个字符，使用 Unicode 编码。
| 数据类型 | 大小（字节） | 取值范围 | 默认值 |
|---|---|---|---|
char |
2 | 0 到 65,535（\u0000 到 \uffff） | '\u0000'（空字符） |
4. 布尔类型 (1)
用于存储逻辑值，只有两个可能的值：true 或 false。
| 数据类型 | 大小（字节） | 取值范围 | 默认值 |
|---|---|---|---|
boolean |
1（实际大小取决于 JVM 实现） | true 或 false |
false |
5. 默认值
在 Java 中，如果类的成员变量是基本数据类型，它们会被赋予默认值；而局部变量则不会被自动初始化，必须显式赋值。
| 数据类型 | 默认值 |
|---|---|
byte |
0 |
short |
0 |
int |
0 |
long |
0L |
float |
0.0f |
double |
0.0d |
char |
'\u0000' |
boolean |
false |
6. 注意事项
-
范围问题：使用基本数据类型时，需要注意其取值范围。例如，
byte类型的值不能超过 127，否则会溢出。示例：-
byte b = 128; // 错误：超出 byte 的范围
-
2.精度问题：
浮点类型（float 和 double）在计算时可能存在精度丢失问题。示例：
double d = 0.1 + 0.2; // 结果可能是 0.300000000000000043.自动类型转换：
小范围类型可以自动转换为大范围类型（如 int 转 long），但大范围类型转换为小范围类型时需要强制类型转换。示例：
int i = 100;
long l = i; // 自动转换
byte b = (byte) i; // 强制转换4.包装类：
Java 为每种基本数据类型提供了对应的包装类（如 Integer、Double 等），用于将基本数据类型转换为对象。示例：
int i = 10;
Integer integer = Integer.valueOf(i); // 基本类型转包装类
int j = integer.intValue(); // 包装类转基本类型基本数据类型如下代码：
package JO;
public class Jibenshujuleixing {
public static void main(String[] args) {
//八大基本数据类型
//常用--整数类型：int，byte，short，long
int num1 = 10;
byte num2 = 20;
short num3 = 30;
long num4 = 30L; //long类型要在数字后面加L
System.out.println("数字num1=" + num1);
System.out.println("数字num2=" + num2);
System.out.println("数字num3=" + num3);
System.out.println("数字num4=" + num4);
//小数，浮点数
float num5 = 50.1F; //float要在数字后加F
double num6 = 3.1415926;
System.out.println("浮点数num5=" + num5);
System.out.println("小数num6=" + num6);
//字符
char name = 'A'; //只能一个字符一个字符的放， 用 ' ' 单引号
//char name = '无言';是错误的写法
//字符串，String不是关键字，而是类，字符串不是基本数据类型
String name1 = "无言"; //String可以放多个字符，用 " " 双引号
System.out.println("字符name=" + name);
System.out.println("字符串name1=" + name1);
//布尔值：是非，只有true 和 false两个
boolean x = true;
boolean y = false;
System.out.println("x=" + x);
System.out.println("y=" + y);
}
}
整数拓展（进制）、浮点数拓展、字符拓展、转义字符、布尔值拓展等；
注意：定义八进制整数时候必须在该数的前面加一个0，定义十六进制的时候在数前面加0X或0x
练习代码：
package com.chao.base;
public class Demo02 {
public static void main(String[] args) {
//整数拓展： 进制 二进制0b 十进制 八进制0 十六进制0x
int i = 10;
int i1 = 010;//八进制0，0-7
int i2 = 0x10;//十六进制0x 0~9 A~F 16
System.out.println(i);
System.out.println(i1);
System.out.println(i2);
/*
输出结果:10 8 16
*/
//浮点数拓展 float 有限 离散 舍入误差 大约 接近但不等于
//double
//最好完全使用浮点数进行比较
System.out.println("------------------");
float a = 0.1f;//0.1
double b = 1.0 / 10;//0.1
System.out.println(a == b);//输出结果：false，即a不等于b
float x = 204567890f;
float y = x + 1;
System.out.println(x == y);//输出结果：true，但实际x和y不相等
float f=1.23f;//定义一个单精度浮点类型，将f去掉，就会报错
double d1=1.23;//定义一个不带后缀的双精度浮点类型，双精度，是否有后缀对结果没有影响
double d2=1.23D;//定义一个带后缀的双精度浮点类型
System.out.println("单精度浮点类型数值等于" + f);//输出结果1.23
System.out.println("双精度浮点类型数值等于" + d1);//输出结果1.23
System.out.println("双精度浮点类型数值等于" + d2);//输出结果1.23
//字符拓展
System.out.println("------------------");
char c1 = 'a';
char c2 = '中';
char c3 = '\u0061';
System.out.println(c1);//输出结果：a
System.out.println(c2);//输出结果：中
System.out.println((int) c2);//强制类型转换，输出结果：20013
System.out.println(c3);//输出结果：a，即''
//所有的字符本质还是数字
//编码 Unicode 表： （65=A a=97）
char c4='A';//定义一个char 类型
int j=c4+1;//char 类型和int 类型计算
char c5=(char)j;//进行强制类型转换
System.out.println("int 强制类型转后为char 后的值等于" + c5);//输出c5的值为B
//转义字符
//\t 制表符 \'单引号 \"双引号 \\斜杠 \r回车
//\n 换行 \f跳页 \b退格
System.out.println("------------------");
System.out.println("Hello\tWorld");//输出结果Hello world
System.out.println("Hello\nWorld");
System.out.println("\'");//输出'
System.out.println("\"");//输出"
System.out.println("\\");//输出\
System.out.println("\r");
System.out.println("\f");
System.out.println("\b");
String sa = new String("Hello,World");
String sb = new String("Hello,World");
System.out.println(sa == sb);//输出结果false
String sc = "Hello,World";
String sd = "Hello,World";
System.out.println(sc == sd);//输出结果true
//布尔值扩展
boolean flag = true;
//新手写代码
// if (flag==true){ //新手写代码
// }
//老手写代码，两个作用是一样的，代码要精简易读
if (flag) {
}
//自动类型转换
short s=3;//定义一个 short 类型变量
int i3=s;//short 自动类型转换为 int
float f1=1.0f;//定义一个 float 类型变量
double d3=f1;//float 自动类型转换为 double
long l=234L;//定义一个 long 类型变量
double d4=l;//long 自动类型转换为 double
System.out.println("short 自动类型转换为 int 后的值等于" + i3);//输出i3的值为3
System.out.println("float 自动类型转换为 double 后的值等于" + d3);//输出d3的值为1.0
System.out.println("long 自动类型转换为 double 后的值等于" + d4);//输出d4的值为234.0
//整数转浮点数会产生误差，因为计算机内部是没有浮点数的，浮点数是靠整数模拟出来的
int i4=234234234;//定义一个int 类型变量
float d=i4;//int 自动类型转换为double
System.out.println("int 自动类型转换为float 后的值等于" + d);//输出d的值为2.3423424E8
//强制转换
int i5=123;//定义一个int 类型
byte b1=(byte)i5;//强制类型转换为byte
System.out.println("int 强制类型转换byte 后值等于" + b1);//输出结果b1为123
int i6=128;//定义一个int 类型
byte b2=(byte)i6;//强制类型转换为byte
System.out.println("int 强制类型转换byte 后值等于" + b2);
/*
输出b2的值为-128，发生了数据丢失情况，因为int转byte，采用截取的方式进行转换，计算机是由二进制表示的
*/
double d5=123.456;//定义一个double 类型
int i7=(int)d5;//强制类型转换为int
System.out.println("double 强制类型转换int 后值等于" + i7);//输出i7的值为123，浮点数强制转为整数，会丢失小数部分
byte b3 = 123;//隐含强制类型转换，123这个数据是int类型，Java系统自动完成转换，不由程序来完成
System.out.println("123 强制转换为byte 后值等于" + b3);
}
}
package com.chao.base;
public class Demo01 {
/*
Java数据类型
两大类:基本数据类型和引用类型
1.基本数据类型共8种:
(1)数值类型分为:
整数类型(4种):
a.byte(字节型)，占1个字节，取值范围（-128~127）
b.short(短整型)，占2个字节，取值范围（-32768~32767）
c.int(整型)，占4个字节，取值范围（-2147483648~2147483647）
d.long(长整型)，占8个字节，取值范围（-9223372036854775808~9223372036854775807）
浮点类型(2种）:
e.float(单精度浮点型),占4个字节
f.double(双精度浮点型)，占8个字节
字符类型(1种):
g.char(字符类型)，占2个字节
(2)boolean类型（布尔类型）:占1位，值只有true和false两种
2.引用类型3种:类、接口、数组
*/
//
public static void main(String[] args) {
}
}
类型转换
在 Java 中，类型转换是将一种数据类型的值转换为另一种数据类型的过程。Java 中的类型转换分为两种：自动转换（隐式类型转换）和强制转换（显式类型转换）
自动转换
规则：
-
从小范围类型向大范围类型转换。
-
例如：
byte -> short -> int -> long -> float -> double。示例：int a = 10; double b = a; // 自动将 int 转换为 double System.out.println(b); // 输出 10.0
强制转换
强制转换是指程序员手动将一种数据类型转换为另一种数据类型，通常发生在以下情况：
-
目标类型比源类型范围更小。
-
转换可能导致数据丢失或精度损失。
语法：
目标类型 变量名 = (目标类型) 源数据;示例：
double a = 10.5;
int b = (int) a; // 强制将 double 转换为 int
System.out.println(b); // 输出 10（小数部分丢失）类型转换的注意事项
(1) 数据丢失
当从大范围类型向小范围类型转换时，可能会导致数据丢失或精度损失。
示例：
int a = 128;
byte b = (byte) a; // byte 的范围是 -128 到 127
System.out.println(b); // 输出 -128（数据溢出）(2) 布尔类型不能转换
Java 中的 boolean 类型不能与其他任何类型进行转换。
错误示例：
boolean flag = true;
int a = (int) flag; // 编译错误(3) 字符串与基本类型的转换
-
字符串转基本类型：使用包装类的
parseXxx()方法。 -
基本类型转字符串：使用
String.valueOf()或直接拼接。示例：// 字符串转基本类型 String str = "123"; int num = Integer.parseInt(str); // 字符串转 int double d = Double.parseDouble(str); // 字符串转 double // 基本类型转字符串 int a = 100; String s1 = String.valueOf(a); // int 转字符串 String s2 = a + ""; // 直接拼接
对象类型转换
在 Java 中，对象类型之间也可以进行类型转换，通常发生在继承关系中。
(1) 向上转型（Upcasting）
将子类对象赋值给父类引用，是自动转换（隐式转换）。
示例：
class Animal {}
class Dog extends Animal {}
Animal myDog = new Dog(); // 向上转型(2) 向下转型（Downcasting）
将父类对象赋值给子类引用，需要强制转换（显式转换）。
示例：
Animal myAnimal = new Dog();
Dog myDog = (Dog) myAnimal; // 向下转型(3) 类型检查
向下转型时，如果对象不是目标类型，会抛出 ClassCastException。可以使用 instanceof 进行检查。
示例：
if (myAnimal instanceof Dog) {
Dog myDog = (Dog) myAnimal; // 安全转换
}总结
-
自动类型（隐式类型）转换：自动完成，适用于从小范围类型向大范围类型转换。
-
强制类型（显式类型）转换：手动完成，适用于从大范围类型向小范围类型转换，可能导致数据丢失。
-
对象类型转换：向上转型是隐式的，向下转型需要显式转换，并使用
instanceof进行检查。
练习代码
package com.chao.base;
public class Demo03 {
public static void main(String[] args) {
int i = 128;
byte b = (byte)i;//内存溢出
double d = i;
//强制转换 （类型）变量名 高-->低 例:int转byte，int转short，int转char等
//自动转换 低-->高 例:int转double，byte转int，float转double等
System.out.println(b);//输出-128
System.out.println(i);//输出128
System.out.println(d);//输出128.0
/*
注意点:
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换到低容量的时候，强制转换
4.转换的时候可能存在内存溢出，或者精度问题
*/
System.out.println("-------");
System.out.println((int)23.7);//输出23
System.out.println((int)-45.89f);//输出-45
System.out.println("------");
char c = 'a';
int e = c + 1;
float f = -12.6f;
double db = f + 1;
System.out.println(e);//输出98
System.out.println((char)e);//输出b，在编码中，97是a，98是b
System.out.println(db);//输出-11.600000381469727
System.out.println((float)db);//输出-11.6
}
}
package com.chao.base;
public class Demo04 {
public static void main(String[] args) {
//操作比较大的数的时候，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割
int money = 10_000_00000;
int years = 20;
int total1 = money*years;//-147483480,计算的时候溢出了
long total2 = money*years;// 默认是int，转换之前已经存在问题了？
long total3 = money*((long)years);//先把一个数转换为long
System.out.println(total3);
}
}
浙公网安备 33010602011771号