变量:程序中要记录数据内容时,在内存中开启一个存储单元,这个存储单元中的内容会发生改变,所以称作变量
如:int num = 10; 数据类型 变量名 = 初始值;
变量声明注意事项:
- 声明变量时必须指定数据类型
- 变量使用之前必须初始化
- 变量不能重复声明
标识符命名规则
- 由字母、数字、下划线和$组成,不能以数字开头
- 不能使用 java中的关键字
3.区分大小写,变量长度不宜过长
4.尽量做到见名知意,不使用中文
JAVA数据类型分类
1、基本数据类型:
整数型:byte、short、int、long
浮点型:float、double
字符型:char
布尔型:boolean
2、引用数据类型
数组、类、接口、枚举、标注
数据类型范围:
浮点类型:float和double
float类型在内存空间占4个字节,叫单精度浮点数,表示7位有效数字,范围:-3.403E38~3.403E38
double类型在内存空间占8个字节,叫双精度浮点数,表示15位有效数字,范围:-1.798E308~1.798E308
double多出来的四个字节可以忽略不计,但是多出来8个有效位数,使用小数时可用double类型声明变量。
java程序中直接写出的小数数据叫做直接量,默认为double类型,如果希望表达float类型的直接量,则需要在直接量的后面加上F或者f
布尔类型:java中用于描述真假信息类型有:boolean,数值有true和false
字符类型:char类型,用于描述单个字符的数据类型.如’a’,‘中’
Java字符类型采用Unicode字符集编码,Unicode是世界通用的定长字符集,所有的字符都是16位。
" \ 代表 "
'\ 代表 ’
\ \ 代表 \
\t 代表制表符,相当于Tab键
\n代表换行
基本数据类型之间的转换(隐式转换):
Java语言中基本数据类型之间的转换方式:自动类型转化和强制类型转换。
自动类型转换是指小类型到大类型之间的转换。
public static void main(String[] args) {
// 1.声明两个变量并初始化
byte b1 = 10;
short s1 = 20;
// 2.打印变量的数值
System.out.println("b1 = " + b1); // b1 = 10
System.out.println("s1 = " + s1); // s1 = 20
System.out.println("----------------------------------------------");
// 3.实现自动类型转换的使用
// 表示将变量b1的数值赋值给变量s1,并覆盖变量s1中原来的数值,相当于从byte类型到short类型的转换,小到大 自动转换
s1 = b1;
System.out.println("b1 = " + b1); // b1 = 10
System.out.println("s1 = " + s1); // s1 = 10
System.out.println("----------------------------------------------");
// 4.实现强制类型转换的使用
// 表示将变量s1的数值赋值给变量b1,并覆盖变量b1中原来的数值,相当于从short类型到byte类型的转换,大到小 强制转换
//b1 = s1; // 错误: 不兼容的类型: 从short转换到byte可能会有损失
s1 = 128; // 故意加该行代码 128:0000 0000 1000 0000 => 1000 0000 => 0111 1111 => 1000 0000 => 128 => -128
b1 = (byte)s1;
System.out.println("b1 = " + b1); // b1 = 10 -128
System.out.println("s1 = " + s1); // s1 = 10 128
}
强制类型转换:大类型到小类型之间的转换
目标类型 变量名 = (目标类型)源类型变量名;
强转可能会损失精度,造成数据丢失!
常用进制
十进制:逢十进一,十进制权重是:100、101、10^2、…
二进制:逢二进一,二进制权重是:20、21、2^2、…
二进制中最高位(最左边)代表符号位,如果该位数是0代表非负数,如果该位数是1代表负数。
八进制和十六进制都是二进制的简写
进制转换
十进制转二进制的方式:除2取余法,使用十进制整数不断除以2取余数,直到商为0时将余数逆序排序
方法2:拆分法:将十进制整数拆分成若干个二进制权重的和,有该权重下面写1,否则写0。
正二进制转换为十进制的方式:
加权法,使用二进制中的每个数字乘以当前位的权重再累加起来。
负十进制转换为二进制的方式:
负二进制转换为十进制的方法:
错题集(任务一)
随堂测试:
1、下面关于标识符命名法则正确的是( C、D ) 多选
A、标识符可以由数字、字母、下划线以及美元符号任意组合。
B、标志符号名称区分大小写,长度有限。
C、标识符名称中不可以使用数字开头。
D、标识符名称可以支持中文,只是通常不使用
解析:任意组合是不可以的,可以由字母、数字、下划线和$组成,不能以数字开头,区分大小写,变量长度不宜过长
2、属于Java语言中基本数据类型的类型有( A、D ) 多选
A、int
B、Long
C、String
D、double
解析:Long属于包装类,long才是属于基本数据类型,严格区分大小写。String是引用数据类型
运算符
算术运算符
-
+表示加法运算符
-
-表示减法运算符
-
*表示乘法运算符
-
/表示除法运算符
字符串连接运算符
- **+**可以实现字符串的连接。同时可以实现字符串与其它数据类型相连。
只要+号两边的操作数中有一个操作数是字符串类型,则该+就被当做字符串连接符处理,否则当做加法运算符处理
关系/比较运算符
-
> 表示 是否大于运算符 **>= ** 表示是否大于等于运算符
-
< 表示是否小于运算符 <= 表示是否小于等于运算符
-
== 表示是否等于运算符 **!= ** 表示是否不等于运算符
-
所有以关系运算符作为最终运算的表达式结果一定是boolean类型。
自增运算符
-
++ 表示自增运算符,用于使得当前变量自身的数值加1的效果。
-
– 表示自减运算符,用于使得当前变量自身的数值减1的效果。
i++表示先让变量i的数值作为整个表达式的最终结果,然后再让i变量自身的数值加1
++i表示先让变量自身的数值加1,然后再让变量的数值作为整个表达式的结果
public static void main(String[] args) { //1、声明一个变量 int i = 20; //2、打印变量的值 System.out.println("i= " + i); //i=20 System.out.println("***********************"); //变量自增,自增运算符的使用 //数值自增+1,覆盖原来的数值 //**i++表示先让变量i的数值作为整个表达式的最终结果,然后再让i变量自身的数值加1** System.out.println(i++); //i=20 System.out.println(i); //i=21 //**++i表示先让变量自身的数值加1,然后再让变量的数值作为整个表达式的结果** System.out.println(++i); //i=22 System.out.println(i); //i=22 System.out.println("***********************"); //先将变量i的数值作为整个表达式的最终结果 System.out.println(i--); //i=22 //变量自减,打印结果 System.out.println(i); //i=21 System.out.println(--i); //20 System.out.println(i); //20 }
如图,i++是先将数值的结果输出后再进行加1,返回累加后的值,++1是先累加1,再输出结果,返回最终的值。
// 5.笔试考点
int ib = ia++;
System.out.println("ib = " + ib); // 12
System.out.println("ia = " + ia); // 13
int ic = ++ia;
System.out.println("ic = " + ic); // 14
System.out.println("ia = " + ia); // 14
// 14 + 16
System.out.println(ia++ + ++ia); // 30
System.out.println("ia = " + ia); // 16
自增长运算符只能用于变量,不能用于常量!!!
逻辑运算符
-
&&表示逻辑与运算符,相当于"并且",同真为真,一假为假。
-
||表示逻辑或运算符,相当于“或者”,一真为真,同假为假。
-
! 表示逻辑非运算符,相当于“取反”,真为假,假为真。
-
逻辑运算符两边的操作数均为boolean表达式。
举例:
public static void main(String[] args) {
// 1.声明两个boolean类型的变量并初始化
boolean b1 = true;
boolean b2 = false;
// 2.打印变量的数值
System.out.println("b1 = " + b1); // b1 = true
System.out.println("b2 = " + b2); // b2 = false
System.out.println("---------------------------------------------");
// 3.使用上述变量实现逻辑运算符的使用
boolean b3 = b1 && b2;
System.out.println("b3 = " + b3); // false
System.out.println(b1 && b2); // false 并且
System.out.println(b1 || b2); // true 或者
System.out.println(!b1); // false 取反
System.out.println(!b2); // true
System.out.println("---------------------------------------------");
// 4.测试一下短路特性
int ia = 3;
int ib = 5;
// 对于逻辑与运算符来说,若第一个条件为假则整个表达式为假,此时跳过第二个表达式不执行
boolean b4 = (++ia == 3) && (++ib == 5);
System.out.println("b4 = " + b4); // false
System.out.println("ia = " + ia); // 4
System.out.println("ib = " + ib); // 5
// 对于逻辑或运算符来说,若第一个条件为真则整个表达式为真,此时跳过第二个表达式不执行
boolean b5 = (++ia == 5) || (++ib == 5);
System.out.println("b5 = " + b5); // true
System.out.println("ia = " + ia); // 5
System.out.println("ib = " + ib); // 5
}
三目运算符
- 条件表达式?表达式1:表达式2
- 判断条件表达式是否成立,若成立则执行表达式1,否则执行表达式2。
案例:
/*
编程实现案例:
提示用户输入两个整数,使用三目运算符找到最大值并打印出来
*/
import java.util.Scanner;
public class LoginJudgeTest2 {
public static void main(String[] args){
//1、提示用户输入两个整数并使用变量记录
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个整数:");
int num1 = sc.nextInt();
System.out.println("请输入第二个整数:");
int num2 = sc.nextInt();
System.out.println("请输入第三个整数:");
int num3 = sc.nextInt();
//2、使用三目运算符计算出最大值并打印出结果
int temp = num1>num2?num1:num2; //比较num1和num2的最大值,并记录到temp临时变量中
int max = temp>num3?temp:num3; //如果temp大于num3,则temp为三个数中的最大数,并赋值给max变量
//输出最大数
System.out.println("最大数是:"+max);
}
}
赋值运算符
-
= 表示赋值运算符,用于将=右边的数据赋值给=左边的变量,覆盖变量原来的数值。
-
赋值表达式本身也有值,其本身的值即为所赋的值。
-
*+= -= = /= 为复合赋值运算符
-
一个=号表示赋值运算符,两个==号表示比较运算符。
面试题:
i == 2; //判断变量i的数值是否等于2 2 == i; //判断2的值是否等于变量i的值,从结果上来说等价,推荐该方式 i = 2; //将2的值赋值给i,覆盖变量i原来的数值 2 = i; //编译报错,不能覆盖固定的值 错误,意外的类型
移位运算符
举例:
/*
编程实现移位运算符的使用
*/
public class MoveBitTest {
public static void main(String[] args) {
// 1.声明一个byte类型的变量并初始化
byte b1 = 13;
// 2.打印变量的数值
System.out.println("b1 = " + b1); // b1 = 13
System.out.println("---------------------------------------------------");
// 3.移位运算符的使用
// 13的二进制是:... 0000 1101 => 左移1位的结果是:... 0001 1010 => 换算为十进制整数是:26
//byte b2 = b1 << 1; // 错误: 不兼容的类型: 从int转换到byte可能会有损失 自动提升为int类型,也就是32位二进制
byte b2 = (byte)(b1 << 1);
System.out.println("b2 = " + b2); // 26
System.out.println(b1 << 1); // 26 左移1位相当于当前整数的数值*2
System.out.println(b1 << 2); // 52 左移2位相当于当前整数的数值*4
System.out.println("---------------------------------------------------");
// 13的二进制是:... 0000 1101 => 右移1位的结果是:... 0000 0110 => 换算为十进制整数是:6
System.out.println(b1 >> 1); // 6 右移1位相当于当前整数的数值/2
System.out.println(b1 >> 2); // 3 右移2位相当于当前整数的数值/4
System.out.println("---------------------------------------------------");
// 逻辑右移 对于非负数来说,逻辑右移和右移的效果一致
System.out.println(b1 >>> 2); // 3
}
}
位运算符
/*
编程实现位运算符的使用
*/
public class BitTest {
public static void main(String[] args) {
// 1.声明两个byte类型的变量并初始化
byte b1 = 11;
byte b2 = 13;
// 2.打印变量的数值
System.out.println("b1 = " + b1); // b1 = 11
System.out.println("b2 = " + b2); // b2 = 13
System.out.println("---------------------------------------------------");
// 3.实现位运算符的使用
// b1的二进制为: 0000 1011
// b2的二进制为: 0000 1101
System.out.println( b1 & b2); // 按位与:同1为1,一0为0 按位与后的二进制为:0000 1001 => 转为十进制是:9
System.out.println( b1 | b2); // 按位或:一1为1,同0为0 按位或后的二进制为:0000 1111 => 转为十进制是:15
System.out.println( b1 ^ b2); // 按位异或:相同为0,不同为1 按位异或的二进制为:0000 0110 => 转为十进制是:6
System.out.println( ~ b1); // 按位取反:1为0,0为1 按位取反的二进制为:1111 0100
// 二进制1111 0100转为十进制 => 先减1: 1111 0011 => 按位取反:0000 1100 => 转为十进制:12 => 添加负号:-12
}
}
运算符的优先级
- ()的优先级极高
- =的优先级极低
- 若无法确定优先级,则使用()来确保即可。
流程控制语句
if分支结构
if (条件表达式) {
语句块;
}
判断条件表达式是否成立
=> 若成立,则执行语句块;
=>若不成立,则跳过语句块;
if else分支结构
判断条件表达式是否成立
=> 若成立,则执行语句块1
=>若不成立,则跳过语句块2
使用if的场景是只判断一个条件是否满足,如果判断两个条件则用if else分支结构,满足就进入if结构,不满足就进入else分支结构,两者永远没有交集。
ifelse if else分支结构
当有三种或者三种以上的情况时,可以用if else if else分支结构,但是大括号中的只能进入一个分支结构。
switch case 分支结构
switch()中支持的数据类型有: byte、short、char以及int类型,从jdk1.5开始支持枚举类型,从jdk1.7开始支持String类型。
for循环
for循环执行流程:
执行初始化表达式 => 判断条件表达式是否成立
=>成立则执行循环体 => 修改初始值表达式 => 判断条件是否成立
=>若不成立,则循环结束
双重for循环
双重for循环的特点:
- 外层循环用于控制打印的行数,内层循环用于控制打印的列数,外层循环改一下,内层循环从头到尾跑一圈。
- 在以后的开发中若需要打印多行多列时,须使用双重循环。
- 多重循环不宜嵌套太多层,否则效率很低。一般三重循环即可,最常见的就是双重循环。
while循环
判断条件表达式是否成立
=>若成立,则执行循环体 =>判断条件表达式是否成立
=>若不成立,则循环结束
while与for循环的区别
- while循环和for循环完全可以互换,当然推荐使用for循环。
- while循环更适合于明确条件但不明确循环次数的场合中。
- for循环更适合于明确次数或者范围的场合。
- while(true)等价于for(;;)都表示无限循环。
do while循环
while循环与do while循环的区别:
- while循环先判断条件是否成立,再执行循环体,条件不成立则不执行循环体。
- do while循环不论条件是否成立,至少执行一次循环,如果成立,则继续执行循环体。
总结
-
分支结构:if分支结构、if else分支结构、if else if else分支结构、switch case分支结构
-
循环结构:for循环、break和continue关键字、双重for循环、while循环、do while循环
数组及应用
一维数组的基本概念
- 当需要在Java程序中记录单个数据内容时,则声明一个变量即可。
- 当需要在Java程序中记录多个类型相同的数据内容时,则声明一个一维数组即可,一维数组本质上就是在内存空间中申请一段连续的存储单元。
- 数组是相同数据类型的多个元素的容器,元素按线性顺序排列,在Java语言中体现为一种引用数据类型。
一维数组声明方式方式
- 数据类型[] 数组名称 = new 数据类型[数组长度];
- 调用数组的length属性可以获取数组的长度;
- 可以通过下标的方式访问数组中的每一个元素。需要注意的是:数组的下标从0开始,对于长度为n的数组,下标的范围是0~n-1。
一维数组的初始方式
数组的优缺点
- 可以直接通过下标(或索引)的方式访问指定位置的元素,速度很快。
- 数组要求所有元素类型相同。
- 数组要求内存空间连续,并且长度一旦确定就不能修改。
- 增加和删除元素可能移动大量元素,效率低。
数组工具类的常用方法
二维数组
二维数组的声明和初始化方式
-
数据类型[][] 数组名称 = new 数据类型[][];
-
当需要在Java程序中记录多个类型相同的数据内容时,则声明一个一维数组即可,一维数组本质上就是在内存空间中申请一段连续的存储单元。
-
数组是相同数据类型的多个元素的容器,元素按线性顺序排列,在Java语言中体现为一种引用数据类型。
一维数组声明方式
- 数据类型[] 数组名称 = new 数据类型[数组长度];
- 调用数组的length属性可以获取数组的长度;
- 可以通过下标的方式访问数组中的每一个元素。需要注意的是:数组的下标从0开始,对于长度为n的数组,下标的范围是0~n-1。
一维数组的初始方式
数组的优缺点
- 可以直接通过下标(或索引)的方式访问指定位置的元素,速度很快。
- 数组要求所有元素类型相同。
- 数组要求内存空间连续,并且长度一旦确定就不能修改。
- 增加和删除元素可能移动大量元素,效率低。