Java基础语法学习笔记
一、Java程序基本结构
1、代码框架及注释
代码基本框架
public class HelloWorld {
public static void main(String[] args) {
}
}
注释:
- 用于说明解释程序的文字。提高了代码的可阅读性。
- Java中的注释格式:
单行注释: //注释文字
多行注释: /* 注释文字 /
文档注释:/* *注释文字 */ - 对于单行和多行注释,被编译器编译成字节码时就被忽略了。
- 文档注释是java特有的注释,其中注释内容可以被JDK提供的工具javadoc.exe所解析,生成一套以网页文件形式体现的该程序的说明文档。
2、标识符
定义:Java对包、类、方法、参数和发量等要素命名时使用的字符序列称为标识符。
Java标识符命名规则
- 由英文字母、数字、下划线(_)和美元符号() 组 成 。
- 不能以数字开头 。
- 不能是Java中的保留关键字 。
- 区分大小写 。
- 长度无限制 。
- 标识符命名习惯 :见名知意 。 示 例 :HelloWorld 、 username 2 、username 、userName 组成
3、关键字
关键字:Java中有特定含义与用途的字符串称为关键字。全部为小写
4、常量
常量:在程序执行的过程中其值不可以发生改变
- 整型常量。所有整数:123 、10、 30、 789
- 浮点数常量。所有实数:3.1415926 、1.32
- 字符常量。由单引号(’ ')标识的单个字符:‘a’、’\t’、’\u0027‘ 、‘o’
- 布尔(逻辑)常量:true、false
- 字符串常量。由双引号(“”)标识的一个或多个字符:“a”、"hello world‚ ‚button‛
- null常量:表示对象的引用为空
二、变量
变量概述
a. 在程序执行的过程中,在某个范围内其值可以发生改变的量
b. 理解:如同数学中的未知数
变量定义格式
a. 数据类型 变量名 = 初始化值;
b. 注意:格式是固定的,记住格式,以不变应万变
三、数据类型
Java语言是强类型语言,对于每一种数据都定义了明确的具体数据类型,在内存总分配了不同大小的内存空间
1、基本数据类型
Java中定义了四类/八种基本数据类型
- 布尔型 boolean
- 字符型 char
- 整数型---- byte, short, int, long
- 浮点数型---- float, double
整数类型:
- 注:Java语言的整型常量默认为int型,如:int i = 3;
- 注:声明long型的数据时可以加’l’或‘L’,如:long l = 3L;
浮点数类型:
- 注:Java浮点型常量默认为double型。声明float型 的数据后面需要加上f或F。
字符类型:
char型数据用来表示通常意义上字符:
char a1 = 'a';
System.out.println(a1);
面试题:
byte b1=3,b2=4,b;
b=b1+b2;
b=3+4;
哪句是编译失败的呢?为什么呢?
答:第二条语句出错。第一句相当于byte b1=3;byte b1=3;byte b;
布尔类型:
- boolean类型适用于逻辑运算,一般用于程序流程控制 。
- boolean类型数据只允许取值true或false。
- 不可以用0或非0的整数替代true和false。
示例:boolean b = false;
基本数据类型之间的转换
- boolean 类型不能转换成任何其它数据类型。
- 自动类型转换:容量小的类型自动转换成容量大的数据类型
byte,short,char—int—long—float—double
byte,short,char相互之间补转换,他们参与运算首先转换为int类型
强制转换
目标类型 变量名=(目标类型)(被转换的数据);
有可能造成精度降低或数据溢出,使用时要小心。
四、运算符
- 算术运算符:+、-、*、/、%、++、–
- 赋值运算符:= 、+= 、-= 、= 、/= 、%=
- 比较运算符:>、<、>=、<=、==、!=
- 逻辑运算符:! 、&、|、^、&&、||
- 位运算符:&、|、^、~、>>、<<、>>>
- 三目运算符
- 字符串连接运算符:+
1. 算数运算符
例:
int a = 10;
int b = 10;
int c = 10;
a = b++; // a=10 b=11 c=10
c = --a; // a=9 b=11 c=9
b = ++a;// a=10 b=10 c=9
a = c--;// a=9 b=10 c=8
2、赋值运算符
赋值运算符作用是将一个值赋给一个发量
由两个运算符组成而成的运算符,也叫复合运算符
3、关系运算符
关系运算符作用是比较两边的操作数,结果总是boolean型的。也叫 比较运算符
- 注1:比较运算符的结果都是boolean型,也就是要么是true,要么是false。
- 注2:比较运算符“==”不能误写成“=”
4、逻辑运算符
逻辑运算符用亍对boolean型结果的表达式迕行运算,运算结果总是boolean型
- 逻辑运算符用于连接布尔型表达式,在Java中不可以写成3<x<6,应该写成x>3& x<6 。
- “&”和“&&”的区别:
单&时,左边无论真假,右边都进行运算;
双&时,如果左边为真,右边参与运算,如果左边为假,那么右边不参与运算。
“|”和“||”的区别同理,双或时,左边为真,右边不参与运算。 - 异或( ^ )与或( |)的不同之处是:当左右都为true时,结果为false。
- 异或相同为False 不同为True
5、位运算符
左移:"a<<b; "将二迕制形式的a逐位左移b位,最低位空出的b位补0
带符号右移:"a>>b; "将二迕制形式的a逐位右移b位,最高位空出的b位补原来的符号位
无符号右移:"a>>>b;"将二迕制形式的a逐位右移b位,最高位空出的b位补0
System.out.println(24<<2); // 96 24*2^2
System.out.println(3<<3);// 3*2^3=24
System.out.println(-24>>2);// 24/2^2=6
System.out.println(100 >> 2); // 100/2^2=25
例:
int a = 3;
int b = 4;
System.out.println(a & b); //0
System.out.println(a | b); //7
System.out.println(a ^ b); //7
System.out.println(~a); // -4
/*
计算机当中是用补码进行计算
a的值原反补:00000000 00000000 00000000 00000011
b的值原反补:00000000 00000000 00000000 00000100
&: 有0则0
00000000 00000000 00000000 00000011
&
00000000 00000000 00000000 00000100
---------------------------------------
00000000 00000000 00000000 00000000 ---> 0
|: 有1则1
00000000 00000000 00000000 00000011
|
00000000 00000000 00000000 00000100
-----------------------------------------
00000000 00000000 00000000 00000111 ---> 7
^: 相同则0,不同则1
00000000 00000000 00000000 00000011
^
00000000 00000000 00000000 00000100
----------------------------------------
00000000 00000000 00000000 00000111 ----> 7
~:1变成0,0变成1
00000000 00000000 00000000 00000011
~
--------------------------------------
11111111 11111111 11111111 11111100
已知补码求原码
补码: 1 1111111 11111111 11111111 11111100
反码: 1 1111111 11111111 11111111 11111011
原码: 1 0000000 00000000 00000000 00000100
-------------------------------------------------
---------> -4
*/
6、字符串连接运算
- String s=“He” + “llo”; 结果"Hello"
- "+"除了可用于字符串相连接,也能将字符串与其它的数据类型相连 成一个新的字符串。
如:String s=“x” + 123; 结果"x123"
7、三目运算符
格式:(关系表达式)?表达式1:表达式2;
如果条件为true,运算后的结果是表达式1;
如果条件为false,运算后的结果是表达式2;
五、语句
1、程序控制流程
(1) 顺序结构
- 是程序中最简单最基本的流程控制,没有特定的语法结构,按照代码的先后顺序,自上而下, 依次执行,程序中大多数的代码都是这样执行的。
- 总的来说:写在前面的先执行,写在后面的后执行
(2) 选择结构
- 选择结构也被称为分支结构。
- 选择结构有特定的语法规则,代码要执行具体的逻辑运算进行判断,逻辑运算的结果有两个,所以产生选择,按照不同的选择执行不同的代码。
- Java语言提供了两种选择结构语句:
if语句
switch语句
(3) 循环结构
- 循环语句可以在满足循环条件的情况下,反复执行某一段代码,这段被重复执行的代码被称为循环体语句,当反复执行这个循环体时,需要在合适的时候把循环判断条件修改为false,从而结束循环,否则循环将一直执行下去,形成死循环。
2、条件语句
if语句第一种格式:
•if(关系表达式) {
语句体
}
执行流程:
- 首先判断关系表达式看其结果是true还是false
- 如果是true就执行语句体
- 如果是false就不执行语句体
if语句第二种格式:
if(关系表达式) {
语句体1;
}else {
语句体2;
}
执行流程:
- 首先判断关系表达式看其结果是true还是false
- 如果是true就执行语句体1
- 如果是false就执行语句体2
if语句第二种格式和三元运算符
- 三元运算符的操作都可以使用if语句改进,反之不成立
- 当if语句控制的语句体是一条输出语句的时候,就不成立。因为三元运算符是一个运算符,必须要求有一个结果返回。
而输出语句却不能作为一个返回结果。
if语句第三种格式:
if(关系表达式1) {
语句体1;
}else if (关系表达式2) {
语句体2;
}
…
else {
语句体n+1;
}
执行流程:
首先判断关系表达式1看其结果是true还是false
如果是true就执行语句体1
如果是false就继续判断关系表达式2看其结果是true还是false
如果是true就执行语句体2
如果是false就继续判断关系表达式…看其结果是true还是false
…
如果没有任何关系表达式为true,就执行语句体n+1
switch语句格式:
switch(表达式){
case 值1: 语句块1; break;
…
…
case 值n: 语句块n; break;
default: 语句块n+1; break;
}
执行流程:
- 首先计算出表达式的值
- 其次,和case依次比较,一旦有对应的值,就会执行相应的语句,在执行的过程中,遇到break就会结束。
- 最后,如果所有的case都和表达式的值不匹配,就会执行default语句体部分,然后程序结束掉。
注意事项:
- case后面只能是常量,不能是变量,而且,多个case后面的值不能出现相同的
- default可以省略。一般不建议。除非判断的值是固定的。(单选题)
- default的位置可以出现在switch语句任意位置。
3、循环语句
功能:在循环条件满足的情况下,反复执行特定代码
分类:
- for 循环
- while 循环
- do/while 循环
(1)for循环语句
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
//在控制台中输出10行hello world
for(int i = 1;i<11;i++) {
System.out.println("hello world");
}
执行流程:
- 执行初始化语句
- 执行判断条件语句,看其结果是true还是false
a.如果是false,循环结束。
b. 如果是true,继续执行。 - 执行循环体语句
- 执行控制条件语句
- 回到B继续
说明:
初始化表达式只执行一次
判断循环条件,为真就执行循环体 ,之后再执行循环后的操作表达式,接着又判断循环条件,重复整个过程,直到条件满足为止。
(2)while循环语句
基本格式:
while(判断条件语句){
循环体语句;
}
扩展格式:
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
//打印10行Hello World
int i = 1;
while(i<=10){
System.out.println("hello world");
i++;
}
特点:先判断后循环
(3)do/while 循环
基本格式:
do {
循环体语句;
}while((判断条件语句);
扩展格式:
初始化语句;
do {
循环体语句;
控制条件语句;
} while((判断条件语句);
特点:先循环后判断,不管条件是否满足,循环体至少执行一次
三种循环语句其实都可以完成一样的功能,也就是说可以等价转换,但还是有小区别的:
(1) do…while循环至少会执行一次循环体。
(2) for循环和while循环只有在条件成立的时候才会去执行循环体
注意事项:
写程序优先考虑for循环,再考虑while循环,最后考虑do…while循环。
4、流程控制语句
break 语句用于终止某个语句块的执行
break的使用场景:
- 在选择结构switch语句中
- 在循环语句中
- 离开使用场景的存在是没有意义的
break的作用:
- 跳出单层循环
- 跳出多层循环
(1)带标签的跳出
(2) 格式:标签名: 循环语句
(3) 标签名要符合Java的命名规则
continue语句用于跳过某个循环语句块的一次执行
continue的使用场景:
- 在循环语句中
- 离开使用场景的存在是没有意义的
continue的作用:
- 单层循环对比break,然后总结两个的区别
(1) break 退出当前循环
(2) continue 退出本次循环
六、方法
1、方法定义
Java的方法类似于其它语言的函数,是一段用来完成特定功能的代码 片段,声明格式:
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2…) {
函数体;
return 返回值;
说明:
- 形式参数(形参):方法被调用时用亍接收外界输入的数据
- 实际参数(实参):调用方法时实际传给方法的数据。
- 返回值类型:方法要返回的结果的数据类型。
- 若一个方法没有迒回值,必须给出迒回值类型void
- 返回值:方法在执行完毕后迒迓给调用者的数据。
- return语句终止方法的运行,并指定要返回的数据。
2、方法的特点
- 定义方法可以将功能代码迕行封装,便于对该功能进行复用
- 对于方法没有具体返回值的情况,返回值类型用关键字void表示,那么该方法中的return语句如果在最后一行可以省略不写。
注意:
- 方法只有被调用才会被执行
- 方法与方法是平级关系,不能嵌套定义
- 使用方法时,方法的结果应该返回给调用者,交由调用者处理。
3、方法重载
在同一个类中,允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可。
方法重载点:
- 与返回值类型无关,只看方法名和参数列表
- 在调用时,JVM通过参数列表的不同来区分同名方法
七、数组
一维数组
1、数组概述
- 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
- 数组既可以存储基本数据类型,也可以存储引用数据类型。
2、数组的声明
一维数组的声明方式:
(1)数据类型 [ ] 数组名;
(2)数据类型 数组名[ ];
例:
int a[];
int[] a;
double b[];
3、数组对象的创建
Java中使用关键字new来创建数组对象
格式:数据类型[] 数组名 = new 数据类型[数组的长度]
数组一旦被创建,就不能再改变它的大小
创建数组对象:
//创建长度为10的int类型数组a
int[] arr = new int[3];
System.out.println(arr); //返回的是数组的地址
System.out.println(arr[0]); //返回数组中第一个默认值
System.out.println(arr[1]); //返回数组中第二个默认值
System.out.println(arr[2]); //返回数组中第三个默认值
4、数组元素的引用
数组元素的引用方式:arrayName[index]
index为数组元素下标(索引),可以是整型常量或整型表达式。如:a[3] , b[i] , c[6*i];
(1) 数组元素下标从0开始
(2) 长度为n的数组,下标取值范围:0 ~ n-1;
(3)每个数组都有一个属性length指明它的长度
public class ArrayDemo {
public static void main(String[] args) {
int[] a = new int[6];
for(int i = 0; i < a.length;i++) {
System.out.print(a[i] + "");
}
}
}
5、数组元素的初始化
(1)动态初始化:
动态初始化:初始化时只指定数组长度,由系统为数组分配初始值。
格式:数据类型[] 数组名 = new 数据类型[数组长度];(数组长度其实就是数组中元素的个数。)
举例:
int[] arr = new int[3];
解释:定义了一个int类型的数组,这个数组中可以存放3个int类型的值。
(2)静态初始化:
静态初始化:初始化时指定每个数组元素的初始值,由系统决定数组长度。
格式:数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
简化写法:元素的数据类型[] 数组名 = {元素1,元素2.....}
举例:
int[] arr = new int[]{1,2,3};
解释:定义了一个int类型的数组,这个数组中可以存放3个int类型的值,并且值分别是1,2,3。
其实这种写法还有一个简化的写法
int[] arr = {1,2,3};
二维数组
二维数组的概述:其实二维数组其实就是一个元素为一维数组的数组。
格式1:数据类型[][] 变量名 = new 数据类型[m][n];
(m表示这个二维数组有多少个一维数组;n表示每一个一维数组的元素个数)
举例:
int[][] arr = new int[3][2];
定义了一个二维数组arr
这个二维数组有3个一维数组,名称是arr[0],arr[1],arr[2]
每个一维数组有2个元素,可以通过arr[m][n]来获取
表示获取第m+1个一维数组的第n+1个元素
格式2:数据类型[ ][ ] 变量名 = new 数据类型[m][ ];
(m表示这个二维数组有多少个一维数组,这一次没有直接给出一维数组的元素个数,可以动态的给出。)
举例:
//数加有3个班级,1班有3个人,2班有4个人,3班有5
//使用二维数组进行表示
int[][] arr = new int[3][];
//创建1班的一维数组赋值到二维数组中
arr[0]=new int[]{11,22,33};
//创建2班的一维数组赋值到二维数组中
arr[1]=new int[]{100,200,300,400};
//创建3班的一维数组赋值到二维数组中
arr[2]=new int[]{1,2,3,4,5};
格式3:数据类型[ ][ ] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版格式:数据类型[ ][ ] 变量名 = {{元素…},{元素…},{元素…}};
举例:
int[][] arr = {{1,2,3},{4,6},{6}};
二维数组的遍历
public class Array2Demo4 {
public static void main(String[] args) {
int[][] shujia = new int[][]{{11, 22, 33}, {100, 200, 300, 400}, {1, 2, 3, 4, 5}};
//二维数组遍历
for (int i = 0; i < shujia.length; i++) {
System.out.println("正在遍历第" + (i + 1) + "个一维数组元素:");
for (int j = 0; j < shujia[i].length; j++) {
// System.out.println(shujia[i][j]);
if (j == 0) {
System.out.print("[" + shujia[i][j] + ",");
} else if (j == shujia[i].length - 1) {
System.out.println(shujia[i][j] + "]");
} else {
System.out.print(shujia[i][j] + ",");
}
}
}
}
}
结果如下图所示:
正在遍历第1个一维数组的元素:
[11,22,33]
正在遍历第2个一维数组的元素:
[100,200,300,400]
正在遍历第3个一维数组的元素:
[1,2,3,4,5]