@
目录Java 基础语法
标识符 & 关键字
标识符
类名、变量名以及方法名都被称为标识符。
- 以字母（a - z / A - Z）/ 下划线（_）/ 美元符（$）开头，后跟字母 / 下划线 / 美元符 / 数字
- 不能以数字开头，不能使用关键字命名
- 大小写敏感
关键字
java 关键字学习：https://baike.baidu.com/item/java关键字/5808816
注意：Java 的 null 不是关键字，类似于 true 和 false，它是一个字面常量，不允许作为标识符使用。
数据类型
1. 数据类型的介绍
Java是强类型语言——变量的使用要严格符合规定，所有的变量都要先定义后才能使用。
- 基本数据类型（四类八种）
- 整数：byte、short、int（默认）、long
- 浮点数：float、double（默认）
- 布尔：boolean
- 字符（单个）：char
- 引用数据类型
- 类
- 接口
- 数组
拓展
public static void main(String[] args) {
// 整数扩展 进制
int num1 = 0b10; // 二进制 0b
int num2 = 010; // 八进制 0
int num3 = 0x10; // 十六进制 0x
int num4 = 10; // 默认是十进制
System.out.println(num1); // 2
System.out.println(num2); // 8
System.out.println(num3); // 16
System.out.println(num4); // 10
System.out.println("==================================");
// ===================================================
// 浮点数扩展 精度丢失 离散 大约 接近但不等于
// 最好避免使用浮点数进行比较运算
// 金融使用 BigDecimal 数学工具类
// ===================================================
float f1 = 0.1F;
double d1 = 1.0/10;
System.out.println(f1 == d1); // false
System.out.println(f1); // 0.1
System.out.println(d1); // 0.1
float f2 = 1123123123123123F;
float f3 = f2 + 1;
System.out.println(f2 == f3); // true
System.out.println("==================================");
// ===================================================
// 字符扩展 Unicode 编码 2Byte 0-65536 0000-FFFF 字符本质上是数字
// ===================================================
char c1 = 'a';
char c2 = '忠';
char c3 = 0x0061;
char c4 = '\u0061';
System.out.println(c1); // a
System.out.println((int)c1); // 97
System.out.println(c2); // 忠
System.out.println((int)c2); // 24544
System.out.println(c3); // a
System.out.println(c4); // a
System.out.println("==================================");
// ===================================================
// 字符串 String 不是关键字
// ===================================================
String str1 = new String("Hello World");
String str2 = new String("Hello World");
System.out.println(str1 == str2); // false
String str3 = "Hello World";
String str4 = "Hello World";
System.out.println(str3 == str4); // true
}
2. 类型转换
由于Java是强类型语言，在进行一些运算时需要用到类型转换
类型转换：同一类型直接进行运算，不同类型首先转换成同一类型再进行运算，转换的规则是根据表示的数据范围从小向大的进行转换。
低 ----------------------------------------> 高
byte,short,char -> int -> long -> float -> double
注：float 和 int 虽同为 4 字节，但 float 表示的范围比 int 要大
- 强制类型转换（范围由低到高）：(类型)变量名
int i = 128; // 11111111 11111111 11111111 10000000 128 (补码表示)
// 强制类型转换 (类型)变量名
byte b = (byte) i; // 范围越界 1,0000000 -128 (补码表示)
// 1,0000000 -0 (原码表示)
System.out.println(b); // -128
- 自动类型转换（范围由高到低）
short s = 32767; // 32767 默认是 int 类型，自动转为 short 类型
char c1 = 61; // int --> char
char c2 = 0x0061;
System.out.println(c1); // =
System.out.println(c2); // a
注：
- 不能对布尔值进行类型转换
- 范围大强制转换成范围小时有可能会发生溢出或者精度丢失
- 不能把对象类型转换成不相干的类型
int money1 = 1000000000; // 十亿
// JDK1.7特性，数字下面加下划线，方便区分，下划线不会被输出
int money2 = 10_0000_0000;
System.out.println(money1); // 1000000000
System.out.println(money2); // 1000000000
System.out.println("===========================");
int year = 20;
int res = year * money1;
System.out.println(res); // -1474836480 溢出
long res1 = year * money1;
// -1474836480 溢出 year money1 默认是int，转换之前就存在问题
System.out.println(res1);
long res2 = ((long)year) * money1;
System.out.println(res2); // 20000000000
long res3 = (long)year * money1;
System.out.println(res3); // 20000000000
long res4 = (long)(year * money1);
System.out.println(res4); // -1474836480
变量
变量
- Java 变量是程序最基本的存储单元，要素包括变量名、变量类型和作用域。
- 每个变量都有类型，可以是基本类型也可以是引用类型。
- 变量名必须是合法的标识符。
- 变量的声明是一条完整的语句，必须以分号结尾。
type varName [=value][{,varName[=value]}];
数据类型 变量名 = 值; // 可以用逗号分隔开，来声明同一类型的变量
- 变量的使用必须先经过初始化才能使用。
变量的作用域
public class Demo02 {
static int var1 = 1; // 类变量
String str = "Hello,World"; // 实例变量
public void method(){
int var2 = 2; // 局部变量
}
}
类变量、实例变量不手动初始化，会自动赋予该类型的默认值
局部变量必须手动初始化才能使用
- byte、short、int、long 默认值为 0
- float double默认值为 0.0；char 类型默认值一个空白字符
- 引用类型默认值为 null
常量
- 初始化以后不能在运行过程中改变的值，是一种特殊的变量
- 使用修饰符
final修饰 - 使用过程中只能赋值一次，无法二次赋值
- 常量名推荐使用大写字母表示
final 数据类型 常量名 = 值;
final double PI = 3.14;
运算符
java语言支持的运算符：
| 基本运算符 | 符号 |
|---|---|
| 算数运算符 | +、-、*、/、%、++、- - |
| 赋值运算符 | = |
| 关系运算符 | >、<、>=、<=、==、!=、instanceof |
| 逻辑运算符 | &&、||、！ |
| 位运算符 | &、` |
| 条件运算符 | ? : |
| 扩展运算符 | +=、-=、*=、/= |
<<：有符号左移
>>：有符号右移
>>>：无符号右移
自增、自减
int a = 3;
int b = a++;
int c = ++a;
System.out.println(a); // 5
System.out.println(b); // 3
System.out.println(c); // 5
逻辑与 && ：短路
int i = 1;
System.out.println(false&& (++i > 0)); // false
System.out.println(i); // 1
有符号左移 <<
System.out.println(1 << 3);// 00001 --> 01000 8
字符串拼接
int a = 10;
int b = 20;
System.out.println("" + a + b); // 1020
System.out.println(a + b + ""); // 30
System.out.println(a + "" + b); // 1020
包机制
- 区别类名的命名空间
- 一般利用公司域名倒置作为包名
- 包语句的语法格式为：
package pk1[.pk2 [ .pk3... ] ];
- 使用某一个包下的类时，用关键字 import 进行导包操作；
import package1[ .package2 ... ].(classname|*);
JavaDoc 文档注释
javadoc 命令是用来生成自己的 API 文档的
格式：
javadoc 参数 java文件
例如：javadoc -encoding UTF-8 -charset UTF-8 ClassName.java
参数信息：
- @author：作者名
- @version：版本号
- @since：指明需要最早使用的 JDK 版本
- @param：参数名
- @return：返回值情况
- @throws：异常抛出情况
Scanner 类
// 创建一个扫描器对象，用于接收用户键盘的输入
Scanner scanner = new Scanner(System.in);
// next()：接收到第一个有效字符之后，以空格或回车为结束标识
// String str = scanner.next();
// nextLine()：完整的输出该行的所有内容，以回车为结束标识
String str = scanner.nextLine();
System.out.println(str);
// 关闭扫描器对象 释放资源
scanner.close();
练习
/*
输入多个数字，并求其总和与平均数
每输入一个数字用回车确认, 通过输入非数字来结束输入并输出执行结果
*/
Scanner scanner = new Scanner(System.in);
double sum = 0;
int cnt = 0;
System.out.print("请输入数字: ");
while (scanner.hasNextDouble()) {
System.out.print("请输入数字: ");
double x = scanner.nextDouble();
sum += x;
if (x != 0) {
cnt++;
}
};
System.out.println("总和：" + sum);
System.out.println("平均数：" + (sum / cnt));
scanner.close();
流程控制
1.1 if 选择结构
语法格式：
if(条件1){}
else if(条件2){}
...
else if(条件n){}
else {}
1.2 switch（匹配）选择结构
语法格式：
switch(表达式){
case value1:
// 语句
break; // 可选 不加会导致 case 穿透：下面的 case 语句都会执行
case value2:
// 语句
break; // 可选
...
case valuen:
// 语句
break; // 可选
default: // 可选
// 语句
}
注：
-
switch 表达式中的类型只能是 byte、short、int、char、String（jdk1.7支持）、枚举
-
也可以是基本类型的包装类：Byte、Short、Integer、Character
-
case 标签的值必须为字符串常量或者字面量，不能是一个变量！
break & continue
- break：用在循环语句体中（也可在 switch 语句中）执行，用于强制退出循环，不执行循环中剩余的语句
- continue：用在循环语句体中，跳过此次循环，接着进行下一次是否执行循环的判定
2.1 while 循环
语法格式：
while(循环条件——布尔表达式){
// 循环体
}
例：1+2+3+……+100 = ？
int sum = 0;
int i = 0;
while (i < 100){
i++;
sum += i;
}
System.out.println(sum);
2.2 do … while 循环
语法格式：
do{
// 循环体
}while(循环条件——布尔表达式);
while 和 do … while 的区别
- do … while 先执行再判断，while 先判断再执行
- do … while 循环至少执行一次，while 循环不满足条件一次也不执行
2.3 for 循环(重要)
for 循环一般用在循环次数确定情况下。
语法格式：
for(初始化表达式; 循环条件; 操作表达式){
// 循环体
}
例 1：分别计算0-100之间的奇数和与偶数和
// 偶数和
int evenSum = 0;
// 奇数和
int oddSum = 0;
// 计算0-100之间的奇数和和偶数和
for (int i = 0; i <= 100; i++) {
// 偶数
if (i % 2 == 0) {
evenSum += i;
}
// 奇数
if (i % 2 != 0) {
oddSum += i;
}
}
System.out.println("偶数和为：" + evenSum);
System.out.println("奇数和为：" + oddSum);
例 2：1-1000能被5整除的数，每行输出三个
// 1-1000能被5整除的数，每行输出三个
int cnt = 0;
for (int i = 1; i <= 1000; i++) {
if (i % 5 == 0) {
cnt = cnt + 1;
if (cnt != 3) {
System.out.print(i + "\t");
} else {
System.out.print(i);
}
}
if (cnt == 3) {
System.out.println();
cnt = 0;
}
}
例 3：九九乘法表
// 九九乘法表
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + " * " + i + " = " + (i * j) + "\t");
}
System.out.println();
}
例 4：
1）打印正三角形：找规律 根据打印的行数 每一行空格数目、星号数目
/*
打印正三角形
*
***
*****
*******
*********
*/
int line = 5; // 打印三角形的行数
for (int i = 1; i <= line; i++) {
for (int j = 1; j <= line - i; j++) { // 控制打印空格的数目
System.out.print(" ");
}
for (int j = 1; j <= 2 * i - 1; j++) { // 控制打印星号的数目
System.out.print("*");
}
System.out.println();
}
2）打印倒三角形
/*
打印倒三角形
*********
*******
*****
***
*
*/
int line = 5;
for (int i = 1; i <= line; i++) {
for (int j = 1; j < i; j++) { // 控制打印空格的数目
System.out.print(" ");
}
for (int j = 1; j <= 2*(line-i)+1 ; j++) { // 控制打印星号的数目
System.out.print("*");
}
System.out.println();
}
2.4 增强 for 循环
java 5 引入，带有迭代器的 for 循环，主要用于解决数组或集合问题
语法格式：
for(声明语句 : 表达式){
// 循环语句块
}
- 声明语句：
- 声明新的局部变量，该变量的类型必须和数组元素的类型匹配。
- 其作用域限定在循环语句块中，其值于此时数组元素的值相等。
- 表达式：
- 此时要访问的数组名或者是返回值为数组的方法。
例：
// 定义一个数组
int[] arrs = {10, 20, 30, 40, 50};
// for循环遍历数组元素
for (int i = 0; i < arrs.length; i++) {
System.out.println(arrs[i]);
}
System.out.println("======================");
// 增强for循环遍历数组元素
for (int x : arrs) {
System.out.println(x);
}
方法
1. 方法的定义
java 中的方法也就是函数，完成指定功能的程序的集合
一个方法包括两大部分：方法头和方法体
语法格式：
修饰符 返回值类型 方法名称(参数类型 参数名){ // 方法头
// 方法体
return 返回值; // 返回值类是 void 可以不加return语句
}
2. 方法的重载
重载就是在一个类中，有相同的方法名，但形参列表不同
重载规则：
- 方法名相同
- 形参列表不同（个数、类型、排列顺序）
- 方法的返回值类型可以相同也可以不同
- 仅返回值类型不同无法构成方法的重载
3. 可变参数
java 1.5 开始提供可变参数
使用：在指定参数类型后面添加一个省略号(英文) …
修饰符 返回值类型 方法名称(参数类型... 参数名){
// 方法体
return 返回值;
}
注意：一个方法中只能有一个可变参数，如果有普通参数的话，必须在所有普通参数之后
数组
对数组的理解：数组是一种容器，用来存储相同数据类型的元素，数组属于引用类型，其长度在运行期间不可改变。
数组下标从 0 开始，到 lenth - 1 ，即下标的合法区间为：[ 0, lenth - 1 ]
数组下标一旦不在合法区间中，会报一个 ArrayIndexOutOfBoundsException （数组下标越界异常）的异常
数组长度可以通过 arrName.lenth 获取
数组的两种声明方式
//第一种声明方式 首选！
dataType[] arrayName;
int[] arr1; // 数组的声明
//第二种声明方式
dataType arrayName[];
java 使用 new 关键字为数组进行申请内存
数组的两种初始化方式
- 动态初始化（长度已知）
dataType[] arrayName = new dataType[arrayLenth];
int[] arr2 = new int[3];
// 或者
dataType[] arrayName;
arrayName = = new dataType[arrayLenth];
int[] arr3;
arr3 = new int[3];
- 静态初始化（内容已知）
// 基本（标准）格式
dataType[] arrayName = new dataType[]{elem1, elem2, ……};
int[] arr4 = new int[]{1, 2, 3};
// 或者
int[] arr5;
arr5 = new int[]{1, 2, 3};
// 省略格式
dataType[] arrayName = {elem1, elem2, ……};
int[] arr6 = {1, 2, 3};
注：
- 虽然静态初始化没有直接指明数组长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度
- 静态初始化和动态初始化可以拆分成声明和初始化两个步骤，但使用省略格式的静态初始化，就不能拆分成为两个步骤了
数组的特点
- 数组的长度是确定，数组一旦被创建，在程序运行期间其大小是不可改变的
- 数组中的元素可以是基本类型，也可以是引用类型，但必须是同一种类型
- 数组变量属于引用类型，可以看成是对象，数组里的每个元素可以看成是数组的成员变量
- Java 中的对象存放在堆（Heap）中，数组变量可以看成是对象，因此数组对象也存放在堆中
数组的隐式默认初始化
数组一旦被创建（动态初始化），如果不特意为数组元素赋值，会有一个默认的隐式赋值
| 数组元素的的数据类型 | 默认值 |
|---|---|
| 整型 | 0 |
| 浮点型 | 0.0 |
| 字符型 | \u0000（一个空白符） |
| 布尔型 | false |
| 引用类型 | null |
// 以下静态初始化，如果不指定内容，则打印结果为什么都没有
int[] arr2 = new int[]{};
int[] arr3 = {};
// 动态初始化，整型元素默认值为 0
int[] arr4 = new int[4];