Day02 Java注释，关键字，标识符，数据类型
Day02内容：注释、标识符和关键字、数据类型
一 注释
个人理解：防止代码自己都看不懂
（一） 注释类型
1 单行注释
方法：双斜杠
/ HELLO WORLD /
//沉舟侧畔千帆过，病树前头万木春。
2 多行注释
方法：斜杠+星号+内容+星号+斜杠
/* HELLO WORLD */
/*沉舟侧畔千帆过，病树前头万木春。*/
3 文档注释（javadoc）
方法：斜杠+星号+星号+内容+星号+斜杠
/** HELLO WORLD */
/**沉舟侧畔千帆过，病树前头万木春*/
二 关键字和标识符
个人理解（针对赋值运算，其他的不太合适）：
关键字规定后续程序运行规则，就像西方起名有子承爷名的方法，东方起名有生辰八字与五行生克结合的方法。
标识符是起出来的名字，也是变量，你可以用继承法起名恰好起出来“李白”，你也可以用八字起名法起名起出来“杰克”， “李白”和“杰克”就是标识符，
而被使用继承法起名的基本上就是欧美人，八字起名法起名的基本上就是中国人，这些被起名的欧美人与中国人就是字符串值
e.g.
int age = 18//int是起名方法，age是杰克或者李白，=是起名过程，18是欧美人或者中国人
（一）关键字
| 关键字（51个） | |
|---|---|
| 数据类型 | boolean、int、long、short、byte、float、double、char、class、interface、enum、void |
| 流程控制 | if、else、do、while、for、switch、case、default、break、continue、return |
| 异常处理 | try、catch、finally、throw、throws |
| 修饰符 | public、protected、private、final、void、static、strict、abstract、transient、synchronized、volatile、native |
| 类之间的关系 | extends、implements |
| 建立以及引用实例 | this、supper、instanceof、new |
| 导包 | package、impor |
（二）标识符
标识符定义：包名、类名、方法名、参数名、变量名等，这些符号被称为标识符。
1，标识符的允许规则
（1）标识符可以由字母、数字、下划线_ 和 美元符号 $ 组成
（2） Java 区分大小写，因此 myvar 和 MyVar 是两个不同的标识符
（3）首字符之后可以是字母（AZ 或者 az）、下划线_ 、美元符号 $ 或数字的任何字符
（4）以字母开头
2，标识符的禁止规则
（1） 标识符不能以数字开头，不能是java中的关键字
（2）不可以使用关键字和保留字作为标识符，但标识符中能包含关键字和保留字
（3）标识符不能包含空格
3，标识符的具体分类
（1）包名：当由多个单词组成时，所有单词都是小写。如aaa.bbb.ccc。
（2）类名、接口名：单词的首字母大写。如XxxYyyZzz。（大驼峰命名法）
（3）变量名、方法名：由多个单词组成时，第一个单词均小写，其它单词首字母大写。如xxxYyyZzz。（小驼峰命名法，简称驼峰法）
（4）常量名：所有字母均大写。且由多个单词组成时，单词之间用下划线“_”隔开。如XXX_YYY_ZZZ。
4，标识符的分类限制性规则
（1） 包名所有字母必须小写。例如：cn.com.test
（2）类名和接口名每个单词的首字母都要大写。例如：ArrayList
（3）常量名所有的字母都大写，单词之间用下划线连接。例如：DAY_OF_MONTH
（4）变量名和方法名的第一个单词首字母小写，从第二个单词开始，每个单词首字母大写。例如：lineName、getLingNumber
（5）在程序中，应该尽量使用有意义的英文单词来定义标识符，使得程序便于阅读。例如：使用userName表示用户名，password表示密码
5，注意要点
（1） java中true、false、friendly和null不属于关键字，也不是保留字，它们只是显式常量值，但是你在程序中不能使用它们作为标识符
（2） java关键字和保留字都是小写。即null是关键字，NULL不是关键字；TRUE、FALSE也不是关键字。
（3） Java中的String是标识符
三 数据类型
（一）数据类型分类
1，整数数据类型
整数类型简称整型，用来存储整数数值，即没有小数部分的数值。它们可以是正数，也可以是负数。
整型数据根据它所占内存大小的不同，可分为 byte、short、int 和 long 4 种类型。它们具有不同的取值范围，如下表所示。
| 数据类型 | 内存空间（8位等于1字节） | 取值范围 |
|---|---|---|
| byte | 8位 | -128～127 |
| short | 16位 | -32768～32767 |
| int | 32位 | -2147483648～2147483647 |
| long | 64位 | -9223372036854775808～9223372036854775807 |
四种详解如下：
（1）int：4个字节，32位，整数类型默认是int类型，取值范围约21亿
int 有四种语法
e.g.
int x;
// 定义 int 型变量 x
int x, y;
// 同时定义 int 型变量 x, y
int x = 10, y = -5;
// 同时定义 int 型变量 x, y 并赋予初值
int x = 5 + 23;
// 定义 int 型变量 x，并赋予公式（5+23）计算结果的初值
int 型是 Java 整型值的默认数据类型。当对多个尚未定义数据类型的整数做运算时，运算的结果将默认为 int 类型
e.g.
System.out.println(15+20); // 输出35
//实际等同如下代码
int a = 15;
int b = 20;
int c = a + b;
System.out.println(c); // 输出35
（2）byte：1个字节，8位，256种状态，取值范围为【-128,127】
byte 型的定义方式与 int 型的定义方式相同
定义 byte 类型变量，
e.g.
byte a;
//定义 byte 型变量 a
byte a, b, c;
//同时定义 byte 型变量 a,b,c
byte a = 19, b = -45;
//同时定义 byte 型变量 a,b并赋予初值
（3）short：2个字节，16位，65536种状态，取值范围为【-32768,32767】
short 型的定义方式与 int 型的定义方式相同
定义 short 类型变量
e.g.
short s;
short s, t, r;
short s = 1000, t = -19;
short s = 20000 / 10;
（4）long：8个字节，64位，long类型表示long类型常量，要加L或者l，建议加L
由于 long 类型变量的取值范围比 int 类型变量的取值范围大，且属于高精度数据类型，因此在赋值时要和 int 型做出区分，需要在整数后加 L 或者 l（小写的 L）
定义 long 类型变量
e.g.
long number; // 定义 long 型变量 number
long number, rum; // 同时定义 long 型变量 number 和 rum
long number = 123456781L, rum = -987654321L; // 同时定义 long 型变量 number 和 rum 并赋予初值
long number = 123456789L * 987654321L; // 定义 long 型变量 number，并赋予公式（123456789L * 987654321L）计算结果的初值
2，小数数据类型
浮点类型简称浮点型，用来存储含有小数部分的数值。
Java 语言中浮点类型分为单精度浮点类型（float）和双精度浮点类型（double），它们具有不同的取值范围，如下表所示
| 数据类型 | 内存空间（8位等于1字节） | 取值范围 |
|---|---|---|
| float | 32位 | 1.4E-45～3.4028235E38 |
| double | 64位 | 4.9E-324～1.7976931348623157E308 |
float：4个字节，32位，单精度，能精确到6~7位，声明一个小数类型，要加F或者f，建议加F
double：8个字节，64位，双精度，能精确到15~16位，小数类型默认是double类型
在默认情况下，小数都被看作 double 型，若想使用 float 型小数，则需要在小数后面添加 F 或 f。另外，可以使用后缀 d 或 D 来明确表明这是一个 double 类型数据，但加不加 d 或 D 并没有硬性规定。而定义 float 型变量时，如果不加 F 或 f，系统会认为它是一个 double 类型数据，并出错。
定义浮点类型变量代码
e.g.
float f1 = 13.23f; // 定义 float 型变量 f1 并赋予初值 13.23
double d1 = 4562.12d; // 定义 double 型变量 d1 并赋予初值 4562.12d
double d2 = 45678.1564; // 定义 double 型变量 d2 并赋予初值 45678.1564
//注意，浮点值属于近似值，在系统中运算后的结果可能与实际有偏差。
【实例】根据身高体重计算 BMI 指数。
创建 BMIexponent 类；声明 double 型变量 height 以记录身高，单位为米；声明 int 型变量 weight 以记录体重，单位为千克；根据 BMI=体重/(身高×身高)计算 BMI 指数。
public class BMlexponent {public static void main(String[] args) {double height = 1.72; // 身高变量，单位：米int weight = 70; // 体重变量，单位：千克double exponent = weight / (height * height); // BMI计算公式System.out.println("您的身高为：" + height);System.out.println("您的体重为：" + weight);System.out.println("您的 BMI 指数为：" + exponent);System.out.print("您的体重属于：");if (exponent < 18.5) {System.out.println("体重过轻"); // 判断BMI指数是否小于18.5} else if (exponent >= 18.5 && exponent < 24.9) {System.out.println("正常范围"); // 判断BMI指数是否为18.5～24.9} else if (exponent >= 24.9 && exponent < 29.9) {System.out.println("体重过重"); // 判断BMI指数是否为24.9～29.9} else if (exponent >= 29.9) {System.out.println("肥胖"); // 判断BMI指数是否大于等于29.9}}
}
运行结果如下：
您的身高为：1.72
您的体重为：70
您的BMI指数为：23.661438615467823
您的体重属于：正常范围
3， 字符数据类型
char：2个字节，16位，字符表示Unicode（万国码）编码表中的每一个符号，每个符号使用单引号引起来，其中前128个符号和ASCII表相同
字符类型（char）用于存储单个字符，占用 16 位（两个字节）的内存空间。
在定义字符型变量时，要用单引号表示，如 's' 表示一个字符。但是 "s" 则表示一个字符串，虽然只有一个字符，但由于使用双引号，因此它仍然表示字符串，而不是字符。
使用 char 关键字可定义字符变量，其语法如下：
char x = 'a'
由于字符 a 在 Unicode 表中的排序位置是97，因此允许将上面的语句写成：
char x = 97
4，布尔数据类型
boolean：占1位，有true和false2个值，一个表示真，一个表示假，一般用于表示逻辑运算
在 Java 语言中布尔类型的值只包括 true 和 false，没有其他值，不包括 1 和 0，布尔类型的数据在开发中主要使用在逻辑判断方面，例如：如果外面在下雨，我出门带一把雨伞。如果明天休息，咱们就一出去玩耍吧。 代码如下：
public class BooleanTest1 {public static void main(String[] args) {boolean isRain = true;/*上行代码表示定义一个布尔类型的变量 isRain 来表示是否下雨了，给其赋值 true，以下的判断逻辑是如果 isRain 为 true 则输出"外面下雨了，出门要带一把雨伞哦！"，反之则输出"外面天气晴朗，走起吧！"。*/if(isRain){System.out.println("外面下雨了，出门要带一把雨伞哦！");}else{System.out.println("外面天气晴朗，走起吧！");}boolean sex = true;/*上行代码表示定义一个布尔类型的变量 sex 来表示性别，判断逻辑是如果 sex 为 true 则输出"哥们你好"，反之则输出"姐们你好"。*/if(sex){System.out.println("哥们你好");}else{System.out.println("姐们你好");}}
}
布尔类型变量的值是不可以使用true和false以外的值
public class BooleanTest2 {public static void main(String[] args) {boolean flag = 1;boolean success = 0;}
}
编译后运行结果如下
（二）数据类型转换规则
基本数据类型之间是存在固定的转换规则的，现总结出以下 6 条规则，无论是哪个程序，将这 6 个规则套用进去，问题迎刃而解：
1，如果整数型字面量没有超出 byte , short , char 的取值范围，可以直接将其赋值给 byte , short , char 类型的变量；
2，小容量向大容量转换称为自动类型转换，容量从小到大的排序为：byte < short(char) < int < long < float < double，其中 short 和 char 都占用两个字节，但是 char 可以表示更大的正整数；
3，大容量转换成小容量，称为强制类型转换，编写时必须添加 “强制类型转换符” ，但运行时可能出现精度损失，谨慎使用；
4，byte , short , char 类型混合运算时，先各自转换成 int 类型再做运算；
5，多种数据类型混合运算，各自先转换成容量最大的那一种再做运算。
6，八种基本数据类型中，除 boolean 类型不能转换，剩下七种类型之间都可以进行转换；
接下来，根据以上的 6 条规则，我们来看一下以下代码
public class TypeConversionTest {public static void main(String[] args) {byte b1 = 1000;byte b2 = 20;short s = 1000;int c = 1000;long d = c;int e = d;int f = 10 / 3;long g = 10;int h = g / 3;long m = g / 3;byte x = (byte)g / 3;short y = (short)(g / 3);short i = 10;byte j = 5;short k = i + j;int n = i + j;char cc = 'a';System.out.println("cc = " + cc);System.out.println((byte)cc);int o = cc + 100;System.out.println(o);}
}
此时编译会报错，
修改方法如下：
public class TypeConversionTest {public static void main(String[] args) {//1000 超出 byte 取值范围，不能直接赋值//byte b1 = 1000;/*如果想让上面程序编译通过，可以手动强制类型转换，但程序运行时会损失精度*/byte b1 = (byte)1000;//20 没有超出 byte 取值范围，可以直接赋值byte b2 = 20;//1000 没有超出 short 取值范围，可以直接赋值short s = 1000;//1000 本身就是 int 类型，以下程序不存在类型转换int c = 1000;//小容量赋值给大容量属于自动类型转换long d = c;//大容量无法直接赋值给小容量//int e = d;//加强制类型转换符int e = (int)d;//int 类型和 int 类型相除最后还是 int 类型，所以结果是 3int f = 10 / 3;long g = 10;/*g 是 long 类型，long 类型和 int 类型最终结果是 long 类型，无法赋值给 int 类型*///int h = g / 3;//添加强制类型转换符int h = (int)(g / 3);//long 类型赋值给 long 类型long m = g / 3;/*g 先转换成 byte，byte 和 int 运算，最后是 int 类型，无法直接赋值给 byte*///byte x = (byte)g / 3;//将以上程序的优先级修改一下byte x = (byte)(g / 3);short y = (short)(g / 3);short i = 10;byte j = 5;/*short 和 byte 运算时先各自转换成 int 再做运算，结果是 int 类型，无法赋值给 short*///short k = i + j;int n = i + j;char cc = 'a';System.out.println("cc = " + cc);//将字符型 char 转换成数字，'a'对应的 ASCII 是 97System.out.println((byte)cc);/** char 类型和 int 类型混合运算，char 类型先转换成* int 再做运算，最终 197*/int o = cc + 100;System.out.println(o);}
}
运行结果如下：
提问
一，标识符的各类包名、类名、方法名、参数名、变量名
1，是什么（举现实可以带入的例子）
2，起什么作用（同上）
二，目前已知回答（并不理解）
提问：把这些所有类型的标识符，写成一段代码，并运用我刚才所说的举例论证方法，组成一整段的举例，比如这段代码就像一辆车，包名是发动机，类名是驾驶员等等AI回答如下
-
包名 com.example.demo：
就好比是一座大型商场的地址，这座商场（包）里有各种店铺（类）。比如商场在城市的特定区域，有明确的地址才能找到它。包名也一样，能帮我们在庞大的代码项目里准确找到类的位置。像我们去商场找特定的店铺，得知道商场的地址，代码中找类就得知道包名。不同商场（包）有不同的店铺（类），这样就避免了不同地方的同名店铺（类）混淆，还能把相关的店铺（类）都集中在一个商场（包）里，管理起来更方便。 -
类名 CarApp：
这就像汽车制造公司的名字，比如“丰田”公司。这个公司（类）决定了生产出来的汽车（对象）有哪些配置（属性）和功能（方法）。丰田公司生产的汽车都有一些共同的特点和能力，就像 CarApp 类创建的对象都有 carName、color 这些属性，以及 startEngine 这样的行为。类是创建对象的模板，就像汽车制造公司是生产汽车的模板，按照这个模板生产出一辆辆具体的汽车（对象）。 -
常量名 MAX_SPEED：
类似高速公路上的限速标志，这个标志上的速度值（常量）是固定不变的。不管什么时候开车经过，这个限速值都不会变。在程序里，MAX_SPEED 也是固定的，用来表示汽车能达到的最大速度。如果高速公路的限速改了，只需要改标志上的值，同样，程序里如果要改最大速度，只需要改 MAX_SPEED 定义的地方就行，方便又能保证程序里这个值的一致性。 -
枚举名 CarColor：
就像手机应用里选择汽车颜色的下拉菜单选项。这个菜单（枚举）里列出了所有可以选的颜色，用户只能从这些选项里选，不能输入别的颜色。在程序里，CarColor 枚举限定了汽车颜色的取值范围，只能是 RED、BLUE、GREEN 这些选项，避免出现不合法的颜色值。就像我们在应用里选颜色不会选到菜单外不存在的颜色一样，程序里也不会给汽车设置不合法的颜色。 -
接口名 Driveable：
如同汽车驾驶资格证书，有这个证书（实现接口）的人（类）才有资格开车（实现接口方法）。不同的人（类）开车的方式（接口方法的实现）可能不一样，但都得有这个证书（实现接口）才行。在程序里，实现 Driveable 接口的类就必须实现 drive 方法，这样就规定了这些类都有“驾驶”的能力，就像有驾驶资格证书的人都能开车一样，而且不同的类实现 drive 方法可以有不同的方式，实现了多态性。 -
变量名 carName 和 color：
carName 类似汽车的车牌，车牌能标识出每一辆车叫什么名字，在程序里 carName 变量用来存汽车的名字，方便我们识别和操作。color 就像汽车的外观颜色，不同颜色的车看起来不一样，程序里 color 变量存着汽车的颜色，我们可以根据这个颜色做一些判断或展示，比如不同颜色的车有不同的保养策略等。 -
方法名 startEngine：
好比汽车上的“启动发动机”按钮，按下这个按钮（调用方法），汽车就会执行启动发动机的操作。在程序里，调用 startEngine 方法，就会执行方法里的代码，输出发动机启动的提示信息。这个方法把发动机启动的操作封装起来，就像按钮把启动发动机的复杂操作封装起来一样，我们只需要按按钮（调用方法）就行，不用管具体的启动细节，而且这个方法还可以在不同的地方被复用，就像按钮可以被多次按下一样。 -
变量名 myCar：
这就像你拥有的一辆实际的汽车，你可以通过这辆车（变量引用）来操作它的各种功能（访问类的属性和方法）。比如你可以开这辆车（调用方法），查看它的外观（访问属性）。在程序里，myCar 是 CarApp 类的一个对象实例的引用，通过 myCar 可以访问 CarApp 类里的 carName、color 属性，也能调用 startEngine 等方法。 -
匿名内部类引用名 driver：
类似于临时聘请的一位驾驶员，这位驾驶员（匿名内部类）有驾驶的能力（实现了 Driveable 接口的 drive 方法）。你雇佣这位驾驶员（创建匿名内部类实例并赋值给 driver 变量），然后让他开车（通过 driver 调用 drive 方法）。在程序里，当我们只需要临时实现一个接口的功能时，用匿名内部类很方便，不需要专门去定义一个完整的类，就像临时雇佣驾驶员，不需要长期雇佣一个固定的驾驶员一样，很灵活。
package com.example.demo; // 包名public class CarApp { // 类名public static final int MAX_SPEED = 200; // 常量名public enum CarColor { // 枚举名RED,BLUE,GREEN}public interface Driveable { // 接口名void drive();}private String carName; // 变量名private CarColor color;public CarApp(String carName, CarColor color) {this.carName = carName;this.color = color;}public void startEngine() { // 方法名System.out.println(carName + " 的发动机启动了");}public static void main(String[] args) {CarApp myCar = new CarApp("宝马X5", CarColor.BLUE); // 变量名 myCarmyCar.startEngine();Driveable driver = new Driveable() { // 匿名内部类引用名 driver@Overridepublic void drive() {System.out.println("驾驶员驾驶着 " + myCar.carName + " 行驶在路上");}};driver.drive();}
}
二次提问这段代码跑下来有啥作用AI解释如下
package com.example.demo; public class CarApp { public static final int MAX_SPEED = 200; public enum CarColor { RED,BLUE,GREEN}public interface Driveable { void drive();}private String carName; private CarColor color;public CarApp(String carName, CarColor color) {this.carName = carName;this.color = color;}public void startEngine() { System.out.println(carName + " 的发动机启动了");}public static void main(String[] args) {CarApp myCar = new CarApp("宝马X5", CarColor.BLUE); myCar.startEngine();Driveable driver = new Driveable() { @Overridepublic void drive() {System.out.println("驾驶员驾驶着 " + myCar.carName + " 行驶在路上");}};driver.drive();}
}
运行这段代码有以下作用：
-
创建对象并初始化属性：在 main 方法中，通过 CarApp myCar = new CarApp("宝马X5", CarColor.BLUE); 创建了一个 CarApp 类的实例 myCar，并为其属性 carName 赋值为 “宝马X5”，color 赋值为 CarColor.BLUE（蓝色） 。这模拟了创建一辆具体的汽车，并设定了它的名称和颜色。
-
启动发动机模拟：调用 myCar.startEngine(); 方法，输出 “宝马X5 的发动机启动了”，这模拟了汽车启动发动机的操作，展示了对象调用方法的过程。
-
驾驶模拟：通过匿名内部类实现了 Driveable 接口，创建了 driver 实例，并实现了 drive 方法。当调用 driver.drive(); 时，输出 “驾驶员驾驶着 宝马X5 行驶在路上”，模拟了驾驶员驾驶汽车行驶的过程。
-
展示类、接口、枚举等概念的使用：这段代码展示了如何定义类、接口、枚举，以及如何在类中使用常量、变量和方法。同时展示了如何通过接口实现多态性（虽然这里是简单的匿名内部类实现接口），体现了 Java 中面向对象编程的一些基本概念和特性。
-
体现包的组织作用：package com.example.demo; 声明了该类所在的包，虽然在这段简单代码中包的实际作用不太明显，但在大型项目中，包可以帮助组织和管理大量的类，避免类名冲突，使项目结构更加清晰。
总体来说，这段代码是一个简单的面向对象编程示例，用于演示 Java 中类、对象、接口、枚举等基本概念的使用，以及它们之间的交互和协作。
