【JavaSE】初识JAVA（注释、标识符、关键字、数据类型、变量、字符串、运算符）
一、初识Java
1.Java的main方法
示例：
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello,world!");
}
}
如上就是一个最简单的Java程序，Java的main方法应该是当前主流编程中最长的。通过上述代码，我们看到了一个完整的Java程序的结构。
Java程序的结构由以下三部分组成：
1.源文件（扩展名为*.java）:源文件带有类的定义。类用来表示程序的一个组件。类的内容必须包括在花括号中。
2.类：类中带有一个或多个方法。方法必须在类的内部声明。
3.方法：在方法的花括号中编写方法应该执行的语句。
总结一下：类存在于源文件里面；方法存在于类中；语句存在于方法中。
注意：在一个源文件中只能有一个public修饰的类，而且源文件名字必须与public修饰的类名字相同。
2.运行Java程序
Java是一门半编译型、半解释型语言。先通过javac编译程序把源文件进行编译，编译后生成的.class文件是由字节
码组成的平台无关、面向JVM的文件。最后启动java虚拟机来运行.class文件，此时JVM会将字节码转换成平台能够
理解的形式来运行。
1.使用记事本或者IDEA（集成开发环境）编写Java程序
2.使用javac.exe编译器编译Java源程序，生成xxx.class的字节码文件 语法格式为： javac xxx.java
3.使用java运行xxx.class字节码文件 语法格式： java xxx
【注意】在运行Java程序前，必须先安装好JDK(Java Development Kit即Java开发工具包)，JDK里面就包含了javac和java工具，Java程序最终是在JVM(Java虚拟机)中运行的。
那么JDK、JRE、JVM之间的关系？
*JDK(Java Development Kit):Java开发工具包，提供给Java程序员使用，包含了JRE，同时还包含了编译器javac与自带的调试工具Jconsole、jstack等。
*JRE(Java Runtime Environment):Java运行时环境，包含了JVM，Java基础类库。是使用Java语言编写程 序运行的所需环境。
*JVM：Java虚拟机，运行Java代码。
编写和运行第一个Java程序时，可能会遇到的一些错误：
1. 源文件名后缀不是.java
2. 类名与文件名不一致
3. main方法名字写错：mian
4. 类没有使用public修饰
5. 方法中语句没有以分号结尾
6. 中文格式的分号
7. JDK环境没有配置好，操作系统不能识别javac或者java命令
3.注释
注释是为了让代码更容易被读懂而附加的描述信息. 不参与编译运行, 但是却非常重要。 Java中的注释主要分为以下三种：
单行注释：// 注释内容（用的最多）
多行注释：/ 注释内容/（不推荐）
文档注释： /* 文档注释*/（常见于方法和类之上描述方法和类的作用)，可以被javadoc工具解析，生成一套以网页文件形式体现的程序说明文档
注意：
- 多行注释不能嵌套使用
- 不论是单行还是多行注释，都不参与编译，即编译之后生成的.class文件中不包含注释信息。
4.标识符
在上述程序中，Test称为类名，main称为方法名，也可以将其称为标识符，即：在程序中由用户给类名、方法名或者变量所取的名字。
【硬性规则】
标识符中可以包含：字母、数字以及 下划线和 $ 符号等等。
注意：标识符不能以数字开头，也不能是关键字，且严格区分大小写。
【软性建议】
类名：每个单词的首字母大写(大驼峰)。
方法名：首字母小写，后面每个单词的首字母大写(小驼峰)。
变量名：与方法名规则相同。
5.关键字
通过观察上述程序可以发现，public、class以及static等颜色会发生变化，将这些具有特殊含义的标识符称为关键字。即：关键字是由Java语言提前定义好的，有特殊含义的标识符，或者保留字。
注意：用户不能使用关键字定义标识符
用于定义访问权限修饰符的关键字： private、protected、public
用于定义类、函数、变量修饰符的关键字：abstract、final、static、synchronized
用于定义类与类之间关系的关键字： extends、implements
用于异常处理的关键字：try、catch、finally、throw、throws
用于包的关键字：package、import
其他修饰符关键字：native、strictfp、transient、volatile、assert
二、数据类型与变量
1.字面常量
在上面出现的程序中， System.Out.println("Hello World")； 语句，不论程序何时运行，输出的都是Hello World，其实"Hello World"就是字面常量。
常量即程序运行期间，固定不变的量称为常量
public class Demo{
public static void main(String[] args){
System.Out.println("hello world!");
System.Out.println(100);
System.Out.println(3.14);
System.Out.println('A');
System.Out.println(true);
System.Out.println(false);
}
}
其中：100、3.14、‘A’、true/false都是常量，将其称为字面常量。
字面常量的分类：
- 字符串常量：由""括起来的，比如“12345”、“hello”、“你好”。
- 整形常量：程序中直接写的数字(注意没有小数点)，比如：100、1000
- 浮点数常量：程序中直接写的小数，比如：3.14、0.49
- 字符常量：由 单引号 括起来的当个字符，比如：‘A’、‘1’
- 布尔常量：只有两种true和false
- 空常量：null
【注意】： 字符串、整形、浮点型、字符型以及布尔型，在Java中都称为数据类型。
2.数据类型
在Java中数据类型主要分为两类：基本数据类型和引用数据类型。
基本数据类型有四类八种：
- 四类：整型、浮点型、字符型以及布尔型
- 八种：
【注意】：
·不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节
·整形和浮点型都是带有符号的
·整型默认为int型，浮点型默认为double
·字符串属于引用类型
什么是字节？
字节是计算机中表示空间大小的基本单位。 计算机使用二进制表示数据。我们认为 8 个二进制位(bit) 为一个字节(Byte).
我们平时的计算机为 8GB 内存, 意思是 8G 个字节。
3.变量
3.1变量概念
在程序中，除了有始终不变的常量外，有些内容可能会经常改变，比如：人的年龄、身高、成绩分数、数学函数的计算结果等，对于这些经常改变的内容，在Java程序中，称为变量，而数据类型就是用来定义不同种类变量的。
3.2 语法格式
定义变量的语法格式为：
数据类型 变量名 = 初始值;
比如：
int a = 10; // 定义整形变量a，a是变量名也称为标识符，该变量中放置的值为10
double d = 3.14;
char c = 'A';
boolean b = true;
System.Out.println(a);
System.Out.println(d);
System.Out.println(c);
System.Out.println(b);
a = 100; // a是变量，a中的值是可以修改的，注意：= 在java中表示赋值，即将100交给a，a中保存的值就是100
System.Out.println(a);
// 注意：在一行可以定义多个相同类型的变量
int a1 = 10, a2 = 20, a3 = 30;
System.Out.println(a1);
System.Out.println(a2);
System.Out.println(a3);
3.3 整型变量
3.3.1 整型变量
// 方式一：在定义时给出初始值
int a = 10;
System.Out.println(a);
// 方式二：在定义时没有给初始值，但使用前必须设置初值
int b;
b = 10;
System.Out.println(b);
// 使用方式二定义后，在使用前如果没有赋值，则编译期间会报错
int c;
System.Out.println(c);
c = 100;
// int型变量所能表示的范围：
System.Out.println(Integer.MIN_VALUE);
System.Out.println(Integer.MAX_VALUE);
// 注意：在定义int性变量时，所赋值不能超过int的范围
int d = 12345678901234; // 编译时报错，初值超过了int的范围
【注意事项】：
- int不论在何种系统下都是4个字节
- 推荐使用方式一定义，如果没有合适的初始值，可以设置为0
- 在给变量设置初始值时，值不能超过int的表示范围，否则会导致溢出
- 变量在使用之前必须要赋初值，否则编译报错
- int的包装类型为 Integer
3.3.2 长整型变量
int a = 10;
long b = 10; // long定义的长整型变量
long c = 10L; // 为了区分int和long类型，一般建议：long类型变量的初始值之后加L或者l
long d = 10l; // 一般更加以加大写L，因为小写l与1不好区分
// long型变量所能表示的范围：这个数据范围远超过 int 的表示范围. 足够绝大部分的工程场景使用.
System.Out.println(Long.MIN_VALUE);
System.Out.println(Long.MAX_VALUE);
【注意事项】：
- 长整型变量的初始值后加L或者l，推荐加L
- 长整型不论在那个系统下都占8个字节
- 长整型的表示范围为：-263~263-1
- long的包装类型为Long
3.3.3 短整型变量
short a = 10;
System.Out.println(a);
// short型变量所能表示的范围：
System.Out.println(Short.MIN_VALUE);
System.Out.println(Short.MAX_VALUE);
【注意事项】：
- short在任何系统下都占2个字节
- short的表示范围为：-32768 ~ 32767
- 使用时注意不要超过范围(一般使用比较少)
- short的包装类型为Short
3.3.3 字节型变量
byte b = 10;
System.Out.println(b);
// byte型变量所能表示的范围：
System.Out.println(Byte.MIN_VALUE);
System.Out.println(Byte.MAX_VALUE);
【注意事项】：
- byte在任何系统下都占1个字节
- byte的范围是：-128 ~ 127
- 字节的包装类型为Byte
3.4 浮点型变量
3.4.1 双精度浮点型
double d = 3.14;
System.Out.println(d);
关于double的两个注意点：
这里输出的是int/int的结果，还是int，所以会忽略小数部分。
所有语言都是使用二进制的0 1这种整数来模拟小数的实现，在某些特定的小数中，可能会出现错误数据（精度问题）。
解决方法：使用JDK提供的BigDecimal类
BigDecimal b1 = BigDecimal.valueOf(1.1);
BigDecimal b2 = BigDecimal.valueOf(1.1);
System.out.println(b1.multiply(b2));
System.out.println(a*b);
3.4.2 单精度浮点型
float num = 1.0f; // 写作 1.0F 也可以
System.out.println(num);
float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小,
一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 float. float的包装类型为Float。
3.5 字符型变量
char c1 = 'A'; // 大写字母
char c2 = '1'; // 数字字符
System.out.println(c1);
System.out.println(c2);
// 注意：java中的字符可以存放整形
char c3 = '帅';
System.out.println(c3);
【注意事项:】
- Java 中使用
单引号 + 单个字母的形式表示字符字面值。- 计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文。
- char的包装类型为Character。
3.6 布尔型变量
布尔类型常用来表示真假。
boolean b = true;
System.out.println(b);
b = false;
System.out.println(b);
【注意事项】
- boolean 类型的变量只有两种取值, true 表示真, false 表示假。
- Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法。
boolean value = true;
System.out.println(value + 1);
// 代码编译会出现如下错误
Test.java:4: 错误: 二元运算符 '+' 的操作数类型错误
System.out.println(value + 1);
^
第一个类型: boolean
第二个类型: int
1 个错误
- Java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令，在 Oracle公司的虚拟机实现中，boolean占1个字节。
- boolean的包装类型为Boolean。
3.7 类型转换
在Java中，当参与运算数据类型不一致时，就会进行类型转换。Java中类型转换主要分为两类：自动类型转换(隐 式) 和强制类型转换(显式)。
该部分内容详见我的另一篇文章：
JavaSE中的两种数据类型转换
3.8 类型提升
不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。
- int与long之间：int会被提升为long
int a = 10;
long b = 20;
int c = a + b; // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long
- byte与byte的运算
byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
// 编译报错
Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte c = a + b;
^
结论: byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误。
由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short这种低于 4 个字节的类型, 会先提升成 int, 再参与计算
正确的写法:
byte a = 10;
byte b = 20;
byte c = (byte)(a + b);
System.out.println(c)；
【类型提升小结:】
- 不同类型的数据混合运算, 范围小的会提升成范围大的。
- 对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算。
4.字符串类型
在Java中使用String类定义字符串类型，比如：
public static void main(String[] args) {
String s1 = "hello";
String s2 = " world";
System.out.println(s1);
System.out.println(s2);
System.out.println(s1+s2); // s1+s2表示：将s1和s2进行拼接
}
在有些情况下，需要将字符串和整形数字之间进行转换：
4.1 int 转成 String
int num = 10;
// 方法1
String str1 = num + "";
// 方法2
String str2 = String.valueOf(num);
4.2 String 转成 int
String str = "100";
int num = Integer.parseInt(str);
三、运算符
1. 算术运算符
1.1 基本四则运算符
加减乘除模(+ - * / %)
int a = 20;
int b = 10;
System.out.println(a + b); // 30
System.out.println(a - b); // 10
System.out.println(a * b); // 200
System.out.println(a / b); // 2
System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数
【注意】：
• 都是二元运算符，使用时必须要有左右两个操作数
• int / int 结果还是int类型，而且会向下取整
int a = 3;
int b = 2;
// 在数学中应该是1.5 但是在Java中输出结果为1 会向下取整，即小数点之后全部舍弃掉了
System.out.println(a / b);
// 如果要得到数学中的结果，可以使用如下方式
double d = a*1.0 / b;
System.out.println(d);
• 做除法和取模时，右操作数不能为0
int a = 1;
int b = 0;
System.out.println(a / b)
// 运行结果
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Test.main(Test.java:5)
• % 不仅可以对整型取模，也可以对double类型取模，但是没有意义，一般都是对整型取模的
System.out.println(11.5 % 2.0);
// 运行结果
1.5
• 两侧操作数类型不一致时，向类型大的提升
System.out.println(1+0.2);
// +的左侧是int，右侧是double，在加之前int被提升为double
// 故：输出1.2
1.2 增量运算符
+= -= *= %=
该种类型运算符操作完成后，会将操纵的结果赋值给左操作数。
int a = 1;
a += 2; // 相当于 a = a + 2
System.out.println(a); // 输出3
a -= 1; // 相当于 a = a - 1
System.out.println(a); // 输出2
a *= 3; // 相当于 a = a * 3
System.out.println(a); // 输出6
a /= 3; // 相当于 a = a / 3
System.out.println(a); // 输出2
a %= 3; // 相当于 a = a % 2
System.out.println(a); // 输出2
【注意】：
只有变量才能使用该运算符，常量不能使用。
1.3 自增/自减运算符
++ --
++是给变量的值+1，–是给变量的值-1。
int a = 1;
a++; // 后置++ 表示给a的值加1，此时a的值为2
System.out.println(a++); // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
System.out.println(a); // 输出3
++a; // 前置++ 表示给a的值加1
System.out.println(++a); // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
System.out.println(a); // 输出5
// --操作符给操作-1，与++含义类似
【注意】：
• 如果单独使用，【前置++】和【后置++】没有任何区别。
• 如果混合使用，【前置++】先+1，然后使用变量+1之后的值，【后置++】先使用变量原来的值，表达式结束时给变量+1。
• 只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改。
2. 关系运算符
关系运算符主要有六个: == != < > <= >= ，其计算结果是 true 或者 false 。
int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a < b); // true
System.out.println(a > b); // false
System.out.println(a <= b); // true
System.out.println(a >= b); // false
【注意】：
当需要多次判断时，不能连着写，比如：1 < a < 3，Java程序与数学中是有区别的。
3. 逻辑运算符★
逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型。
- 逻辑与 &&
语法规则：表达式1 && 表达式2，左右表达式必须是boolean类型的结果。
两个表达式都为真，结果才是真，只要有一个是假，结果就是假。
int a = 1;
int b = 2;
System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
System.out.println(a > 100 && b == 2); // 左为假 但 右为真 则结果为假
System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假
- 逻辑 ||
语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果。
相当于现实生活中的或。
int a = 1;
int b = 2;
System.out.println(a == 1 || b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 || b > 100); // 左为真 但 右为假 则结果也为真
System.out.println(a > 100 || b == 2); // 左为假 但 右为真 则结果也为真
System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假
【注意】：
左右表达式至少有一个位真，则结果为真
- 逻辑非 !
语法规则：! 表达式
真变假，假变真。
int a = 1;
System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
System.out.println(!(a != 1)); // a != 1 为false，取个非就是true
- 短路求值
&& 和 || 遵守短路求值的规则.
System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0); // 打印true
我们都知道, 计算 10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行, 说明 10 / 0 并没有真正被求值。
【注意】:
• 对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式。
• 对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式。
• & 和 | 如果表达式结果为 boolean 时,也表示逻辑运算. 但与 && || 相比, 它们不支持短路求值。
System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常
4. 位运算符
Java 中数据存储的最小单位是字节，而数据操作的最小单位是比特位. 字节是最小的存储单位，每个字节是由8个二进制比特位组成的，多个字节组合在一起可以表示各种不同的数据。
位运算符主要有四个: & | ~ ^ ，除 ~ 是一元运算符外，其余都是二元运算符。
位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算。
- 按位与
&:
如果两个二进制位都是 1, 则结果为 1, 否则结果为 0
int a = 10;
int b = 20;
System.out.println(a & b);
进行按位运算, 需要先把 10 和 20 转成二进制, 分别为 1010 和 10100
- 按位或
|:
如果两个二进制位都是 0, 则结果为 0, 否则结果为 1
int a = 10;
int b = 20;
System.out.println(a | b);
运算方式和按位于类似：
【注意】：
当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean的时候, 表示逻辑运算。
- 按位取反
~:
如果该位为 0 则转为 1, 如果该位为 1 则转为 0
int a = 0xf;
System.out.printf("%x\n", ~a)
【注意】：
• 0x 前缀的数字为 十六进制数字. 十六进制可以看成是二进制的简化表示方式. 一个十六进制数字对应 4个二进制位.
• 0xf 表示 10 进制的 15, 也就是二进制的 1111
• printf 能够格式化输出内容, %x 表示按照十六进制输出.
• \n 表示换行符
- 按位异或
^:
如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1
int a = 0x1;
int b = 0x2;
System.out.printf("%x\n", a ^ b);
【注意】：
如果两个数相同，则异或的结果为0
5. 条件运算符
条件运算符只有一个:
表达式1 ? 表达式2 : 表达式3
当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;
当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值。
也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法。
// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;
【注意】：
- 表达式2和表达式3的结果要是同类型的，除非能发生类型隐式类型转换
int a = 10;
int b = 20;
int c = a > b? 1 : 2.0;
- 表达式不能单独存在，其产生的结果必须要被使用
int a = 10;
int b = 20;
a > b? a : b; // 报错：Error:(15, 14) java: 不是语句
6. 运算符的优先级
在一条表达式中，各个运算符可以混合起来进行运算，但是运算符的优先级不同，比如：* 和 / 的优先级要高于 +和 - ，有些情况下稍不注意，可能就会造成很大的麻烦。
// 求a和b的平均值
int a = 10;
int b = 20;
int c = a + (b - a) >> 1;
System.out.println(c);
上述表达式中，由于 + 的优先级要高于 >> , 因此a先和b-a的结果做加法，整体为20，最后再进行右移，因此结果为10。
【注意】：
运算符之间是有优先级的. 具体的规则我们不必记忆. 在可能存在歧义的代码中加上括号即可。
// 求a和b的平均值
int a = 10;
int b = 20;
int c = a + ((b - a) >> 1);
System.out.println(c);