Java基本语法

关键字和保留字

定义：关键字和保留字是被Java语言赋予了特殊含义，专门用途的单词。

[ 注意 ]：这些单词都是小写的

具体有多少可以参考官网：官方地址

关键字表单

这些东西也不需要刻意的去背，多敲，慢慢的就记住了

用于定义数据类型关键字

class，interface，enum，byte，short，int，long，float，double，char，boolean，void

用于定义流程控制地关键字

if，else，switch，case，default，while，do，for，break，continue，return

用于定义类，函数，变量的关键字

abstract，final，static，synchronized

用于定义类于类之间的关键字

extends，implements

用于定义新建以及引用，判断实体的关键字

new，this，super，instanceof

处理异常的关键字

try，catch，finally，throw，throws

其他关键字

package，import，native，strictfp，transient，volatile，assert

---

这也就意味着我们定义变量的时候不能和这些玩意同名。

定义变量的规则以及规范

基本规则

这些基本规则是必须遵循的，因为这个是编译器决定的。

• 由26个英文字母大小写，0-9 ，_或 $ 组成
• 数字不可以开头。
• 不可以使用关键字和保留字，但能包含关键字和保留字。
• Java中严格区分大小写，长度无限制。
• 标识符不能包含空格。

命名规范

这个规范时候来的人们规定的，不按照这个规范写依然可以使用，但是为了程序的可读性最好还是遵守这些规范。

• 包名：多单词组成时所有字母都小写：xxxyyyzzz
• 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个 单词首字母大写：xxxYyyZzz
• 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

[ 注意 ]：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

变量

基本知识

什么是变量，这个东西可谓是初学者最容易犯迷糊的东西。先来给个专业的解释：

• 内存中的一个存储区域
• 该区域的数据可以在同一类型范围内不断变化
• 变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值

这哪看的明白，最简单的理解：一个盒子装着东西，盒子有对应的名字，这个名字就是变量名，里面装的东西可以换别的同一个类型的玩意，里面的东西也就是值，这整个东西就是变量。

所以变量有什么作用：不就是用于在内存中保存数据

使用变量需要注意的事情：

• Java中每个变量必须先声明，后使用（也就是我们需要先拿到盒子）
• 使用变量名来访问这块区域的数据（使用这个盒子）
• 变量的作用域：其定义所在的一对{ }内
• 变量只有在其作用域内才有效
• 同一个作用域内，不能定义重名的变量

例如定义一个变量：

int num; //盒子就定义好了，只不过里面没有东西

num = 10; //给这个盒子放东西

int num = 10; //这个就相当于上面两步

变量的类型

整数类型：byte、short、int、long

java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’

类 型	占用存储空间	表数范围
byte	1字节=8bit位	-128 ~ 127
short	2字节	-2^15 ~2^15 -1
int	4字节	-231~231-1(约21亿)
long	8字节	-2^63 ~ 2^63 -1

浮点类型：float、double

与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作 系统的影响。

浮点型常量有两种表示形式：

• 十进制数形式：如：5.12 512.0f .512 (必须有小数点）
• 科学计数法形式:如：5.12e2 512E2 100E-2

float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。 double:双精度，精度是float的两倍。通常采用此类型。

[ 注意 ]：Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。

字符类型：char

char 型数据用来表示通常意义上“字符”(2字节)

Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。

字符型变量的三种表现形式：

• 字符常量是用单引号(‘ ’)括起来的单个字符。例如：char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;

• Java中还允许使用转义字符 ‘\’ 来将其后的字符转变为特殊字符型常量。 例如：

  char c3 = ‘\n’; // '\n'表示换行符 
  

• 直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表 一个十六进制整数。如：\u000a 表示 \n。

char类型是可以进行运算的。因为它都对应有Unicode码。

[ Unicode ]：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一 无二的编码，使用 Unicode 没有乱码的问题。

布尔类型：boolean

boolean 类型用来判断逻辑条件，一般用于程序流程控制：

• if条件控制语句；
• while循环控制语句；
• do-while循环控制语句；
• for循环控制语句；

boolean类型数据只允许取值true和false，无null。

[ 注意 ]：不可以使用0或非 0 的整数替代false和true，这点和C语言不同。

基本数据类型转换

自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：

byte 、char 、short --> int --> long --> float --> double

[ 注意 ]：当byte、char、short三种类型的变量做运算时，结果为int型

当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类 型的值将自动转化为字符串(String)类型。

字符串类型：String

String不是基本数据类型，属于引用数据类型

使用方式与基本数据类型一致。例如：String str = “abcd”;

一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：

str = str + “xyz”; 
int n = 100; 
str = str + n;

通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可 以实现把字符串转换成基本类型。

运算符

如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是 负数则不可忽略。此外，取模运算的结果不一定总是整数。

对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只 保留整数部分而舍弃小数部分。 例如：int x=3510;x=x/1000*1000，此时x为3000

“+”除字符串相加功能外，还能把非字符串转换成字符串.例如： System.out.println(“5+5=”+5+5); //打印结果是？ 5+5=55 ?

算术运算符

例如：

//除号：/
int num1 = 12;
int num2 = 5;
int result1 = num1 / num2;
System.out.println(result1);//2
// %:取余运算
//结果的符号与被模数的符号相同
//开发中，经常使用%来判断能否被除尽的情况。
int m1 = 12;
int n1 = 5;
System.out.println("m1 % n1 = " + m1 % n1);

int m2 = -12;
int n2 = 5;
System.out.println("m2 % n2 = " + m2 % n2);

int m3 = 12;
int n3 = -5;
System.out.println("m3 % n3 = " + m3 % n3);

int m4 = -12;
int n4 = -5;
System.out.println("m4 % n4 = " + m4 % n4);
//(前)++ :先自增1，后运算
//(后)++ :先运算，后自增1
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1 + ",b1 = " + b1);

int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2 + ",b2 = " + b2);

int a3 = 10;
++a3;//a3++;
int b3 = a3;
//(前)-- :先自减1，后运算
//(后)-- :先运算，后自减1

int a4 = 10;
int b4 = a4--;//int b4 = --a4;
System.out.println("a4 = " + a4 + ",b4 = " + b4);

/** 注意
(前)++ :先自增1，后运算
(后)++ :先运算，后自增1
(前)-- :先自减1，后运算
(后)-- :先运算，后自减1
*/

赋值运算符

= += -= *= /= %=

例如：

int i2,j2;
//连续赋值
i2 = j2 = 10;
//***************
int i3 = 10,j3 = 20;
int num1 = 10;
num1 += 2;//num1 = num1 + 2;
System.out.println(num1);//12

int num2 = 12;
num2 %= 5;//num2 = num2 % 5;
System.out.println(num2);

short s1 = 10;
//s1 = s1 + 2;//编译失败
s1 += 2;//结论：不会改变变量本身的数据类型
System.out.println(s1);

[ 说明 ]：运算的结果不会改变变量本身的数据类型

比较运算符（关系运算符）

int i = 10;
int j = 20;

System.out.println(i == j);//false
System.out.println(i = j);//20

boolean b1 = true;
boolean b2 = false;
System.out.println(b2 == b1);//false
System.out.println(b2 = b1);//true

说明：

• 比较运算符的结果是boolean类型

• > < >= <= :只能使用在数值类型的数据之间。

• == 和 !=: 不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间。

  Account acct1 = new Account(1000);
  Account acct2 = new Account(1000);
  boolean b1 = (acct1 == acct2);//比较两个Account是否是同一个账户。
  boolean b2 = (acct1 != acct2);//
  

逻辑运算符

& && | || ! ^

//区分& 与 &&
// 相同点1：& 与  && 的运算结果相同
//相同点2：当符号左边是true时，二者都会执行符号右边的运算
//不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
//开发中，推荐使用&&
boolean b1 = true;
b1 = false;
int num1 = 10;
if(b1 & (num1++ > 0)){
    System.out.println("我现在在北京");
}else{
    System.out.println("我现在在南京");
}

System.out.println("num1 = " + num1);


boolean b2 = true;
b2 = false;
int num2 = 10;
if(b2 && (num2++ > 0)){
    System.out.println("我现在在北京");
}else{
    System.out.println("我现在在南京");
}

System.out.println("num2 = " + num2);

// 区分：| 与 || 
//相同点1：| 与  || 的运算结果相同
//相同点2：当符号左边是false时，二者都会执行符号右边的运算
//不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
//开发中，推荐使用||
boolean b3 = false;
b3 = true;
int num3 = 10;
if(b3 | (num3++ > 0)){
    System.out.println("我现在在北京");
}else{
    System.out.println("我现在在南京");
}
System.out.println("num3 = " + num3);


boolean b4 = false;
b4 = true;
int num4 = 10;
if(b4 || (num4++ > 0)){
    System.out.println("我现在在北京");
}else{
    System.out.println("我现在在南京");
}
System.out.println("num4 = " + num4);

[ 注意 ]：逻辑运算符操作的都是boolean类型的变量。而且结果也是boolean类型
[ 补充 ]：三元运算符：(条件表达式)? 表达式1 : 表达式2

流程控制

if-else条件判断结构

结构一：
if(条件表达式){
	执行表达式
}

结构二：二选一
if(条件表达式){
	执行表达式1
}else{
	执行表达式2
}

结构三：n选一
if(条件表达式){
	执行表达式1
}else if(条件表达式){
	执行表达式2
}else if(条件表达式){
	执行表达式3
}
...
else{
	执行表达式n
}

说明：

• else 结构是可选的。
• if-else结构是可以相互嵌套的。
• 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议省略。

switch-case选择结构

switch(表达式){
case 常量1:
	执行语句1;
	//break;
case 常量2:
	执行语句2;
	//break;
...
default:
	执行语句n;
	//break;
}

说明：

• 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。

• break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构，可选的

• switch结构中的表达式，只能是如下的6种数据类型之一：
  byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)

• default:相当于if-else结构中的else。并且是可选的，而且位置是灵活的。

for循环结构

for(①;②;④){
	③
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
    
例如：
/*			i(行号)		j(*的个数)
	*			1			1
	**			2			2
	***			3			3
	****		4			4
	*****		5			5
*/

for(int i = 1;i <= 5;i++){//控制行数
   for(int j = 1;j <= i;j++){//控制列数
       System.out.print("*");
   }
   System.out.println();
}

while循环结构

①
while(②){
	③;
	④;
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
注意：写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！

数组

基本概念

数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式 对这些数据进行统一管理。

数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。

创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是 这块连续空间的首地址。

数组的长度一旦确定，就不能修改。

我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。（各种排序算法的基本操作）

一维数组

一维数组的声明方式： type var[] 或 type[] var；

Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法

声明的方式

//正确的方式：
int num;//声明
num = 10;//初始化
int id = 1001;//声明 + 初始化

int[] ids;//声明
//1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{1001,1002,1003,1004};
//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];

int[] arr4 = {1,2,3,4,5};//类型推断

//错误的方式：
int[] arr1 = new int[];
int[5] arr2 = new int[5];
int[] arr3 = new int[3]{1,2,3};

使用

String[] names = new String[5];
//数组的角标（或索引从0开始的，到数组的长度-1结束。
names[0] = "王铭";
names[1] = "王赫";
names[2] = "张学良";
names[3] = "孙居龙";
names[4] = "王宏志";//charAt(0)

数组的属性：length，这个是声明的数组的一个固有属性。数组一旦初始化，其长度就是确定的。arr.length

二维数组

一个一维数组A的元素如果还是一个一维数组类型的，则此数组A称为二维数组。

一维数组类似一串，二维数组类似一张表。

二维数组的声明与初始化以及使用

//正确的方式：
int[] arr = new int[]{1,2,3};//一维数组
//静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
//动态初始化1
String[][] arr2 = new String[3][2];
//动态初始化2
String[][] arr3 = new String[3][];
//也是正确的写法：
int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};//类型推断

//错误的方式：
String[][] arr4 = new String[][4];
String[4][3] arr5 = new String[][];
int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}}

//调用二维数组元素
System.out.println(arr1[0][1]);//2
System.out.println(arr2[1][1]);//null

arr3[1] = new String[4];
System.out.println(arr3[1][0]);
System.out.println(arr3[0]);

//二维数组的属性：
System.out.println(arr4.length);//3
System.out.println(arr4[0].length);//3
System.out.println(arr4[1].length);//4

//采用双重for循环遍历
for(int i = 0;i < arr4.length;i++){	
    for(int j = 0;j < arr4[i].length;j++){
        System.out.print(arr4[i][j] + "  ");
    }
    System.out.println();
}

Arrays工具类的使用

//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,3,2,4};
boolean isEquals = Arrays.equals(arr1, arr2);
System.out.println(isEquals);

//2.String toString(int[] a):输出数组信息。
System.out.println(Arrays.toString(arr1));


//3.void fill(int[] a,int val):将指定值填充到数组之中。
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));


//4.void sort(int[] a):对数组进行排序。
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));

//5.int binarySearch(int[] a,int key)
int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int index = Arrays.binarySearch(arr3, 210);
if(index >= 0){
    System.out.println(index);
}else{
    System.out.println("未找到");
}