关键字和保留字
定义:关键字和保留字是被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("未找到");
}