《第一阶段 java基础 Day02笔记》————————第二讲Java基本语法
第二讲Java基本语法
| 课程大纲 |
课程内容 |
学习效果 |
掌握目标 |
| Java基本语法 |
注释、关键字、标识符 |
掌握 |
熟练掌握Java的注释方式 熟练掌握Java中的关键字 熟练掌握标识符概念 |
| 数据类型、常量、变量 |
掌握 |
熟练掌握Java中的数据类型 熟练掌握Java中的常量、变量的定义和使用 |
|
| 运算符 |
掌握 |
熟练掌握Java中的各种运算符 |
|
| 键盘录入Scanner类 |
掌握 |
熟练掌握Java中的键盘输入Scanner类 |
一、注释、关键字、标识符
1、注释
注释概述
用于解释说明程序的文字
注释分类
1、单行注释
格式： //注释文字
2、多行注释
格式： /* 注释文字 */
3、文档注释
格式：/** 注释文字 */
注释作用
1、对程序进行解释说明：要求代码中，有30%行数都是用来写注释的
2、对程序的思路进行描述
3、对程序进行调试：通过注释的方式，快速定位出现错误的代码位置
示例代码
|
|
2、关键字
关键字概述
1、关键字是被Java语言赋予特殊含义，具有专门用途的单词，比如之前接触的class，public，static，void均为Java已经预设好的。
2、你可以先把Java关键字理解为“命令”！
关键字特点
1、组成关键字的字母全部小写。
2、常用的代码编辑器,针对关键字有特殊的颜色标记，非常直观，所以我们不需要去死记硬背，在今后的学习中重要的关键字也会不断的出来。
Java中的所有关键字展示
特点：
1、全部小写。
2、自己起名字的时候，不要和关键字重名。
3、有两个保留字：goto、const，在当前版本不使用，但是以后是否使用未知。
注意：边学边积累（不用背）
3、标识符
什么是标识符
其实在Java程序中，除了关键字以外基本上都是标识符了。
其实标识符就是名称的意思，所有的名称都统称为标识符。
Java中经常要定义类、方法、变量（后面会学习到），在定义他们时总要给它们起名字，这些名字就是标识符。我们要学习的就是标识符的规范。凡是可以自己起名字的地方都叫做标识符。
组成元素
1、英文字符: a-zA-Z
2、数字: 0-9
3、符号: _与$
标识符规则(规范)
1、数字不能开头
2、不可以使用关键字
3、严格区分大小写，不限制长度起名时，尽量达到见名知意
4、类名：首字母大写，其他字母小写，若有多个单词，每个单词的首字母大写（后面学习）
5、方法名：第一个单词字母小写，后面的单词首字母大写，其他字母小写
6、变量：一个单词首字母小写。多个单词，从第二个单词开始每个单词首字母大写（驼峰形式）非强制要求，约定俗称的规则
二、数据类型、常量、变量
1、数据类型
（1）数据类型分类
在生活中数据是有类型的，例如人的姓名是字符串类型，人的年龄是正整数类型。在Java中数据也是有类型的。
Java中数据的类型：
基本数据类型
是Java语言中内置的类型，分别是整数类型、浮点类型、字符类型、布尔类型。这四类基本类型是最简单、最基础的类型。
引用数据类型
是强大的数据类型，它是基于基本数据类型创建的。JavaSE中提供了一个超级类库，类库中包含了近万种引用数据类型。不过现在我们先要学习的是基本类型！
（2）基本数据类型示例
整数类型
十进制表示方式：正常数字 如 13、25等
二进制表示方式：以0b(0B)开头 如0b1011 、0B1001
八进制表示方式：以0开头 如01、07、0721
十六进制表示方式：以0x(0X)开头 数字以0-9及A-F组成 如0x23A2、0xa、0x10
浮点数类型
如1.0、-3.15、3.168等
布尔类型
true、false
字符类型
如'a'，'A', '0', '家'
字符必须使用’’ 包裹，并且其中只能且仅能包含一个字符。
（3）基本数据类型占用大小和表示范围
基本数据类型(4类8种)
| 四类 |
八种 |
字节数 |
数据表示范围 |
| 整型 (精确)
|
byte |
1 |
-128～127 |
| short |
2 |
-32768～32767 |
|
| int(默认) |
4 |
-2147483648～2147483647 |
|
| long |
8 |
-263～263-1 |
|
| 浮点型 (不精确) |
float |
4 |
-3.403E38～3.403E38 |
| double(默认) |
8 |
-1.798E308～1.798E308 |
|
| 字符型 |
char |
2 |
表示一个字符，如('a'，'A'，'0'，'家') |
| 布尔型 |
boolean |
1 |
只有两个值true与false |
注意：Java中的数据类型有哪些？(一定要答对)范围是多少？(大概知道)
2、常量
Java中的数据量分为常量和变量，我们先来学习常量。
常量就是不变的数据量，例如100就是常量，任何数据量都有其类型，那么100这个常量是什么类型呢？回忆一下基本类型中有四类，分别是整数、小数（浮点数）、字符、布尔。
示例代码
回顾HelloWorld案例，其中System.out.println(“Hello World!”)的圆括号中放的就是一个字符串。那么我们是否可以把圆括号中的字符串换成其他字符串呢？答案是可以的！不只是可以换成其他字符串，还可以把圆括号中的字符串换成其他类型的常量，例如：
| public static void main(String[] args) { // 整型常量（默认是int类型） System.out.println(100); System.out.println(2147483647); // int类型最大值 //System.out.println(2147483648); // 报错(超出int的范围) System.out.println(2147483648L); // long类型常量
//进制 System.out.println(0b10110); //二进制表示 System.out.println(017); //八进制表示 System.out.println(0x17); //十六进制表示
//浮点数类型 System.out.println(3.14); //默认是double类型 System.out.println(3.14f); System.out.println(3.14F); // float类型加f或F
//字符串类型 System.out.println('A'); System.out.println('0'); System.out.println('中');
//布尔类型 System.out.println(true); System.out.println(false);
// 字符串 System.out.println("abc"); } |
- 变量
（1）概念
变量：在程序中可以变化的量称为变量(常量是固定不变的量)
数学中，可以使用字母代替数字运算,例如 x=1+5 或者 6=x+5。
程序中，可以使用字母保存数字的方式进行运算，提高计算能力，可以解决更多的问题。比如x保存5，x也可以保存6，这样x保存的数据是可以改变的，也就是我们所讲解的变量。
Java中要求一个变量每次只能保存一个数据，必须要明确保存的数据类型。
（2）定义格式
格式
数据类型 变量名 = 数据值;
例如
int a = 100;
其中int是数据类型，指定了变量只能存储整数，而且指定了存储范围为-2147483648～2147483648。
其中a表示变量名，变量名是标识符，这说明只要是合法的标识符都可以用来做变量名。在程序中可以通过变量名来操作变量。
其中“=100”是给变量赋值，即向a变量中写入100。
注意，给变量赋的值一定要与类型符合，也就是说int类型只能存储整数，而且必须是在-2147483648～2147483648范围内的整数。
示例代码
| public static void main(String[] args) { // byte类型变量 byte b = 100; System.out.println(b);
//short类型变量 short s = 100; System.out.println(s);
//int类型变量 int x = 100; System.out.println(x);
//long类型变量 long num = 100L; System.out.println(num);
//float类型变量 float f = 2.0F; System.err.println(f); float f2 = 2.0f; System.out.println(f2);
//double类型变量 double d = 3.14; System.out.println(d); double d2 = 3.14d; System.out.println(d2); double d3 = 3.14D; System.out.println(d3);
//char类型变量 char c = 'a'; System.out.println(c);
//boolean类型变量 boolean flag = true; System.out.println(flag); } |
（3）注意事项
变量定义后可以不赋值，使用时再赋值。不赋值不能使用。
示例代码
| public static void main(String[] args) { int x; x = 20; //下面要使用变量x x必须先赋值 System.out.println(x); } |
变量不能重复定义,并且赋值时类型得匹配。
示例代码
| public static void main(String[] args) { int x = 20; // 定义一个int类型变量x //int x = 30; //编译报错， 不能重复定义一个x变量 x =30; // 正确，表示给x重新赋值 //x = "abc"; //编译报错，赋值时，类型要匹配 } |
变量使用时有作用域的限制。
示例代码
| public static void main(String[] args) { int a= 100; { int b = 200; System.out.println(a); System.out.println(b); } //System.out.println(b); // 编译报错，这里不能访问到变量b } |
4、数据类型转换
（1）概念
不同类型的变量是否可以在一起运算呢？答案是可以的，但要先进行类型转换再运算。下面我们来学习一下类型转换。
其实，我们所学习的数据，它的表示方式是可以灵活多变的，比如把小数转换成整数的操作。
（2）数据类型转换有两种方式
自动类型转换
表示范围小的数据类型（如byte）可以直接转换成范围大的数据类型（如int），这种方式称为自动类型转换。
格式：范围大的数据类型 变量 = 范围小的数据类型值；
强制类型转换
表示范围大的数据类型（如int）不可以转换成范围小的数据类型（如byte），但可以强制转，这种方式称为强制类型转换。
格式：范围小的数据类型 变量 = (范围小的数据类型) 范围大的数据类型值;
转换规律：
各种数据类型按照数据范围从小到大依次列出：范围小的类型向范围大的类型提升：byte
byte、short、char 运算时直接提升为int，同样的道理，当一个int 类型变量和一个double 变量运算时， int 类型将会自动提升为double 类型进行运算。
示例代码
| public static void main(String[] args) {
byte a = 1; byte b = 2; int c = a+b; //正确，byte类型可以自动提升为int类型（小东西装大盒子中）
int d = 1; int e = 2; byte f = (byte)(d+e); // 这里需要强制类型转换，强制转换可能损失精度 } |
注意
浮点转成整数，直接去掉小数点，可能造成数据损失精度。
示例代码
| public static void main(String[] args) { double d = 3.14; int x = (int)d; System.out.println(x); //3 损失精度 } |
int 强制转成byte砍掉3个字节，可能造成数据丢失(丢失精度)。
示例代码
| public static void main(String[] args) { int x = 128; byte b = (byte)x; System.out.println(b); // -128 } |
（3）浮点数运算问题
浮点数做运算结果不精确
示例代码
| public static void main(String[] args) { double x = 1.0; double y = 0.9; double result = x-y; System.out.println(result); //0.09999999999999998
double a = 0.1; double b = 0.2; double result2 = a+b; System.out.println(result2); //0.30000000000000004 } |
（4）类型转换练习
1、计算一年有多少毫秒（一年按365天计算）
| public static void main(String[] args) { //int result = 365*24*60*60*1000; //long result = 365*24*60*60*1000; long result = 365L*24*60*60*1000; System.out.println(result); } |
2、整数的除法运算
| public static void main(String[] args) { int x = 10; int y = 4;
int result = x/y; System.out.println(result); // 2
double result2 = x/y; System.out.println(result2); //2.0;
double result3 = (double)x/y; // 把x强转成double System.out.println(result3); //2.5
double result4 = 1.0*x/y; // 低侵入式 System.out.println(result4); } |
3、浮点数 四舍五入取整 四舍五入取两位小数
| public static void main(String[] args) { double x = 3.4665; //四舍五入取整数 int result = (int)(x+0.5); System.out.println(result);
// 四舍五入取保留两位小数 double result2 = (int)(x*100+0.5)/100.0; System.out.println(result2); } |
5、字符集和char类型
（1）常见字符集
1 ASCII字符集&编码
ASCII(American Standard Code for Information Interchange, 美国信息交换标准代码)是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语。
ASCII一共定义了128个字符,包括33个控制字符,和95个可显示字符。大部分的控制字符已经被废弃。
ASCII码为单字节,用7位二进制数表示，由于计算机1个字节是8位二进制数，所以最高位为0，即00000000-01111111或0x00-0x7F。
|
|
2 GB2312字符集&编码
GB2312 或 GB2312–80 是中华人民共和国国家标准简体中文字符集，全称《信息交换用汉字编码字符集·基本集》，又称GB0，由中国国家标准总局发布，1981年5月1日实施。GB 2312编码通行于中国大陆；新加坡等地也采用此编码。中国大陆几乎所有的中文系统和国际化的软件都支持GB2312。
GB2312标准共收录6763个汉字，其中一级汉字3755个，二级汉字3008个；同时收录了包括拉丁字母、希腊字母、日文平假名及片假名字母、俄语西里尔字母在内的682个字符，基本满足了汉字的计算机处理需要。它所收录的汉字已经覆盖中国大陆99.75%的使用频率，但对于人名、古汉语等方面出现的罕用字和繁体字，GB2312不能处理。
3 GBK字符集&编码
汉字内码扩展规范，称GBK，全名为《汉字内码扩展规范(GBK)》1.0版，由中华人民共和国全国信息技术标准化技术委员会1995年12月1日制订，国家技术监督局标准化司和电子工业部科技与质量监督司1995年12月15日联合以《技术标函[1995]229号》文件的形式公布。
GBK的K为汉语拼音Kuo Zhan（扩展）中“扩”字的声母。英文全称Chinese Internal Code Extension Specification。
GB2312只收录6763个汉字，有不少汉字，如部分在GB2312推出以后才简化的汉字（如“啰”），部分人名用字（如中国前总理朱镕的“镕”字），台湾及香港使用的繁体字，日语及朝鲜语汉字等，并未有收录在内。GBK对GB 2312-80进行扩展, 总计拥有23940个码位，共收入21886个汉字和图形符号，其中汉字（包括部首和构件）21003 个，图形符号883 个。
4 Unicode字符集&编码
Unicode（中文：万国码、国际码、统一码、单一码）是计算机科学领域里的一项业界标准。它对世界上大部分的文字系统进行了整理、编码，使得电脑可以用更为简单的方式来呈现和处理文字。
Unicode伴随着通用字符集的标准而发展，同时也以书本的形式对外发表。Unicode至今仍在不断增修，每个新版本都加入更多新的字符。目前最新的版本为2016年6月21日公布的9.0.0,已经收入超过十万个字符（第十万个字符在2005年获采纳）。Unicode涵盖的数据除了视觉上的字形、编码方法、标准的字符编码外，还包含了字符特性，如大小写字母。
Unicode发展由非营利机构统一码联盟负责，该机构致力于让Unicode方案替换既有的字符编码方案。因为既有的方案往往空间非常有限，亦不适用于多语环境。
Unicode备受认可，并广泛地应用于电脑软件的国际化与本地化过程。有很多新科技，如可扩展置标语言、Java编程语言以及现代的操作系统，都采用Unicode编码。
统一码的编码方式与ISO 10646的通用字符集概念相对应。目前实际应用的统一码版本对应于UCS-2，使用16位的编码空间。也就是每个字符占用2个字节。这样理论上一共最多可以表示2的16次方（即65536）个字符。基本满足各种语言的使用。实际上当前版本的统一码并未完全使用这16位编码，而是保留了大量空间以作为特殊使用或将来扩展。
Unicode原编码占用两个字节,在使用ASCII字符时,高位字节的8位始终为0,这会造成空间的浪费。为了避免这种浪费，Unicode的实现方式不同于编码方式。一个字符的Unicode编码是确定的。但是在实际传输过程中，由于不同系统平台的设计不一定一致，以及出于节省空间的目的，对Unicode编码的实现方式有所不同。Unicode的实现方式称为Unicode转换格式（Unicode Transformation Format，简称为UTF）。
UTF-8、UTF-16、UTF-32都是将数字转换到程序数据的编码方案。
5 UTF-8 编码
UTF-8（8-bit Unicode Transformation Format）是一种针对Unicode的可变长度字符编码，也是一种前缀码。其编码中的第一个字节仍与ASCII兼容，这使得原来处理ASCII字符的软件无须或只须做少部分修改，即可继续使用。
UTF-8使用一至六个字节为每个字符编码（尽管如此，2003年11月UTF-8被RFC 3629重新规范，只能使用原来Unicode定义的区域，U+0000到U+10FFFF，也就是说最多四个字节）：
128个US-ASCII字符只需一个字节编码（Unicode范围由U+0000至U+007F）。
带有附加符号的拉丁文、希腊文、西里尔字母、亚美尼亚语、希伯来文、阿拉伯文、叙利亚文及它拿字母则需要两个字节编码（Unicode范围由U+0080至U+07FF）。
其他基本多文种平面（BMP）中的字符（这包含了大部分常用字，如大部分的汉字）使用三个字节编码（Unicode范围由U+0800至U+FFFF）。
其他极少使用的Unicode 辅助平面的字符使用四至六字节编码（Unicode范围由U+10000至U+1FFFFF使用四字节，Unicode范围由U+200000至U+3FFFFFF使用五字节，Unicode范围由U+4000000至U+7FFFFFFF使用六字节）。
对上述提及的第四种字符而言，UTF-8使用四至六个字节来编码似乎太耗费资源了。但UTF-8对所有常用的字符都可以用三个字节表示，而且它的另一种选择，UTF-16编码，对前述的第四种字符同样需要四个字节来编码，所以要决定UTF-8或UTF-16哪种编码比较有效率，还要视所使用的字符的分布范围而定。
编码方式
单字节字符的最高有效比特永远为0。
多字节序列中的首个字符组的几个最高有效比特决定了序列的长度。最高有效位为110的是2字节序列，而1110的是三字节序列，如此类推。
多字节序列中其余的字节中的首两个最高有效比特为10。
（2）char类型
赋值方式
| public static void main(String[] args) { char c1 = 'a'; char c2 = '中'; char c3 = 20013; char c4 = 20014; char c5 = '\u0061'; // 'a' 在unicode编码中的位置 } |
和int类型的运算
| public static void main(String[] args) { char c1 = 'a'; int x = c1+1; // c1 自动提升为int类型，值为97 97+1=98 System.out.println(x); //98
System.out.println('A'+1); // 65+1 = 66 System.out.println(0+1); // 1 System.out.println('0'+1); // 48+1=49 } |
说明
在char类型和int类型计算的过程中，char类型的字符先查询编码表，得到97，再和1求和，结果为98。char类型提升为了int类型。char类型内存2个字节，int类型内存4个字节。
几个特殊意义的字符
| \ 转义字符 \’ 表示 单引号 \\ 表示 \
\n 换行 \r 回车 \t tab 制表符 … |
6、综合练习
需求:
在控制台输出完成水果超市价格表
代码实现
版本1
| System.out.println("水果编号 水果名称 水果价格 计价单位 品质"); System.out.println(" 1 榴莲 32.0 公斤 A"); System.out.println(" 2 黄瓜 66.0 公斤 B"); System.out.println(" 3 香蕉 88.0 公斤 C"); |
版本2
| System.out.println("水果编号\t果名称\t水果价格\t计价单位\t品质"); System.out.println(1+"\t榴莲\t"+32.0+"\t公斤\t"+'A'); System.out.println(2+"\t黄瓜\t"+66.0+"\t公斤\t"+'B'); System.out.println(3+"\t香蕉\t"+88.0+"\t公斤\t"+'C'); |
版本3
| int id1 = 1; String name1 = "榴莲"; double price1 = 32.0; String danwei = "公斤"; char pinzhi1 = 'A';
int id2 = 2; String name2 = "黄瓜"; double price2 = 66.0; char pinzhi2 = 'B';
int id3 = 3; String name3 = "黄瓜"; double price3 = 66.0; char pinzhi3 = 'B';
System.out.println("水果编号\t果名称\t水果价格\t计价单位\t品质"); System.out.println(id1+"\t"+name1+"\t"+price1+"\t"+danwei+"\t"+pinzhi1); System.out.println(id2+"\t"+name2+"\t"+price2+"\t"+danwei+"\t"+pinzhi2); System.out.println(id3+"\t"+name3+"\t"+price3+"\t"+danwei+"\t"+pinzhi3); |
三、运算符
1、概述
运算符
对常量和变量进行操作的符号称为运算符
表达式
用运算符把常量或者变量连接起来符号java语法的式子就可以称为表达式。不同运算符连接的式子体现的是不同类型的表达式。
定义两个int类型的变量a,b，做加法(a + b)
常用运算符
算术运算符
赋值运算符
关系运算符
逻辑运算符
三元运算符
2、算术运算符
（1）概念
和数学中的算术运算符基本一致,用法如下:
| 运算符 |
运算规则 |
范例 |
结果 |
| + |
正号 |
+3 |
3 |
| + |
加 |
2+3 |
5 |
| + |
连接字符串 |
“中”+“国” |
“中国” |
| - |
负号 |
int a=3; -a |
-3 |
| - |
减 |
3-1 |
2 |
| * |
乘 |
2*3 |
6 |
| / |
除 |
5/2 |
2 |
| % |
取模(取余) |
5%2 |
1 |
| ++ |
自增 |
int a=1; a++ / ++a |
2 |
| -- |
自减 |
int b=3; b-- / --b |
2 |
示例代码
| public static void main(String[] args) { /* int result = 1+2; int result2 = 3-1; int result3 = 3*2; int result4 = 3/2; int result5 = 3%2; // 取模 （余数） -------> 判断能不能整除
System.out.println(result); //3 System.out.println(result2); //2 System.out.println(result3); //6 System.out.println(result4); //1 System.out.println(result5); //1 */
/* int x = 100; int y = 3;
int result = x+y; int result2 = x/y; int result3 = x%y; System.out.println(result); //103 System.out.println(result2); //33 System.out.println(result3); // 1 */
// ++(递增) --(递减)
/* int a = 1; //a++; ++a; System.out.println(a); //2 */
/* int a = 5; int result = a++; // a++ (a=a+1)a++ 先赋值，在递增 System.out.println(result); // 5 System.out.println(a); // 6
int b = 5; int result2 = ++b; //(b=b+1) 先递增在赋值 System.out.println(result2); // 6 System.out.println(b); // 6 */
System.out.println("1+2="+1+2); // 如何值和字符串相加后结果都是字符串 "1+2=12" System.out.println("1+2="+(1+2)); // 小括号改变计算的优先级 "1+2=3" } |
（2）自增和自减 ++、--
++ 运算，变量自己增长1
-- 运算，变量自己减少1
独立运算：
变量前++ ，例如 ++i
变量后++ ，例如 i++
变量在独立运算时， 前++ 和后++ 没有区别 。
示例代码
| public static void main(String[] args) { int a = 1; a++; System.out.println(a);//2 ++a; System.out.println(a);//3 } |
和其他变量放在一起运算
前++计算方式：变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2
后++计算方式：变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的结果是2，b的结果是1。
示例代码
| public static void main(String[] args) { int a = 1; //int b = ++a;//a:2 b:2 注意:++在前表示先计算++ 再赋值 int b = a++;//a:2 b:1 注意:++在后表示先赋值 再计算++ System.out.println(a); System.out.println(b); } |
（3）练习
取出一个整数的千位上的数
| int x = 321345;//取出千位上的数 int qian = x/1000%10; |
浮点数 取出整数部分，取出小数部分
| double x = 3.1456; int zhengshu = (int)x; // 取出整数部分 double xiaoshu = x-zhengshu; //取出小数部分 |
3、赋值运算符
（1）概念
所谓赋值运算符，就是将符号右边的值，赋给左边的变量。
如下所示:
| 运算符 |
运算规则 |
范例 |
结果 |
| = |
赋值 |
int a=2 |
2 |
| += |
加后赋值 |
int a=2，a+=2 |
4 |
| -= |
减后赋值 |
int a=2，a-=2 |
0 |
| *= |
乘后赋值 |
int a=2，a*=2 |
4 |
| /= |
整除后赋值 |
int a=2，a/=2 |
1 |
| %= |
取模后赋值 |
int a=2，a%=2 |
0 |
示例代码
| public static void main(String[] args) { int a = 5; int b = 2;
a+=2; // a= a+2; System.out.println(a); //7
a-=1; // a = a-1; System.out.println(a); //6
a*=2; // a = a*2; System.out.println(a); //12
a/=2; a = a/2; System.out.println(a); //6
a%=2; a= a%2; System.out.println(a); //0 } |
（2）练习
- 下面代码的运行结果为?
| public static void main(String[] args) { int a = 1; short b = 2;
b = b + a;//编译失败 b += a;//3 System.out.println(b); } |
b = b + a;//编译失败,因为short类型和int类型计算结果自动提升为int类型，赋给short类型会报错
b+=a; //3 += 内部隐含了一个强转，当b = b+a行不通时，
会自动变成：b=（short）(b+a)
2下面代码的运行结果为?
| public static void main(String[] args) { byte b1 = 1; byte b2 = 2; //byte b3 = 1 + 2; //byte b3 = b1 + b2; //System.out.println(b3); } |
分析：
b3=1+2 ，1和2是常量，为固定不变的数据，在编译的时候（编译器javac），已经确定了1+2的结果并没有超过byte类型的取值范围，可以赋值给变量b3，因此b3=1+2 是正确的。
常量优化机制：
有一些计算，非常简单，例如常量和常量的计算就非常简单，在编译阶段就可以把这些简单的运算计算完。
反之， b4=b2+b3 ，b2和b3是变量，变量的值是可能变化的，在编译的时候，编译器javac不确定b2+b3的结果是什么，因此会将结果以int类型进行处理，所以int类型不能赋值给byte类型，因此编译失败。
4、关系运算符(比较运算符)
关系运算符，是两个数据之间进行比较的运算，运算结果都是布尔值true(正确的,真的,满足条件的) 或者false(错误的,假的,不满足条件的) 。
如下所示:
| 运算符 |
运算规则 |
范例 |
结果 |
| == |
相等于 |
4==3 |
false |
| != |
不等于 |
4!=3 |
true |
| < |
小于 |
4<3 |
false |
| > |
大于 |
4>3 |
true |
| <= |
小于等于 |
4<=3 |
false |
| >= |
大于等于 |
4>=3 |
true |
示例代码
| public static void main(String[] args) { int a = 2; int b = 1; System.out.println(b>a); // true System.out.println(b>=a); // true System.out.println(b<a); // false System.out.println(b<=a); // false System.out.println(b==a); // false System.out.println(b!=a); // true } |
5、逻辑运算符
（1）概念
逻辑运算符，是用来连接两个布尔类型结果的运算符，运算结果都是布尔值true 或者false
如下所示:
| 运算符 |
运算规则 |
范例 |
结果 |
| & |
与 |
false&true |
False |
| | |
或 |
false|true |
True |
| ^(了解) |
异或 (相同:false,不同:true) |
true^flase |
True |
| ! |
非 |
!true |
Flase |
| && |
短路与 |
false&&true |
False |
| || |
短路或 |
true||false |
True |
示例代码
| public static void main(String[] args) { /* int x = 5; int y = 3;
int a = 10; int b =8;
System.out.println(x>y & a>=b); // true & true = true System.out.println(x>y & a System.out.println(ay); // false & true = false System.out.println(a
System.out.println(x>y | a>=b); // true | true = true System.out.println(x>y | a System.out.println(ay); // false | true = true System.out.println(a
System.out.println(x>y ^ a>=b); // true ^ true = false System.out.println(x>y ^ a System.out.println(ay); // false ^ true = true System.out.println(a */
/* int x = 5; int y = 3;
int a = 10; int b =8;
System.out.println(!(x>y)); // false System.out.println(!(x
System.out.println(x>y && a>=b); // true && true = true System.out.println(x>y && a System.out.println(ay); // false && true = false System.out.println(a
System.out.println(x>y || a>=b); // true || true = true System.out.println(x>y || a System.out.println(ay); // false || true = true System.out.println(a */ } |
（2）&& 和 ||
&& 短路与
短路特点：符号左边是false，右边不运算
|| 短路或
短路特点： 符号左边是true，右边不运算
结论:实际开发中都是使用短路与&&和短路或||,因为效率更高
示例代码
| int x = 5; int y = 3;
int a = 10; int b =8; /* System.out.println(x System.out.println(a); // 既是第一个表达式是false 也会计算第2个表达式 也就是执行了a++ a的值变为11 */ System.out.println(x<y && a++<b); // false System.out.println(a); //10 第一个表达式是false了结果就直接为false 不会执行第2个表达式 也就是没有执行a++ a的值还是10 |
6、三元运算符
（1）概念
三元运算符格式：
数据类型 变量名 = 布尔类型表达式？值1：值2
三元运算符计算方式：
布尔类型表达式值是true时，三元运算符整体值为值1，赋值给变量。
布尔类型表达式值是false时，三元运算符整体值为值2，赋值给变量。
示例代码
| int a = 5; int b = 8;
int result = a<b?a:b; System.out.println(result); // 判断a大于b吗 如果a大于b 把 a赋给result 反之把b赋给result |
（2）练习
获取两个数中的最大值
| int a = 10; int b = 211; int max = a>b?a:b; System.out.println(max); |
获取三个数中的最大值
| int a = 10; int b = 211; int c = 444; int max = a>b?(a>c?a:c):(b>c?b:c); System.out.println(max); |
7、负数在计算机中存储 （原码、反码、补码）—扩展内容
正数 是以2进制方式
例如：5
| 0000 0000 0000 0000 0000 0000 0000 0101 |
负数在计算机中是以补码方式存储的
什么是补码？ 在说补码之前，要先了解什么是原码和反码
原码： 一个数的绝对值二进制表示，就是原码
也就是说 5 的原码
| 0000 0000 0000 0000 0000 0000 0000 0101 |
-5的原码
| 0000 0000 0000 0000 0000 0000 0000 0101 |
反码： 就是对原码按位取反
| 0000 0000 0000 0000 0000 0000 0000 0101 的反码 1111 1111 1111 1111 1111 1111 1111 1010 |
补码： 反码加1
| 1111 1111 1111 1111 1111 1111 1111 1011 |
1111 1111 1111 1111 1111 1111 1111 1100 表示的数是？
| 1111 1111 1111 1111 1111 1111 1111 1100 -1 1111 1111 1111 1111 1111 1111 1111 1011 0000 0000 0000 0000 0000 0000 0000 0100 -----4 因此对应的是-4 |
8、位运算符—扩展内容
| 位运算符
|
运算符含义
|
| & |
与（AND） |
| | |
或（OR） |
| ^ |
异或 |
| ~ |
取反 |
按位操作符用来操作整数基本数据类型中的单个比特（bit），就是二进制，按位操作符会对两个参数中对应的位（bit）执行布尔运算，最终生成一个结果。按位操作符来源于C语言面向底层的操作，Java设计的初衷是嵌入式电视机机顶盒，所以面向底层的操作也保留了下来。
任何信息在计算机中都是以二进制的形式保存的，”&”、“|”、“^”除了可以作为逻辑运算符也可以作为位运算符。位运算是直接对二进制进行运算。他们对两个操作数中的每一个二进制位都进行运算。例如int是由32个二进制数组成，因此使用位运算符可以对整数值的二进制数进行运算。
（1）& 与运算
& 参加运算的两位数都为1，&运算符结果才为1，否则就为0。
6&3
| 00000000 |
00000000 |
00000000 |
00000110 |
6 |
| 00000000 |
00000000 |
00000000 |
00000011 |
3 |
| 00000000 |
00000000 |
00000000 |
00000010 |
& =2 |
（2）| 或运算
| 参与运算的两位都为0，|运算的结果才为0，否则就为1。
| 00000000 |
00000000 |
00000000 |
00000110 |
6 |
| 00000000 |
00000000 |
00000000 |
00000011 |
3 |
| 00000000 |
00000000 |
00000000 |
00000111 |
| =7 |
（3）^ 异或运算
^只有参加运算的两位不同，^运算的结果才为1，否则就为0。
| 00000000 |
00000000 |
00000000 |
00000110 |
6 |
| 00000000 |
00000000 |
00000000 |
00000011 |
3 |
| 00000000 |
00000000 |
00000000 |
00000101 |
^ =5 |
（4）~ 反码
就是取反，二进制只有1和0，取反就是如果为1，取反就是0，如果是0，取反就是1。
| 0000-0000 |
0000-0000 |
0000-0000 |
0000-0110 |
6 |
| 1111-1111 |
1111-1111 |
1111-1111 |
1111-1001 |
取反 -7 |
结论：当参与取反的数值是正数时，把对应的值加上负号，再-1；
当参与取反的数值是负数时，把对应的值加上负号，再-1；
负数的表现形式就是对应的正数取反，再加1。负数的最高位肯定是1。
9、移位运算符—扩展内容
（1）概述
<< 左移
>> 右移
>>> 无符号右移
| 位运算符 |
||
| 运算符 |
运算 |
范例 |
| << |
左移 |
3 << 2 = 12 --> 3*2*2=12 |
| >> |
右移 |
3 >> 1 = 1 --> 3/2=1 |
| >>> |
无符号右移 |
3 >>> 1 = 1 --> 3/2=1 |
| & |
与运算 |
6 & 3 = 2 |
| | |
或运算 |
6 | 3 = 7 |
| ^ |
异或运算 |
6 ^ 3 = 5 |
| ~ |
反码 |
~6 = -7 |
| 位运算符的细节 |
|
| << |
空位补0，被移除的高位丢弃，空缺位补0。 |
| >> |
被移位的二进制最高位是0，右移后，空缺位补0； 最高位是1，空缺位补1。 |
| >>> |
被移位二进制最高位无论是0或者是1，空缺位都用0补。 |
| & |
二进制位进行&运算，只有1&1时结果是1，否则是0; |
| | |
二进制位进行 | 运算，只有0 | 0时结果是0，否则是1; |
| ^ |
任何相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0
不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1 |
技巧：可以理解为二进制1就是true，0就是false。
（2）案例
1、左移 （算术移位）
3<< 2 是如何在计算机里是实现的?
首先将3转换为2进制，
| 00000000 |
00000000 |
00000000 |
00000011 |
3 的二进制 |
| 00000000 |
00000000 |
00000000 |
000011 |
左移2位，砍掉高位 |
| 0000 0000 |
0000 0000 |
0000 0000 |
0000 1100 |
低位补0 |
结果是12，所以3<<2 =12;
结论：左移就相当于乘以2的位移个数次幂.
2、右移
6>>2
| 00000000 |
00000000 |
00000000 |
00000110 |
6的二进制 |
| 000000 |
00000000 |
00000000 |
00000001 |
右移10被砍掉 |
| 00000000 |
00000000 |
00000000 |
00000001 |
高位补0 |
结果是1，所以6>>2 =1;
结论一个数往左移越移越大,往右边移越来越小.
推论
3<<2=12; 3<<1=6 ; 3<<3=24;
3*4=12 ; 3*2=6; 3*8=24;
3*22=12; 3*21=6 3*23 =24;
结论往左移几位就是乘以2的几次幂。
右移规律
6>>2=1 ;6>>1=3 ;
6/4=1 ; 6/2=3 ;
右移两位就是除以 2的2次方,右移一位就是除以 2的一次方。
总结 ：>> 是除以2的移动位数次幂
<< 是乘以2的移动位数次幂
用处:最快的运算是位运算。
练习：最有效率的方式算出2经过什么运行得到8？
3、无符号右移 （逻辑移位）
通过演示发现右移时高位就空了出来, >> 右移时高位补什么要按照原有 数据的最高位来决定。
1111-1111 1111-1111 1111-1111 1111-1010 -6>>2
1111-1111 1111-1111 1111-1111 1111-0010
最高位补什么要看原有最高位是什么
那么使用>> 后原来是最高位1 的那么空出来的最高位还是1 的，是0的还是0。
如果使用>>> 无论最高位是0还是1 空余最高位都拿0 补,这就是无符号右移。
1111-1111 1111-1111 1111-1111 1111-1010 -6>>>2
001111-1111 1111-1111 1111-1111 1111-10
结果是；1073741822
10、面试题-交换两个变量的值
方式一:使用temp临时变量
|
|
方式二:不使用临时变量
|
|
方式三:了解即可
|
|
方式四:了解即可
|
|
四、键盘录入Scanner类
1、概述
我们目前在写程序的时候，数据都是代码中定义好的，我们想让数据由键盘中输入，所以可以考虑把数据改进为键盘录入，提高程序的灵活性。
那么该如何实现呢?这就需要使用到引用数据类型Scanner类,它是JDK给我们提供的,使用方式也得按照一定的步骤来
2、使用步骤
1.定义变量，并相应类型的对象赋值给变量：
数据类型 变量名 = new 数据类型();
如:Scanner scanner = new Scanner(System.in);
2.导包：
使用import导包,告诉JVM从哪里去找Scanner类
3.调用Scanner对象方法：
变量名.方法名();
示例代码
| import java.util.Scanner; public class Demo24_键盘输入 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int x = sc.nextInt(); //代码执行到这一步时，会阻塞(停住) 等着键盘从控制台输入，输入完成后回车，把输入的值赋给了x System.out.println("键盘输入的值为："+x); double y = sc.nextDouble(); System.out.println("键盘输入的浮点数值为："+y); } } |
作业
1、随意定义一个变量i = 3287;获取该数字中各个位上的数字
最终输出：个位是7， 十位是8，百位是2， 千位是3
class Day02Homework01 {
public static void main(String[] args) {
int i = 3287;
int ge = i%10;//个位数
int shi = i/10%10;//十位数
int bai = i/100%10;//百位数
int qian = i/1000;//千位数
System.out.println("个位数是:"+ge);
System.out.println("十位数是:"+shi);
System.out.println("百位数是:"+bai);
System.out.println("千位数是:"+qian);
}
}2、给定i和j，int i = 10, j = 20; int z = (i++) + (++j) + (++i)*2 + (j++)*3;
不要写代码，计算i、j、z的值
z=10+21+12*2+21*3=118
i=11 j=21 i=12 j=22
3、定义一个int变量，使用三元运算符，输出这个变量是否可以被7整除
例如，定义变量int a = 10;
最终输出：变量值为10，该变量不能被7整除
class Day02Homework03 {
public static void main(String[] args) {
int a = 66;
String result = a%7==0 ? "能被7整除" : "不能被7整除";
System.out.println(result);
}
}4、double y = 2.825423; 四舍五入取三位小数
/*
4、double y = 2.825423; 四舍五入取三位小数
*/
class Homework04 {
public static void main(String[] args) {
double y = 2.825423;
/*double x = (int)(y*1000+0.5)/1000.0;
System.out.println(x);*/
//String类中的format方法，可以直接把浮点数四舍五入保留n位小数
String str = String.format("%.3f",y);
System.out.println(str);
}
}5、华氏温度和摄氏温度互相转换，
从华氏度变成摄氏度你只要减去32，
乘以5再除以9就行了，
将摄氏度转成华氏度，直接乘以9，除以5，
再加上32即行。
已知 摄氏35度 求华氏温度
已知 华氏100度 求摄氏温度
/*
5、华氏温度和摄氏温度互相转换，
从华氏度变成摄氏度你只要减去32，乘以5再除以9就行了，
将摄氏度转成华氏度，直接乘以9，除以5，
再加上32即行。
已知 摄氏35度 求华氏温度
已知 华氏100度 求摄氏温度
*/
class Homework05 {
public static void main(String[] args) {
double centigrade = 35;
double fahrenheit = 100;
//华氏度转成摄氏度
double fToC = (fahrenheit - 32) * 5 /9;
//摄氏度转成华氏度
double cToF = centigrade * 9 / 5 +32;
System.out.println("华氏100度转换为摄氏度是:"+fToC+"度");
System.out.println("摄氏35度转换为华氏度是:"+cToF+"度");
}
}6、一个任意的5位整数，将它保留到百位，无需四舍五入
/*
6、一个任意的5位整数，将它保留到百位，无需四舍五入
*/
class Homework06 {
public static void main(String[] args) {
int num = 34552;
int num1 = num / 100;
System.out.println(num1);
}
}7、int x = 12345， 求各个位上数字之和
/*
7、int x = 12345， 求各个位上数字之和
*/
class Homework07 {
public static void main(String[] args) {
int num = 12345;
int ge = num % 10;
int shi = num / 10 % 10;
int bai = num / 100 % 10;
int qian = num / 1000 %10;
int wan = num / 10000;
int sum = ge + shi + bai + qian + wan;
System.out.println(sum);
}
}8、 （标识符命名）下面几个变量中，那些是对的？那些是错的？错的请说明理由
A. ILoveJava
B. $20
C. learn@java
D. antony.lee
E. Hello_World
F. 2tigers
/*
变量名哪个正确
A. ILoveJava
B. $20
C. learn@java
D. antony.lee
E. Hello_World
F. 2tigers
*/
class Homework08 {
public static void main(String[] args) {
int ILoveJava;
int $20;
//int learn@java; 编译错误非法字符@
//int antony.lee; 编译错误非法字符@.
int Hello_World;
//int 2tigers; 编译错误数字开头
}
}9、（Java 程序的编译与运行）假设有如下程序：
package com.corejava.chp1;
public class HelloWorld{
public static void main(String args[]){
System.out.println("Hello World");
}
}
问：
1）假设这个代码存在hello.java 文件中，那这个程序能够编译通过？为什么？
不能,因为类HelloWorld是公共的,
2）如果编译不通过，应该如何改进？
应在名为 HelloWorld.java 的文件中声明
如果类名前加上public，类名与源文件名必须保持一致
10、(三目运算语句）判断一个整数是奇数还是偶数
int i = 10;
String str = i%2==0?”偶数”:”奇数”;
/*
10、(三目运算语句）判断一个整数是奇数还是偶数
*/
class Homework10 {
public static void main(String[] args) {
int num = 66;
String result = (num % 2 == 0) ? "是偶数" : "是奇数";
System.out.println(num+result);
}
}