class
、public
、 static
、 void
等,这些单词已经被Java定义好了。小写字母
。说明:
- 关键字一共
50个
,其中const
和goto
是保留字
(reserved word)。true
,false
,null
不在其中,它们看起来像关键字,其实是字面量,表示特殊的布尔值和空值。
Java中变量、方法、类等要素命名时使用的字符序列,称为标识符。
技巧:凡是自己可以起名字的地方都叫标识符。
标识符的命名规则(必须遵守的硬性规定
):
> 由26个英文字母大小写,0-9 ,_或 $ 组成
> 数字不可以开头。
> 不可以使用关键字和保留字,但能包含关键字和保留字。
> Java中严格区分大小写,长度无限制。
> 标识符不能包含空格。
练习:miles、Test、a++、 --a、4#R、$4、 #44、apps、class、public、int、x、y、radius
标识符的命名规范(建议遵守的软性要求
,否则工作时容易被鄙视):
> 包名:多单词组成时所有字母都小写:xxxyyyzzz。
例如:java.lang、com.atguigu.bean
> 类名、接口名:多单词组成时,所有单词的首字母大写:XxxYyyZzz
例如:HelloWorld,String,System等
> 变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写:xxxYyyZzz
例如:age,name,bookName,main,binarySearch,getName
> 常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ
例如:MAX_VALUE,PI,DEFAULT_CAPACITY
注意:在起名字时,为了提高阅读性,要尽量有意义,“见名知意”。
更多细节详见《代码整洁之道_关于标识符.txt》《阿里巴巴Java开发手册-1.7.1-黄山版》
一花一世界,如果把一个程序看做一个世界或一个社会的话,那么变量就是程序世界的花花草草、万事万物。即,变量是程序中不可或缺的组成单位,最基本的存储单元。
变量的概念:
变量的作用:用于在内存中保存数据。
使用变量注意:
作用域
内才有效。出了作用域,变量不可以再被调用。Java中变量的数据类型分为两大类:
格式:数据类型 变量名;
//例如:
//存储一个整数类型的年龄
int age;
//存储一个小数类型的体重
double weight;
//存储一个单字符类型的性别
char gender;
//存储一个布尔类型的婚姻状态
boolean marry;
//存储一个字符串类型的姓名
String name;
//声明多个同类型的变量
int a,b,c; //表示a,b,c三个变量都是int类型。
注意:变量的数据类型可以是基本数据类型,也可以是引用数据类型。
给变量赋值,就是把“值”存到该变量代表的内存空间中。同时,给变量赋的值类型必须与变量声明的类型一致或兼容。
变量赋值的语法格式:
变量名 = 值;
举例1:可以使用合适类型的常量值
给已经声明的变量赋值
age = 18;
weight = 109;
gender = '女';
举例2:可以使用其他变量
或者表达式
给变量赋值
int m = 1;
int n = m;
int x = 1;
int y = 2;
int z = 2 * x + y;
3:变量可以反复赋值
//先声明,后初始化
char gender;
gender = '女';
//给变量重新赋值,修改gender变量的值
gender = '男';
System.out.println("gender = " + gender);//gender = 男
举例4:也可以将变量的声明和赋值一并执行
boolean isBeauty = true;
String name = "迪丽热巴";
内存结构如图:
定义long类型的变量,赋值时需要以"l
"或"L
"作为后缀。
Java程序中变量通常声明为int型,除非不足以表示较大的数,才使用long。
Java的整型常量默认为 int 型
。
**字节(Byte):**是计算机用于计量存储容量
的基本
单位,一个字节等于8 bit。
**位(bit):**是数据存储的最小
单位。二进制数系统中,每个0或1就是一个位,叫做bit(比特),其中8 bit 就称为一个字节(Byte)。
转换关系:
单精度
,尾数可以精确到7位有效数字。很多情况下,精度很难满足需求。双精度
,精度是float的两倍。通常采用此类型。f
"或"F
"作为后缀。常量默认为double型
。并不是所有的小数都能可以精确的用二进制浮点数表示。二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。
浮点类型float、double的数据不适合在不容许舍入误差
的金融计算领域。如果需要精确
数字计算或保留指定位数的精度,需要使用BigDecimal类
。
测试用例:
//测试1:(解释见章末企业真题:为什么0.1 + 0.2不等于0.3)
System.out.println(0.1 + 0.2);//0.30000000000000004
//测试2:
float ff1 = 123123123f;
float ff2 = ff1 + 1;
System.out.println(ff1);
System.out.println(ff2);
System.out.println(ff1 == ff2);
案例1:定义圆周率并赋值为3.14,现有3个圆的半径分别为1.2、2.5、6,求它们的面积。
/**
* @author 尚硅谷-宋红康
* @create 12:36
*/
public class Exercise1 {
public static void main(String[] args) {
double PI = 3.14; //圆周率
double radius1 = 1.2;
double radius2 = 2.5;
int radius3 = 6;
System.out.println("第1个圆的面积:" + PI * radius1 * radius1);
System.out.println("第2个圆的面积:" + PI * radius2 * radius2);
System.out.println("第3个圆的面积:" + PI * radius3 * radius3);
}
}
案例2:小明要到美国旅游,可是那里的温度是以华氏度为单位记录的。
它需要一个程序将华氏温度(80度)转换为摄氏度,并以华氏度和摄氏度为单位分别显示该温度。
℃ = (℉ - 32) / 1.8
/**
* @author 尚硅谷-宋红康
* @create 12:51
*/
public class Exercise2 {
public static void main(String[] args) {
double hua = 80;
double she = (hua-32)/1.8;
System.out.println("华氏度" + hua+"℉转为摄氏度是" +she+"℃");
}
}
char 型数据用来表示通常意义上“字符
”(占2字节)
Java中的所有字符都使用Unicode编码,故一个字符可以存储一个字母,一个汉字,或其他书面语的一个字符。
字符型变量的三种表现形式:
**形式1:**使用单引号(’ ')括起来的单个字符
。
例如:char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;
**形式2:**直接使用 Unicode值
来表示字符型常量:‘\uXXXX
’。其中,XXXX代表一个十六进制整数。
例如:\u0023 表示 ‘#’。
**形式3:**Java中还允许使用转义字符‘\’
来将其后的字符转变为特殊字符型常量。
例如:char c3 = ‘\n’; // '\n’表示换行符
转义字符 | 说明 | Unicode表示方式 |
---|---|---|
\n |
换行符 | \u000a |
\t |
制表符 | \u0009 |
\" |
双引号 | \u0022 |
\' |
单引号 | \u0027 |
\\ |
反斜线 | \u005c |
\b |
退格符 | \u0008 |
\r |
回车符 | \u000d |
char类型是可以进行运算的。因为它都对应有Unicode码,可以看做是一个数值。
boolean 类型用来判断逻辑条件,一般用于流程控制语句中:
boolean类型数据只有两个值:true、false,无其它。
举例:
boolean isFlag = true;
if(isFlag){
//true分支
}else{
//false分支
}
经验之谈:
Less is More!建议不要这样写:if ( isFlag = = true ),只有新手才如此。关键也很容易写错成if(isFlag = true),这样就变成赋值isFlag为true而不是判断!
老鸟的写法
是if (isFlag)或者if ( !isFlag)。
在Java程序中,不同的基本数据类型(只有7种,不包含boolean类型)变量的值经常需要进行相互转换。
转换的方式有两种:自动类型提升
和强制类型转换
。
规则:将取值范围小(或容量小)的类型自动提升为取值范围大(或容量大)的类型 。
基本数据类型的转换规则如图所示:
(1)当把存储范围小的值(常量值、变量的值、表达式计算的结果值)赋值给了存储范围大的变量时
int i = 'A';//char自动升级为int,其实就是把字符的编码值赋值给i变量了
double d = 10;//int自动升级为double
long num = 1234567; //右边的整数常量值如果在int范围呢,编译和运行都可以通过,这里涉及到数据类型转换
//byte bigB = 130;//错误,右边的整数常量值超过byte范围
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围,必须加L,显式表示long类型。否则编译不通过
(2)当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时,会按照其中最大的类型运算。
int i = 1;
byte b = 1;
double d = 1.0;
double sum = i + b + d;//混合运算,升级为double
(3)当byte,short,char数据类型的变量进行算术运算时,按照int类型处理。
byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错,b1 + b2自动升级为int
char c1 = '0';
char c2 = 'A';
int i = c1 + c2;//至少需要使用int类型来接收
System.out.println(c1 + c2);//113
练习:
设 x 为float型变量,y为double型变量,a为int型变量,b为long型变量,c为char型变量,则表达式
x + y * a / x + b / y + c的值类型为:
A. int B. long C. double D. char
将3.14
赋值到int
类型变量会发生什么?产生编译失败,肯定无法赋值。
int i = 3.14; // 编译报错
想要赋值成功,只有通过强制类型转换
,将double
类型强制转换成int
类型才能赋值。
规则:将取值范围大(或容量大)的类型强制转换成取值范围小(或容量小)的类型。
自动类型提升是Java自动执行的,而强制类型转换是自动类型提升的逆运算,需要我们自己手动执行。
转换格式:
数据类型1 变量名 = (数据类型1)被强转数据值; //()中的数据类型必须<=变量值的数据类型
(1)当把存储范围大的值(常量值、变量的值、表达式计算的结果值)强制转换为存储范围小的变量时,可能会损失精度
或溢出
。
int i = (int)3.14;//损失精度
double d = 1.2;
int num = (int)d;//损失精度
int i = 200;
byte b = (byte)i;//溢出
(2)当某个值想要提升数据类型时,也可以使用强制类型转换。这种情况的强制类型转换是没有风险
的,通常省略。
int i = 1;
int j = 2;
double bigger = (double)(i/j);
(3)声明long类型变量时,可以出现省略后缀的情况。float则不同。
long l1 = 123L;
long l2 = 123;//如何理解呢? 此时可以看做是int类型的123自动类型提升为long类型
//long l3 = 123123123123; //报错,因为123123123123超出了int的范围。
long l4 = 123123123123L;
//float f1 = 12.3; //报错,因为12.3看做是double,不能自动转换为float类型
float f2 = 12.3F;
float f3 = (float)12.3;
练习:判断是否能通过编译
1)short s = 5;
s = s-2; //判断:no
2) byte b = 3;
b = b + 4; //判断:no
b = (byte)(b+4); //判断:yes
3)char c = ‘a’;
int i = 5;
float d = .314F;
double result = c+i+d; //判断:yes
4) byte b = 5;
short s = 3;
short t = s + b; //判断:no
问答:为什么标识符的声明规则里要求不能数字开头?
//如果允许数字开头,则如下的声明编译就可以通过:
int 123L = 12;
//进而,如下的声明中l的值到底是123?还是变量123L对应的取值12呢? 出现歧义了。
long l = 123L;
""
来表示一个字符串,内部可以包含0个、1个或多个字符。1、任意八种基本数据类型的数据与String类型只能进行连接“+”运算,且结果一定也是String类型
System.out.println("" + 1 + 2);//12
int num = 10;
boolean b1 = true;
String s1 = "abc";
String s2 = s1 + num + b1;
System.out.println(s2);//abc10true
//String s3 = num + b1 + s1;//编译不通过,因为int类型不能与boolean运算
String s4 = num + (b1 + s1);//编译通过
2、String类型不能通过强制类型()转换,转为其他的类型
String str = "123";
int num = (int)str;//错误的
int num = Integer.parseInt(str);//正确的,后面才能讲到,借助包装类的方法才能转
案例:公安局身份登记
要求填写自己的姓名、年龄、性别、体重、婚姻状况(已婚用true表示,单身用false表示)、联系方式等等。
/**
* @author 尚硅谷-宋红康
* @create 12:34
*/
public class Info {
public static void main(String[] args) {
String name = "康师傅";
int age = 37;
char gender = '男';
double weight = 145.6;
boolean isMarried = true;
String phoneNumber = "13112341234";
System.out.println("姓名:" + name);
System.out.println("年龄:" + age);
System.out.println("性别:" + gender);
System.out.println("体重:" + weight);
System.out.println("婚否:" + isMarried);
System.out.println("电话:" + phoneNumber);
//或者
System.out.println("name = " + name + ",age = " + age + ",gender = " +
gender + ",weight = " + weight + ",isMarried = " + isMarried +
",phoneNumber = " + phoneNumber);
}
}
练习:
练习1:
String str1 = 4; //判断对错:
String str2 = 3.5f + ""; //判断str2对错:
System.out.println(str2); //输出:
System.out .println(3+4+"Hello!"); //输出:
System.out.println("Hello!"+3+4); //输出:
System.out.println('a'+1+"Hello!"); //输出:
System.out.println("Hello"+'a'+1); //输出:
练习2:
System.out.println("* *"); //输出:
System.out.println("*\t*"); //输出:
System.out.println("*" + "\t" + "*"); //输出:
System.out.println('*' + "\t" + "*"); //输出:
System.out.println('*' + '\t' + "*"); //输出:
System.out.println('*' + "\t" + '*'); //输出:
System.out.println("*" + '\t' + '*'); //输出:
System.out.println('*' + '\t' + '*'); //输出:
计算机世界中只有二进制,所以计算机中存储和运算的所有数据
都要转为二进制
。包括数字、字符、图片、声音、视频等。
世界上有10种人 ,认识和不认识二进制的。
十进制(decimal)
二进制(binary)
0b
或0B
开头八进制(octal):很少使用
0
开头表示十六进制
0x
或0X
开头表示。此处的 a-f 不区分大小写代码演示:
class BinaryTest {
public static void main(String[] args) {
int num1 = 123; //十进制
int num2 = 0b101; //二进制
int num3 = 0127; //八进制
int num4 = 0x12aF; //十六进制
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
System.out.println(num4);
}
}
十进制 | 二进制 | 八进制 | 十六进制 |
---|---|---|---|
0 | 0 | 0 | 0 |
1 | 1 | 1 | 1 |
2 | 10 | 2 | 2 |
3 | 11 | 3 | 3 |
4 | 100 | 4 | 4 |
5 | 101 | 5 | 5 |
6 | 110 | 6 | 6 |
7 | 111 | 7 | 7 |
8 | 1000 | 10 | 8 |
9 | 1001 | 11 | 9 |
10 | 1010 | 12 | a或A |
11 | 1011 | 13 | b或B |
12 | 1100 | 14 | c或C |
13 | 1101 | 15 | d或D |
14 | 1110 | 16 | e或E |
15 | 1111 | 17 | f或F |
16 | 10000 | 20 | 10 |
二进制,是计算技术中广泛采用的一种数制,由德国数理哲学大师莱布尼茨
于1679年发明。
二进制数据是用0和1两个数码来表示的数。它的基数为2,进位规则是“逢二进一
”。
二进制广泛应用于我们生活的方方面面。比如,广泛使用的摩尔斯电码(Morse Code),它由两种基本信号组成:短促的点信号“·
”,读“滴
”;保持一定时间的长信号“—
”,读“嗒
”。然后,组成了26个字母,从而拼写出相应的单词。
记忆技巧:
我们偶尔会看到的:SOS,即为:
二进制如何表示整数?
计算机数据的存储使用二进制补码
形式存储,并且最高位是符号位
。
最高位是0
最高位是1
规 定
三码合一
原码
:把十进制转为二进制,然后最高位设置为1反码
:在原码的基础上,最高位不变,其余位取反(0变1,1变0)补码
:反码+1二进制转十进制:权相加法
针对于byte数据举例来说:
例如:byte类型(1个字节,8位)
25 ==> 原码 0001 1001 ==> 反码 0001 1001 -->补码 0001 1001
-25 ==>原码 1001 1001 ==> 反码1110 0110 ==>补码 1110 0111
整数:
正数:25 00000000 00000000 000000000 00011001(原码)
正数:25 00000000 00000000 000000000 00011001(反码)
正数:25 00000000 00000000 000000000 00011001(补码)
负数:-25 10000000 00000000 000000000 00011001(原码)
负数:-25 11111111 11111111 111111111 11100110(反码)
负数:-25 11111111 11111111 111111111 11100111(补码)
一个字节可以存储的整数范围是多少?
//1个字节:8位
0000 0001 ~ 0111 111 ==> 1~127
1000 0001 ~ 1111 1111 ==> -127 ~ -1
0000 0000 ==>0
1000 0000 ==> -128(特殊规定)=-127-1
十进制转二进制:除2取余的逆
二进制转八进制
二进制转十六进制
八进制、十六进制转二进制
练习:
1.将以下十进制数转换为十六进制和二进制
123 256 87 62
2.将以下十六进制数转换为十进制和二进制
0x123 0x25F 0x38 0x62
运算符是一种特殊的符号,用以表示数据的运算、赋值和比较等。
运算符的分类:
功能
分为:算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、Lambda运算符分类 | 运算符 |
---|---|
算术运算符(7个) | +、-、*、/、%、++、– |
赋值运算符(12个) | =、+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、|=、^=等 |
比较(或关系)运算符(6个) | >、>=、<、<=、==、!= |
逻辑运算符(6个) | &、|、^、!、&&、|| |
位运算符(7个) | &、|、^、~、<<、>>、>>> |
条件运算符(1个) | (条件表达式)?结果1:结果2 |
Lambda运算符(1个) | ->(第18章时讲解) |
操作数个数
分为:一元运算符(单目运算符)、二元运算符(双目运算符)、三元运算符 (三目运算符)分类 | 运算符 |
---|---|
一元运算符(单目运算符) | 正号(+)、负号(-)、++、–、!、~ |
二元运算符(双目运算符) | 除了一元和三元运算符剩下的都是二元运算符 |
三元运算符 (三目运算符) | (条件表达式)?结果1:结果2 |
举例1:加减乘除模
public class ArithmeticTest1 {
public static void main(String[] args) {
int a = 3;
int b = 4;
System.out.println(a + b);// 7
System.out.println(a - b);// -1
System.out.println(a * b);// 12
System.out.println(a / b);// 计算机结果是0,为什么不是0.75呢?
System.out.println(a % b);// 3
//结果与被模数符号相同
System.out.println(5%2);//1
System.out.println(5%-2);//1
System.out.println(-5%2);//-1
System.out.println(-5%-2);//-1
//商*除数 + 余数 = 被除数
//5%-2 ==>商是-2,余数时1 (-2)*(-2)+1 = 5
//-5%2 ==>商是-2,余数是-1 (-2)*2+(-1) = -4-1=-5
}
}
举例2:“+”号的两种用法
+
两边都是数值的话,+
就是加法的意思+
两边至少有一边是字符串的话,+
就是拼接的意思public class ArithmeticTest2 {
public static void main(String[] args) {
// 字符串类型的变量基本使用
// 数据类型 变量名称 = 数据值;
String str1 = "Hello";
System.out.println(str1); // Hello
System.out.println("Hello" + "World"); // HelloWorld
String str2 = "Java";
// String + int --> String
System.out.println(str2 + 520); // Java520
// String + int + int
// String + int
// String
System.out.println(str2 + 5 + 20); // Java520
}
}
举例3:自加自减运算
理解:++
运算,表示自增1
。同理,--
运算,表示自减1
,用法与++ 一致。
1、单独使用
前++
和变量后++
,是没有区别的。前++
:例如 ++a
。后++
:例如 a++
。public class ArithmeticTest3 {
public static void main(String[] args) {
// 定义一个int类型的变量a
int a = 3;
//++a;
a++;
// 无论是变量前++还是变量后++,结果都是4
System.out.println(a);
}
}
2、复合使用
其他变量放在一起使用
或者和输出语句放在一起使用
,前++
和后++
就产生了不同。前++
:变量先自增1,然后再运算。后++
:变量先运算,然后再自增1。public class ArithmeticTest4 {
public static void main(String[] args) {
// 其他变量放在一起使用
int x = 3;
//int y = ++x; // y的值是4,x的值是4,
int y = x++; // y的值是3,x的值是4
System.out.println(x);
System.out.println(y);
System.out.println("==========");
// 和输出语句一起
int z = 5;
//System.out.println(++z);// 输出结果是6,z的值也是6
System.out.println(z++);// 输出结果是5,z的值是6
System.out.println(z);
}
}
案例1:
随意给出一个整数,打印显示它的个位数,十位数,百位数的值。
格式如下:
数字xxx的情况如下:
个位数:
十位数:
百位数:
例如:
数字153的情况如下:
个位数:3
十位数:5
百位数:1
class ArithmeticExer1 {
public static void main(String[] args) {
int num = 187;
int bai = num / 100;
int shi = num % 100 / 10;//int shi = num / 10 % 10;
int ge = num % 10;
System.out.println("百位为:" + bai);
System.out.println("十位为:" + shi);
System.out.println("个位为:" + ge);
}
}
拓展:获取一个四位数的个位,十位,百位,千位
public class ArithmeticExer01 {
public static void main (String [] args) {
//1.定义一个变量,赋值为一个四位数整数,例如1234
int num = 1234;
//2.通过运算操作求出个位,十位,百位,千位
int ge = num % 10;
int shi = num /10 % 10;
int bai = num /100 % 10;
int qian = num / 1000 % 10;
System.out.println("个位上的数字是:" + ge);
System.out.println("十位上的数字是:" + shi);
System.out.println("百位上的数字是:" + bai);
System.out.println("千位上的数字是:" + qian);
}
}
**案例2:**为抵抗洪水,战士连续作战89小时,编程计算共多少天零多少小时?
public class ArithmeticExer2 {
public static void main(String[] args){
int hours = 89;
int day = hours / 24;
int hour = hours % 24;
System.out.println("为抵抗洪水,战士连续作战89小时:");
System.out.println(hours + "是" + day + "天" + hour +"小时");
}
}
练习1:算术运算符:自加、自减
public class ArithmeticExer3{
public static void main(String[] args){
int i1 = 10;
int i2 = 20;
int i = i1++;
System.out.print("i="+i); //
System.out.println("i1="+i1);//
i = ++i1;
System.out.print("i="+i);//
System.out.println("i1="+i1);//
i = i2--;
System.out.print("i="+i);//
System.out.println("i2="+i2);//
i = --i2;
System.out.print("i="+i);//
System.out.println("i2="+i2);//
}
}
练习2:
System.out.println("5+5=" + 5 + 5); //打印结果是? 5+5=55 ?
练习3:
byte bb1 = 127;
bb1++;
System.out.println("bb1 = " + bb1);//-128
练习4:
int i = 1;
int j = i++ + ++i * i++;
System.out.println("j = " + j);
练习5:(企业真题)写出下列程序的输出结果
int i = 2;
int j = i++;
System.out.println(j);
int m = 2;
m = m++; //(1)先取b的值“2”放操作数栈 (2)m再自增,m=3 (3)再把操作数栈中的"2"赋值给m,m=2
System.out.println(m);
符号:=
连续赋值
。扩展赋值运算符: +=、 -=、*=、 /=、%=
赋值运算符 | 符号解释 |
---|---|
+= |
将符号左边的值 和右边的值 进行相加 操作,最后将结果赋值给左边的变量 |
-= |
将符号左边的值 和右边的值 进行相减 操作,最后将结果赋值给左边的变量 |
*= |
将符号左边的值 和右边的值 进行相乘 操作,最后将结果赋值给左边的变量 |
/= |
将符号左边的值 和右边的值 进行相除 操作,最后将结果赋值给左边的变量 |
%= |
将符号左边的值 和右边的值 进行取余 操作,最后将结果赋值给左边的变量 |
public class SetValueTest1 {
public static void main(String[] args) {
int i1 = 10;
long l1 = i1; //自动类型转换
byte bb1 = (byte)i1; //强制类型转换
int i2 = i1;
//连续赋值的测试
//以前的写法
int a1 = 10;
int b1 = 10;
//连续赋值的写法
int a2,b2;
a2 = b2 = 10;
int a3 = 10,b3 = 20;
//举例说明+= -= *= /= %=
int m1 = 10;
m1 += 5; //类似于 m1 = m1 + 5的操作,但不等同于。
System.out.println(m1);//15
//练习1:开发中,如何实现一个变量+2的操作呢?
// += 的操作不会改变变量本身的数据类型。其他拓展的运算符也如此。
//写法1:推荐
short s1 = 10;
s1 += 2; //编译通过,因为在得到int类型的结果后,JVM自动完成一步强制类型转换,将int类型强转成short
System.out.println(s1);//12
//写法2:
short s2 = 10;
//s2 = s2 + 2;//编译报错,因为将int类型的结果赋值给short类型的变量s时,可能损失精度
s2 = (short)(s2 + 2);
System.out.println(s2);
//练习2:开发中,如何实现一个变量+1的操作呢?
//写法1:推荐
int num1 = 10;
num1++;
System.out.println(num1);
//写法2:
int num2 = 10;
num2 += 1;
System.out.println(num2);
//写法3:
int num3 = 10;
num3 = num3 + 1;
System.out.println(num3);
}
}
练习1:
short s = 3;
s = s+2; //① 编译报错
s += 2; //② 正常执行
//①和②有什么区别?
练习2:
int i = 1;
i *= 0.1;
System.out.println(i);//0
i++;
System.out.println(i);//1
练习3:
int m = 2;
int n = 3;
n *= m++; //n = n * m++;
System.out.println("m=" + m);//3
System.out.println("n=" + n);//6
练习4:
int n = 10;
n += (n++) + (++n); //n = n + (n++) + (++n)
System.out.println(n);//32
练习5:你有几种办法实现变量值减1?变量值减2呢?
/**
* @author 尚硅谷-宋红康
* @create 16:55
*/
public class MinusTest {
public static void main(String[] args) {
//练习①:变量值减1
short s = 10;
//方式1:
//s = (short)(s - 1);
//方式2:推荐
s--; //或者 --s
//方式3:
s -= 1;
//练习②:变量值减2
short s1 = 10;
//方式1:
//s1 = (short)(s1 - 2);
//方式2:推荐
s1 -= 2;
}
}
比较运算符的结果都是boolean型,也就是要么是true,要么是false。
> < >= <= :只适用于基本数据类型(除boolean类型之外)
== != :适用于基本数据类型和引用数据类型
比较运算符“==
”不能误写成“=
”
举例:
class CompareTest {
public static void main(String[] args) {
int i1 = 10;
int i2 = 20;
System.out.println(i1 == i2);//false
System.out.println(i1 != i2);//true
System.out.println(i1 >= i2);//false
int m = 10;
int n = 20;
System.out.println(m == n);//false
System.out.println(m = n);//20
boolean b1 = false;
boolean b2 = true;
System.out.println(b1 == b2);//false
System.out.println(b1 = b2);//true
}
}
思考:
boolean b1 = false;
//区分好==和=的区别。
if(b1 == true) //if(b1 = true)
System.out.println("结果为真");
else
System.out.println("结果为假");
逻辑运算符,操作的都是boolean类型的变量或常量,而且运算得结果也是boolean类型的值。
运算符说明:
异或,追求的是“异”!
逻辑运算符用于连接布尔型表达式,在Java中不可以写成 3 < x < 6,应该写成x > 3 & x < 6 。
区分“&”和“&&”:
相同点:如果符号左边是true,则二者都执行符号右边的操作
不同点:& : 如果符号左边是false,则继续执行符号右边的操作
&& :如果符号左边是false,则不再继续执行符号右边的操作
区分“|”和“||”:
相同点:如果符号左边是false,则二者都执行符号右边的操作
不同点:| : 如果符号左边是true,则继续执行符号右边的操作
|| :如果符号左边是true,则不再继续执行符号右边的操作
建议:开发中,推荐使用 ||
代码举例:
public class LoginTest {
public static void main(String[] args) {
int a = 3;
int b = 4;
int c = 5;
// & 与,且;有false则false
System.out.println((a > b) & (a > c));
System.out.println((a > b) & (a < c));
System.out.println((a < b) & (a > c));
System.out.println((a < b) & (a < c));
System.out.println("===============");
// | 或;有true则true
System.out.println((a > b) | (a > c));
System.out.println((a > b) | (a < c));
System.out.println((a < b) | (a > c));
System.out.println((a < b) | (a < c));
System.out.println("===============");
// ^ 异或;相同为false,不同为true
System.out.println((a > b) ^ (a > c));
System.out.println((a > b) ^ (a < c));
System.out.println((a < b) ^ (a > c));
System.out.println((a < b) ^ (a < c));
System.out.println("===============");
// ! 非;非false则true,非true则false
System.out.println(!false);
System.out.println(!true);
//&和&&的区别
System.out.println((a > b) & (a++ > c));
System.out.println("a = " + a);
System.out.println((a > b) && (a++ > c));
System.out.println("a = " + a);
System.out.println((a == b) && (a++ > c));
System.out.println("a = " + a);
//|和||的区别
System.out.println((a > b) | (a++ > c));
System.out.println("a = " + a);
System.out.println((a > b) || (a++ > c));
System.out.println("a = " + a);
System.out.println((a == b) || (a++ > c));
System.out.println("a = " + a);
}
}
案例:
1. 定义类 CompareLogicExer
2. 定义 main方法
3. 定义一个int类型变量a,变量b,都赋值为20
4. 定义boolean类型变量bo1 , 判断++a 是否被3整除,并且a++ 是否被7整除,将结果赋值给bo1
5. 输出a的值,bo1的值
6. 定义boolean类型变量bo2 , 判断b++ 是否被3整除,并且++b 是否被7整除,将结果赋值给bo2
7. 输出b的值,bo2的值
public class CompareLogicExer {
public static void main(String[] args){
int a = 20;
int b = 20;
boolean bo1 = ((++a % 3) == 0) && ((a++ % 7) == 0);
System.out.println("bo1的值:" + bo1);
System.out.println("a的值:" + a);
System.out.println("----------------------------");
boolean bo2 = ((b++ % 3) == 0) && ((++b % 7) == 0);
System.out.println("bo2的值:" + bo2);
System.out.println("b的值:" + b);
}
}
**练习1:**区分 & 和 &&
int x = 1;
int y = 1;
if(x++ == 2 & ++y == 2){
x = 7;
}
System.out.println("x=" + x + ",y=" + y);
int x = 1,y = 1;
if(x++ == 2 && ++y == 2){
x =7;
}
System.out.println("x="+x+",y="+y);
**练习2:**区分 | 和 ||
int x = 1,y = 1;
if(x++==1 | ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);
int x = 1,y = 1;
if(x++==1 || ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);
**练习3:**程序输出
class Test {
public static void main (String [] args) {
boolean x = true;
boolean y = false;
short z = 42;
if ((z++ == 42) && (y = true)) {
z++;
}
if ((x = false) || (++z == 45)) {
z++;
}
System.out.println("z=" + z);
}
}
//结果为:
//z= 46
(1)左移:<<
运算规则:在一定范围内,数据每向左移动一位,相当于原数据*2。(正数、负数都适用)
【注意】当左移的位数n超过该数据类型的总位数时,相当于左移(n-总位数)位
3<<4 类似于 3*2的4次幂 => 3*16 => 48
-3<<4 类似于 -3*2的4次幂 => -3*16 => -48
(2)右移:>>
运算规则:在一定范围内,数据每向右移动一位,相当于原数据/2。(正数、负数都适用)
【注意】如果不能整除,向下取整
。
69>>4 类似于 69/2的4次 = 69/16 =4
-69>>4 类似于 -69/2的4次 = -69/16 = -5
(3)无符号右移:>>>
运算规则:往右移动后,左边空出来的位直接补0。(正数、负数都适用)
69>>>4 类似于 69/2的4次 = 69/16 =4
-69>>>4 结果:268435451
(4)按位与:&
运算规则:对应位都是1才为1,否则为0。
1 & 1 结果为1
1 & 0 结果为0
0 & 1 结果为0
0 & 0 结果为0
9 & 7 = 1
-9 & 7 = 7
(5)按位或:|
运算规则:对应位只要有1即为1,否则为0。
1 | 1 结果为1
1 | 0 结果为1
0 | 1 结果为1
0 & 0 结果为0
9 | 7 //结果: 15
-9 | 7 //结果: -9
(6)按位异或:^
运算规则:对应位一个为1一个为0,才为1,否则为0。
1 ^ 1 结果为0
1 ^ 0 结果为1
0 ^ 1 结果为1
0 ^ 0 结果为0
9 ^ 7 //结果为14
-9 ^ 7 //结果为-16
(7)按位取反:~
运算规则:对应位为1,则结果为0;对应位为0,则结果为1。
~0就是1
~1就是0
~9 //结果:-10
~-9 //结果:8
举例2:体会 m = k ^ n = (m ^ n) ^ n
**案例1:**高效的方式计算2 * 8的值(经典面试题)
答案:2 << 3 、 8 << 1
**案例2:**如何交换两个int型变量的值?String呢?
public class BitExer {
public static void main(String[] args) {
int m = 10;
int n = 5;
System.out.println("m = " + m + ", n = " + n);
//(推荐)实现方式1:优点:容易理解,适用于不同数据类型 缺点:需要额外定义变量
//int temp = m;
//m = n;
//n = temp;
//实现方式2:优点:没有额外定义变量 缺点:可能超出int的范围;只能适用于数值类型
//m = m + n; //15 = 10 + 5
//n = m - n;//10 = 15 - 5
//m = m - n;//5 = 15 - 10
//实现方式3:优点:没有额外定义变量 缺点:不易理解;只能适用于数值类型
m = m ^ n;
n = m ^ n; //(m ^ n) ^ n
m = m ^ n;
System.out.println("m = " + m + ", n = " + n);
}
}
(条件表达式)? 表达式1:表达式2
public static void main(String[] args) {
int i = (1==2 ? 100 : 200);
System.out.println(i);//200
boolean marry = false;
System.out.println(marry ? "已婚" : "未婚" );
double d1 = (m1 > m2)? 1 : 2.0;
System.out.println(d1);
int num = 12;
System.out.println(num > 0? true : "num非正数");
}
**案例1:**获取两个数中的较大值
/**
* @author 尚硅谷-宋红康
* @create 12:40
*/
public class ConditionExer1 {
public static void main(String[] args) {
//获取两个数的较大值
int m1 = 10;
int m2 = 20;
int max1 = (m1 > m2)? m1 : m2;
System.out.println("m1和m2中的较大值为" + max1);
}
}
**案例2:**获取三个数中的最大值
public class ConditionExer2 {
public static void main(String[] args) {
int n1 = 23;
int n2 = 13;
int n3 = 33;
//写法1:
int tempMax = (n1 > n2)? n1:n2;
int finalMax = (tempMax > n3)? tempMax : n3;
System.out.println("三个数中最大值为:" + finalMax);
//写法2:不推荐,可读性差
int finalMax1 = (((n1 > n2)? n1:n2) > n3)? ((n1 > n2)? n1:n2) : n3;
System.out.println("三个数中最大值为:" + finalMax1);
}
}
**案例3:**今天是周2,10天以后是周几?
要求:控制台输出"今天是周2,10天以后是周x"。
public class ConditionExer3 {
public static void main(String[] args) {
int week = 2;
week += 10;
week %= 7;
System.out.println("今天是周2,10天以后是周" + (week == 0 ? "日" : week));
}
}
凡是可以使用条件运算符的地方,都可以改写为if-else结构。反之,不成立。
开发中,如果既可以使用条件运算符,又可以使用if-else,推荐使用条件运算符。因为执行效率稍高。
//if-else实现获取两个数的较大值
int i1 = 10;
int i2 = 20;
int max;//声明变量max,用于记录i1和i2的较大值
if(i1 > i2){
max = i1;
}else{
max = i2;
}
System.out.println(max);
运算符有不同的优先级,所谓优先级就是在表达式运算中的运算符顺序。
上一行中的运算符总是优先于下一行的。
优先级 | 运算符说明 | Java运算符 |
---|---|---|
1 | 括号 | () 、[] 、{} |
2 | 正负号 | + 、- |
3 | 单元运算符 | ++ 、-- 、~ 、! |
4 | 乘法、除法、求余 | * 、/ 、% |
5 | 加法、减法 | + 、- |
6 | 移位运算符 | << 、>> 、>>> |
7 | 关系运算符 | < 、<= 、>= 、> 、instanceof |
8 | 等价运算符 | == 、!= |
9 | 按位与 | & |
10 | 按位异或 | ^ |
11 | 按位或 | ` |
12 | 条件与 | && |
13 | 条件或 | ` |
14 | 三元运算符 | ? : |
15 | 赋值运算符 | = 、+= 、-= 、*= 、/= 、%= |
16 | 位赋值运算符 | &= 、` |
开发建议:
- 不要过多的依赖运算的优先级来控制表达式的执行顺序,这样可读性太差,尽量
使用()来控制
表达式的执行顺序。- 不要把一个表达式写得过于复杂,如果一个表达式过于复杂,则把它
分成几步
来完成。例如:
(num1 + num2) * 2 > num3 && num2 > num3 ? num3 : num1 + num2;
计算机中储存的信息都是用二进制数
表示的,而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则,将字符存储到计算机中,称为编码
。反之,将存储在计算机中的二进制数按照某种规则解析显示出来,称为解码
。
字符编码(Character Encoding) : 就是一套自然语言的字符与二进制数之间的对应规则。
字符集:也叫编码表。是一个系统支持的所有字符的集合,包括各国家文字、标点符号、图形符号、数字等。
英语字符
与二进制位之间的关系,做了统一规定。这被称为ASCII码。128个
字符。比如:空格“SPACE”是32(二进制00100000),大写的字母A是65(二进制01000001)。显示中文
而设计的一套字符集。7000多个简体汉字
,此外数学符号、罗马希腊的字母、日文的假名们都编进去了,这就是常说的"全角"字符,而原来在127号以下的那些符号就叫"半角"字符了。双字节
编码方案,共收录了21003个
汉字,完全兼容GB2312标准,同时支持繁体汉字
以及日韩汉字等。70244个
,采用多字节
编码,每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字,同时支持繁体汉字以及日韩汉字等。Unicode编码为表达任意语言的任意字符
而设计,也称为统一码、标准万国码。Unicode 将世界上所有的文字用2个字节
统一进行编码,为每个字符设定唯一的二进制编码,以满足跨语言、跨平台进行文本处理的要求。
Unicode 的缺点:这里有三个问题:
极大的浪费
。区别Unicode和ASCII
?计算机怎么知道两个字节表示一个符号,而不是分别表示两个符号呢?不够表示所有字符
。Unicode在很长一段时间内无法推广,直到互联网的出现,为解决Unicode如何在网络上传输的问题,于是面向传输的众多 UTF(UCS Transfer Format)标准出现。具体来说,有三种编码方案,UTF-8、UTF-16和UTF-32。
将数字转换到程序数据
的编码方案。顾名思义,UTF-8就是每次8个位传输数据,而UTF-16就是每次16个位。其中,UTF-8 是在互联网上使用最广
的一种 Unicode 的实现方式。变长的编码方式
。它可以使用 1-4 个字节表示一个符号它使用一至四个字节为每个字符编码,编码规则:
Unicode符号范围 | UTF-8编码方式
(十六进制) | (二进制)
————————————————————|—–—–—–—–—–—–—–—–—–—–—–—–—–—–
0000 0000-0000 007F | 0xxxxxxx(兼容原来的ASCII)
0000 0080-0000 07FF | 110xxxxx 10xxxxxx
0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
注意:在中文操作系统上,ANSI(美国国家标准学会、AMERICAN NATIONAL STANDARDS INSTITUTE: ANSI)编码即为GBK;在英文操作系统上,ANSI编码即为ISO-8859-1。