第2章Java基本语法1

本章内容

第一节 标识符

第二节 变 量

第三节 进制与位运算（选学）

第四节 变量的数据类型

第五节 运算符

第一节 标识符和关键字

标识符

标识符：

Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符

凡是自己可以起名字的地方都叫标识符。

定义合法标识符规则：

由26个英文字母大小写，0-9 ，_或 $ 组成

数字不可以开头。

不可以使用关键字和保留字，但能包含关键字和保留字。

Java中严格区分大小写，长度无限制。

标识符不能包含空格。

注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

Java语言的关键字（保留字）

用于定义数据类型的关键字

string
class	interface	enum	byte	short
int	long	float	double	char
boolean	void

用于定义流程控制的关键字

if	else	switch	case	default
while	do	for	break	continue
return

用于定义访问权限修饰符的关键

private

protected

public

用于定义类，函数，变量修饰符的关键字

abstract

final

static

synchronized

用于定义类与类之间关系的关键字

extends

implements

用于定义建立实例及引用实例，判断实例的关键字

new

this

super

instanceof

用于异常处理的关键字

try

catch

finally

throw

throws

用于包的关键字

package

import

其他修饰符关键字

native

strictfp

transient

volatile

assert

用于定义数据类型值的字面值

true

false

null

注意一点:我们自己中程序中取的名字,不管是类名,文件们,变量名,还是其他,不能和关键字一模一样(拼写,大小写一样)

保留字(reserved word)

Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使

用。自己命名标识符时要避免使用这些保留字

goto 、const

Java中的名称命名规范

Java中的名称命名规范：

包名：多单词组成时所有字母都小写：xxxyyyzzz

类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

第二节 变 量

int var2 = 20;

变 量

变量的作用 — 保存数据

声明变量

语法：

例如：int var;

变量的赋值

语法： =

例如：var = 10;

声明和赋值变量

语法： =

例如：int var = 10;

变量的概念：

内存中的一个存储区域

该区域有自己的名称（变量名）和类型（数据类型）

Java中每个变量必须先声明，后使用

该区域的数据可以在同一类型范围内不断变化

使用变量注意：

变量的作用域：一对{ }之间有效

初始化值

变量是通过使用变量名来访问这块区域的

补充：变量的分类-按声明的位置的不同

在方法体外，类体内声明的变量称为成员变量。

在方法体内部声明的变量称为局部变量。

注意：二者在初始化值方面的异同:

同：都有生命周期 异：局部变量除形参外，需显式初始化。

练 习

编写一个Variable类，main方法中声明两个变量var1和var2并赋值，声明var3变量，保存var1和var2之积，然后打印输出var3的值。

第三节 进制与位运算（选学）

进 制

对于整数，有四种表示方式：

二进制：0,1 ，满2进1.以0b或0B开头。

十进制：0-9 ，满10进1.

八进制：0-7 ，满8进1.八进制数被冠以0来表示。

十六进制：0-9及A-F，满16进1.十六进制数被冠以0X来表示（字母大小写均可）

如： 0x3f20（十六进制） 0732 （八进制）

十进制	十六进制	八进制	二进制
0	0	0	0
1	1	1	1
2	2	2	10
3	3	3	11
4	4	4	100
5	5	5	101
6	6	6	110
7	7	7	111
8	8	10	1000

进制间转化

进制的基本转换

十进制 二进制互转

二进制转成十进制 乘以2的幂数

十进制转成二进制 除以2取余数

二进制 八进制互转

二进制 十六进制互转

十进制 八进制互转

十进制 十六进制互转

十 十六

十六进制->十进制 ：乘16 的操作

16进制就是逢16进1，但我们只有0~9这十个数字，所以我们用A，B，C，D，E，F这六个字母来分别表示10，11，12，13，14，15。字母不区分大小写。

十六进制数的第0位的权值为16的0次方，第1位的权值为16的1次方，第2位的权值为16的2次方……

所以，在第N（N从0开始）位上，如果是是数 X （X 大于等于0，并且X小于等于 15，即：F）表示的大小为 X * 16的N次方。

假设有一个十六进数 2AF5, 那么如何换算成10进制？

用竖式计算：

2AF5换算成10进制:第0位：

第1位：

第2位：

第3位：

直接计算就是：

可以看出，所有进制换算成10进制，关键在于各自的权值不同。

十进制->十六进制 ：除16的操作

对于整数部分，用被除数反复除以16，除第一次外，每次除以16均取前一次商的整数部分作被除数并依次记下每次的余数。另外，所得到的商的最后一位余数是所求二进制数的最高位。

对于小数部分，采用连续乘以基数16，并依次取出的整数部分，直至结果的小数部分为0为止。故该法称“乘基取整法”。

给你一个十进制，比如：120，如何将它转换成十六进制数呢？

10进制数转换成十六进制数，这是一个连续除以16的过程：把要转换的数，除以16，得到商和余数，将商继续除以16，直到商为0。最后将所有余数倒序排列，得到数就是转换结果。

比如要转换120为十六进制数：

“把要转换的数，除以16，得到商和余数”，那么：要转换的数是120， 120 ÷ 16，得到商是7，余数是8。

“将商继续除以16,直到商为0……”，现在商是7，还不是0，所以继续除以16。

那就： 7 ÷ 16, 得到商是0,余数是7。现在商已经是0。

我们两次计算依次得到余数分别是：8、7，将所有余数倒序排列，那就是：78。

故120转换成十六进制，结果是78。

十六进制 二进制

十六进制数转换成二进制数：

每一位十六进制数，转换为四位二进制数。

二进制数转换成十六进制数：

取四合一法，即从二进制的小数点为分界点，向左（或向右）每四位取成一组。

八进制 二进制

二进制数转换成八进制数：

把每一个八进制数字改写成等值的三位二进制数,并保持高低位的次序不变即可。

（为了方便同学们记忆，我们可以把一个八进制数看看是421中哪些数或组合组成的，例如八进制的5是由4+1得来的，所以4和1对应1.2对应0，结果就是101）

八进制数转换成二进制数：

把每一个八进制数字改写成等值的三位二进制数,并保持高低位的次序不变即可。（为了方便同学们记忆，我们可以把一个八进制数看看是421中哪些数或组合组成的，例如八进制的5是由4+1得来的，所以4和1对应1.2对应0，结果就是101）

十进制 二进制

十进制 -> 二进制 ：

除2的操作

6 -> 1 1 0

二进制 -> 十进制 ：

要将二进制数为十进制数，只要反过来算就可以了。

十进制 八进制

十进制 -> 八进制

间接法：先将十进制转换成二进制，然后将二进制又转换成八进制  。

.直接法：前面我们讲过，八进制是由二进制衍生而来的，因此我们可以采用与十进制转换为二进制相类似的方法，分为整数部分的转换和小数部分的转换：

整数部分方法：除8取余法，即每次将整数部分除以8，余数为该位权上的数，而商继续除以8，余数又为上一个位权上的数，这个步骤一直持续下去，直到商为0为止

最后读数时候，从最后一个余数起，一直到最前面的一个余数

八进制 -> 十进制

按权相加法，即将八进制每位上的数乘以位权，然后相加之和即是十进制数。

位权就是，小数点前一位就是8的0次方，小数点后一位就是8的-1次方

原码、反码、补码

所有数字在计算机底层都以二进制形式存在。

计算机以补码的形式保存所有的整数。

正数的原码、反码、补码都相同

负数的补码是其反码加1。

原码：直接将一个数值换成二进制数。

反码：是对原码按位取反，只是最高位（符号位）确定为1。

Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认占64位，第64位是符号位

练 习

将以下十进制数转换为十六进制和二进制

123 256 87 62

将以下十六进制数转换为十进制和二进制

0x123 0x25F 0x38 0x62

位与字节

计算机中任何的计算和存储都是以二进制方式实现的

位（bit） — 是计算机中最小的存储单位

字节（byte） — 计算机中基本的存储单元

1byte = 8bits

0/1	0/1	0/1	0/1	0/1	0/1	0/1	0/1
7	6	5	4	3	2	1	0

位运算符

位运算符
运算符	运算	范例
	左移	3  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
~	正数取反，各二进制码按补码各位取反 负数取反，各二进制码按补码各位取反

按位取反或补( ~ )

例如： ~0x3F -> 0011 1111

=0xC0 -> 1100 0000

按位或( | )

0 | 0 = 0

1 | 0 = 1

1 | 1 = 1

例如： 0x3f -> 0011 1111

| 0x6d -> 0110 1101

= 0x7f -> 0111 1111

按位与( & )

0 & 0 = 0

0 & 1 = 0

1 & 1 = 1

例如： 0x3f -> 0011 1111

& 0x6d -> 0110 1101

= 0x2d -> 0010 1101

-13 在计算机中的存储形式

0000 1101 -13 的原码

1111 0010 -13 的反码

1111 0011 -13 的补码

0000 1100

0000 1101

1111 0101	1110 0111
1111 0100	1110 0110
0000 1011	0001 1001
-11

按位异或 ( ^ )

0 ^ 0 = 0

0 ^ 1 = 1

1 ^ 1 = 0

例如： 0x3f -> 0011 1111

^ 0x6d -> 0110 1101

= 0x52 -> 0101 0010

负数的位表示

负数的位表示为正数取反加一

例如： 63 = 0x3F -> 0011 1111

-63 = 0xC1 ->1100 0001

在用位表示负数时，最高位为符号位，1表示负数

第四节 变量的数据类型

变量的数据类型

对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。

8种基本数据类型—整型

Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。

java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’

类   型	占用存储空间	表数范围
byte	1字节=8bit位	-128 ~ 127
short	2字节	-215 ~215-1
int	4字节	-231 ~ 231-1
long	8字节	-263 ~ 263-1

8种基本数据类型—浮点型

与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体OS的影响。

Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。

浮点型常量有两种表示形式：

十进制数形式：如：5.12 512.0f .512 (必须有小数点）

科学计数法形式:如：5.12e2 512E2 100E-2

类  型	占用存储空间	表数范围
单精度float	4字节	-3.403E38 ~ 3.403E38
双精度double	8字节	-1.798E308 ~ 1.798E308

示 例

public class TestNum {

public static void main(String[] args) {

int no = 32920;

System.out.println("byte no = " + no);

long lnum = 1234567L;

long lnum1 = 1234567l;

System.out.println("long lnum1 = " + lnum1);

double num = 123.123456789123456789;

double num1 = 123.123456789123456789d;

double num2 = 123.123456789123456789D;

System.out.println("double num = " + num);

float numf = 123.123456789123456789f;

float numf1 = 123.123456789123456789F;

System.out.println("float numf = " + numf);

}

}

8种基本数据类型—字符型

char 型数据用来表示通常意义上“字符”(2字节)

字符型常量的三种表现形式：

字符常量是用单引号(‘ ’)括起来的单个字符，涵盖世界上所有书面语的字符。例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';

Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’; // '\n'表示换行符

直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n。

char类型是可以进行运算的。因为它都对应有Unicode码。

ASCII 码

在计算机内部，所有数据都使用二进制表示。每一个二进制位（bit）有 0 和 1 两种状态，因此 8 个二进制位就可以组合出 256 种状态，这被称为一个字节（byte）。一个字节一共可以用来表示 256 种不同的状态，每一个状态对应一个符号，就是 256 个符号，从 00000000 到 11111111。

ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。

缺点：

不能表示所有字符。

相同的编码表示的字符不一样：比如，130在法语编码中代表了é，在希伯来语编码中却代表了字母Gimel (ג)

Unicode 编码

乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。

Unicode：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用 Unicode 没有乱码的问题。

Unicode 的缺点：Unicode 只是一个符号集，它只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储：无法区别 Unicode 和 ASCII：计算机无法区分三个字节表示一个符号还是分别表示三个符号

UTF-8

UTF-8 是在互联网上使用最广的一种 Unicode 的实现方式。

UTF-8 是一种变长的编码方式。它可以使用 1-6 个字节表示一个符号，根据不同的符号而变化字节长度。

UTF-8的编码规则：

对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于ASCII码）。

对于多字节的UTF-8编码，如果编码包含 n 个字节，那么第一个字节的前 n 位为1，第一个字节的第 n+1 位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的所有的字节，都是最高两位为"10"，其余6位用来对字符进行编码。

示 例

1 public class TestNum1 {

2 public static void main(String[] args) {

3 char c = 'b';

4 char c1 = 'Z';

5 char c2 = '0';

6 char c3 = '$';

7 char c4 = '\n'; //换行 -转义字符

8 char c5 = '\r'; //回车

9 char c6 = '\t'; //制表符

10 char c7 = '张';

11

12 System.out.println("char c = " + c);

13 System.out.println("ASCII c = " + (int)c);

14 System.out.println("ASCII a = " + (int)'a');

15 System.out.println("ASCII A = " + (int)'A');

16 System.out.println("ASCII Z = " + (int)'Z');

17

18 System.out.println("ASCII 0 = " + (int)'0');

19 System.out.println("ASCII 1 = " + (int)'1');

20

21 System.out.println("ASCII 9 = " + (int)'9');

22 System.out.println("ASCII \r = " + (int)'\r');

23 System.out.println("ASCII \n = " + (int)'\n');

24

25 char c8 = '\u5f20';

26 System.out.println("Unicode 5f20 = " + c8);

27 }

28 }

8种基本数据类型—布尔型

boolean 类型适于逻辑运算，一般用于程序流程控制：

if条件控制语句；

while循环控制语句；

do-while循环控制语句；

for循环控制语句；

boolean类型数据只允许取值true和false，无null。

不可以0或非 0 的整数替代false和true，这点和C语言不同。

基本数据类型转换

自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：

有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。

byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。

当把任何基本类型的值和字符串值进行连接运算时(+)，基本类型的值将自动转化为字符串类型。

强制类型转换

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符（()），但可能造成精度降低或溢出,格外要注意。

通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。

如： String a = “43”; int i = Integer.parseInt(a);

boolean类型不可以转换为其它的数据类型。

练 习

判断是否能通过编译

1）short s = 5; s = s-2; //判断： 2） byte b = 3; b = b + 4; //判断： b = (byte)(b+4); //判断： 3）char c = ‘a’; int i = 5; double d = .314; double result = c+i+d; //判断： 4） byte b = 5; short s = 3; short t = s + b; //判断

字符串类型String

String不是基本数据类型，属于对象类型或引用数据类型

使用方式与基本数据类型一致。例如：

String str = “abcd”;

一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：

str = str + “xyz” ; 或 str += “xyz” ;

int n = 100;

str += n;

注：当字符串与任何基本数据类型进行运算，都将串接为字符串类型（考虑优先级）。

示 例—TestString类

1 public class TestString { 2 public static void main(String[] args) { 3 int no = 10; 4 String str = "abcdef"; 5 String str1 = str + "xyz"; 6 7 str1 += "123"; 8 char c = '国'; 9 10 double pi = 3.1416; 11 str1 += pi; 12 boolean b = false; 13 str1 += b; 14 str1 += c; 15 16 System.out.println("str1 = " + str1); 17 } 18 } 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); //输出：

改进Variable类，main方法中使用double类型声明var1和var2变量，然后用var2保存var1与var2之商。

声明字符串变量str，用str串接的形式表示上述计算并打印输出结果。

第五节 运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

算术运算符

赋值运算符

比较运算符（关系运算符）

逻辑运算符

位运算符

三元运算符

算术运算符

运算符	运算	范例	结果
+	正号	+3	3
-	负号	b=4; -b	-4
+	加	5+5	10
-	减	6-4	2
*	乘	3*4	12
/	除	5/5	1
%	取模	7%5	2
++ ++	自增（前）：先运算后取值 自增（后）：先取值后运算	a=2;b=++a; a=2;b=a++;	a=3;b=3 a=3;b=2
- - - -	自减（前）：先运算后取值 自减（后）：先取值后运算	a=2;b=- -a a=2;b=a- -	a=1;b=1 a=1;b=2
+	字符串相加	“He”+”llo”	“Hello”

算术运算符的注意问题

如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。

对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。 例如：int x=3510;x=x/1000*1000; x的结果是？

“+”除字符串相加功能外，还能把非字符串转换成字符串.例如：System.out.println("5+5="+5+5); //打印结果是？

练 习—算术运算符：自加、自减

public class TestSign{ public static void main(String[] args){ int i1 = 10,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); } }

赋值运算符

符号：=

当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。

支持连续赋值。

扩展赋值运算符： +=, -=, *=, /=, %=

思考：

boolean b1 = false;

//区分好==和=的区别。

if(b1=true)

System.out.println("结果为真");

else

System.out.println("结果为假");

思考：

int i = 1;

i *= 0.1;

System.out.println(i);//

i++;

System.out.println(i);//

比较运算符

运算符	运算                                 范例                                         结果
==	相等于                               4==3                                        false
!=	不等于                               4!=3                                          true
	小于                                   4
>	大于                                   4>3                                           true
	小于等于                           4
>=	大于等于                           4>=3                                         true
instanceof	检查是否是类的对象       “Hello”  instanceof  String        true

比较运算符的结果都是boolean型，也就是要么是true，要么是false。

比较运算符“==”不能误写成“=” 。

逻辑运算符

&—逻辑与 | —逻辑或 ！—逻辑非

&& —短路与 || —短路或 ^ —逻辑异或

a	b	a&b	a|b	!a	a^b	a&&b	a||b
true	true	true	true	false	false	true	true
true	false	false	true	false	true	false	true
false	true	false	true	true	true	false	true
false	false	false	false	true	false	false	false

逻辑运算符

逻辑运算符用于连接布尔型表达式，在Java中不可以写成33 & x

“&”和“&&”的区别：

单&时，左边无论真假，右边都进行运算；

双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

“|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。

异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。

理解：异或，追求的是“异”!

练 习—写出每题的输出结果

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);

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);

三元运算符

格式:

表达式1和表达式2为同种类型

三元运算符与if-else的联系与区别：

1）三元运算符可简化if-else语句

2）三元运算符要求必须返回一个结果。

3）if后的代码块可有多个语句

练 习

1. 使用三元运算符，获取两个数中的较大数

int x = 1,y = 1; (x > y)?x:y;

1. 使用三元运算符，获取三个数中的较大数

int x = 1,y = 2,z = 3; int a = (x > y)?x:y; int b = (a > y)?a:z;

day02课后练习-变量

基础题目:

第一题

• 按步骤编写代码，效果如图所示：

编写步骤：

1. 定义类 Test1
2. 定义 main方法
3. 定义两个byte类型变量b1,b2,并分别赋值为10和20.
4. 定义变量b3,保存b1和b2的和,并输出.
5. 定义两个short类型变量s1,s2,并分别赋值为1000和2000.
6. 定义变量s3,保存s1和s2的和,并输出.
7. 定义一个char类型变量ch1赋值为'a',一个int类型变量i1赋值为30.
8. 定义变量ch3,保存c1和i1的差,并输出.

public class Test01 { public static void main(String[] args) { byte b1 = 10; byte b2 = 20; byte b3 = (byte)(b1 + b2); System.out.println("byte类型的b1和b2的和为："); System.out.println(b3); short s1 = 1000; short s2 = 2000; short s3 = (short)(s1 + s2); System.out.println("short类型的s1和s2的和为："); System.out.println(s3); char c1 = 'a'; int i1 = 30; int ch3 = c1 - i1; System.out.println("char类型的ch1和int类型的i1的差："); System.out.println(ch3); } }

第二题

• 按步骤编写代码，效果如图所示：

编写步骤：

• 1. 定义类 Test2
  2. 定义 main方法
  3. 定义 int类型变量i1 和 long类型变量l1
  4. 定义变量add,保存i1和l1的和,并输出.
  5. 定义 long类型变量l2 和 float类型变量f2
  6. 定义变量add2,保存l2和f2的和,并输出.
  7. 定义 int类型变量i3 和 double类型变量d3
  8. 定义变量add3,保存i3和d3的和,并输出.
  9. 定义 float类型变量f4 和 double类型变量d4
  10. 定义变量add4,保存f4和d4的和,并输出.

public class Test2 { public static void main(String[] args) { int i1 = 100; long l1 = 200; long add = i1 + l1; System.out.println("add的值：" + add); long l2 = 1000000L; float f2 = 0.44F; float add2 = l2 + f2; System.out.println("add2的值：" + add2); int i3 = 100000; double d3 = 0.45; double add3 = i3 + d3; System.out.println("add3的值：" + add3); float f4 = 1000000; double d4 = 1.2625; double add4 = f4 + d4; System.out.println("add4的值：" + add4); } }

第三题

• 按步骤编写代码，效果如图所示：

编写步骤：

• 1. 定义类 Test3
  2. 定义 main方法
  3. 定义char类型变量ch,赋值为'J'
  4. 使用强制转换的方式,将变量ch转换为小写'j',并输出
  5. 定义char类型变量ch2,赋值为'a'
  6. 使用+=的方式,将变量ch2转换为大写'A',并输出
  7. 定义double类型变量d3,int类型变量i3
  8. 定义double变量sum3,保存d3与i3的和,输出sum3的值和sum3去除小数部分的值
  9. 定义double类型变量d4,int类型变量i4
  10. 定义int变量mul4,保存d4和i4乘积的整数部分,并输出

public class Test03 { public static void main(String[] args){ char ch = 'J'; char ch1 = (char)(ch + 32); System.out.println(ch1); char ch2 = 'a'; ch2 -= 32; System.out.println(ch2); double d3 = 100.5; int i3 = 3; double sum3 = d3 + i3; int sum4 = (int)sum3; System.out.println("sum3的值：" + sum3); System.out.println("sum3的整数部分的值：" + sum4); double d4 = 4.0; int i4 = 435; int mul4 = (int)(d4 * i4); System.out.println("mul4的整数部分的值：" + mul4); } }

第四题

• 按步骤编写代码，效果如图所示：

编写步骤：

• 1. 定义类 Test4
  2. 定义 main方法
  3. 定义两个int类型变量a1和a2,分别赋值10,11,判断变量是否为偶数,拼接输出结果
  4. 定义两个int类型变量a3和a4,分别赋值12,13,判断变量是否为奇数,拼接输出结果

public class Test04 { public static void main(String[] args) { int a1 = 10; int a2 = 11; int a3 = 12; int a4 = 13; System.out.println("10是偶数？" + (a1 % 2 == 0)); System.out.println("11是偶数？" + (a2 % 2 == 0)); System.out.println("12是奇数？" + (a3 % 2 != 0)); System.out.println("13是奇数？" + (a4 % 2 != 0)); } }

第五题

• 按步骤编写代码，效果如图所示：

编写步骤：

• 1. 定义类 Test5
  2. 定义 main方法
  3. 定义一个int类型变量a,变量b,都赋值为20.
  4. 定义boolean类型变量bo , 判断++a 是否被3整除,并且a++ 是否被7整除,将结果赋值给bo
  5. 输出a的值,bo的值.
  6. 定义boolean类型变量bo2 , 判断b++ 是否被3整除,并且++b 是否被7整除,将结果赋值给bo2
  7. 输出b的值,bo2的值.

public class Test05 { public static void main(String[] args){ int a = 20; int b = 20; boolean bo = ((++a % 3) == 0) && ((a++ % 7) == 0); boolean bo2 = ((b++ % 3) == 0) && ((++b % 7) == 0); System.out.println("bo的值：" + bo); System.out.println("a的值：" + a); System.out.println("----------------------------"); System.out.println("bo2的值：" + bo2); System.out.println("b的值：" + b); } }

第六题

案例：为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？

• 按步骤编写代码，效果如图所示：

编写步骤：

• 1. 定义类Test6
  2. 定义main方法
  3. 定义一个int类型变量hours，赋值为89
  4. 定义一个int类型变量day，用来保存89小时中天数的结果
  5. 定义一个int类型变量hour，用来保存89小时中不够一天的剩余小时数的结果
  6. 输出结果

public class Test06 { 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 +"小时"); } }

第七题

案例：今天是周2，100天以后是周几？

• 按步骤编写代码，效果如图所示：

编写步骤：

• 1. 定义类Test7
  2. 定义main方法
  3. 定义一个int类型变量week，赋值为2
  4. 修改week的值，在原值基础上加上100
  5. 因为week的值加上100后超过了星期的范围，重写修改week的值
  6. 输出结果，在输出结果的时候考虑特殊值，例如周日

public class Test07 { public static void main(String[] args){ int week = 2; week += 100; week %= 7; System.out.println("今天是周2,100天以后是周" + (week==0?"日":week)); } }

第八题

案例：求三个整数x,y,z中的最大值

• 按步骤编写代码，效果如图所示：

编写步骤：

• 1. 定义类Test8
  2. 定义main方法
  3. 定义三个int类型变量,x,y,z，随意赋值整数值
  4. 定义一个int类型变量max，先存储x与y中的最大值（使用三元运算符）
  5. 再次对max赋值，让它等于上面max与z中的最大值（使用三元运算符）
  6. 输出结果

public class Test08 { public static void main(String[] args) { int x = 3; int y = 4; int z = 1; int max = x > y ? x : y; max = max > z ? max : z; System.out.println(x + "," + y + "," + z + "中的最大值是：" + max); } }

第九题

案例：给定一个年份，判断是否是闰年

闰年的判断标准是：

​ 1）可以被4整除，但不可被100整除

​ 2）可以被400整除

• 按步骤编写代码，效果如图所示：

编写步骤：

• 1. 定义类Test9
  2. 定义main方法
  3. 定义一个int类型变量year，随意赋值一个年份
  4. 定一个一个boolean类型变量，用来保存这个年份是否是闰年的结果
  5. 输出结果

public class Test09 { public static void main(String[] args) { int year = 2018; boolean result = year%4==0 && year%100!=0 || year%400==0; System.out.println(year + (result ? "是闰年" : "不是闰年")); } }

第十题

案例：小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。它需要一个程序将华氏温度（80度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。

按步骤编写代码，效果如图所示：

编写步骤：

• 1. 定义类Test10
  2. 定义main方法
  3. 定义一个double类型变量hua，存储华氏温度80
  4. 定义一个double类型变量she，存储摄氏温度，根据公式求值
  5. 输出结果

public class Test10 { public static void main(String[] args) { double hua = 80; double she = (hua-32)/1.8; System.out.println("华氏度" + hua+"℉转为摄氏度是" +she+"℃"); } }

阅读代码题：

第一题

如下代码的计算结果是： int i = 1; i *= 0.2; i++; System.out.println("i=" + i);//i=1

第二题

如下代码的运算结果是： int i = 2; i *= i++; int j = 2; j *= j+1; int k = 2; k *= ++k; System.out.println("i=" + i);//i=4 System.out.println("j=" + j);//i=6 System.out.println("k=" + k);//i=6

第三题

public static void main(String[] args) { int a = 3; int b = 1; if(a = b){//编译报错 System.out.println("Equal"); }else{ System.out.println("Not Equal"); } }

第四题

public static void main(String[] args) { int a = 8, b = 3; System.out.println(a>>>b);//1 System.out.println(a>>>b | 2);//3 }

0000 1000

0000 0001

0000 0010

0000 0011