【韩顺平Java笔记】第3章：变量

只记录我觉得重点的，自用，如果有漏的请自己看视频

文章目录

33. 内容梳理
34. 变量原理
34.1 为什么需要变量
35. 变量概念
35.1 概念
35.2 变量使用的基本步骤
36. 变量入门
- 36.1 变量使用入门案例
37. 变量细节
- 37.1 变量使用注意事项
38. 加号使用
- 38.1 程序中+号的使用
39. 数据类型
40. 整型使用
- 40.1 整数的类型
41. 整型细节
- 41.1 整型的使用细节
42. 浮点数使用
- 42.1 浮点型的分类
43. 44. 浮点数细节1,2
45. Java API文档
46. 字符型使用
47. 字符型细节
- 47.1 字符类型使用细节
48. 字符型本质
- 48.1 字符类型本质探讨
49. 常用编码
- 49.1 ASCII 码
- 49.2 Unicode 编码
- 49.3 UTF-8 编码
50. 布尔类型
51. 自动类型转换基础
52. 53. 自动类型转换细节1
54. 强制类型转换基础
55. 强制类型转换细节
56. 类型转换练习
57. String和基本类型转换
58. String转基本数据类型细节
59. 60. 本章作业

33. 内容梳理

详见视频，回顾第2章内容

34. 变量原理

34.1 为什么需要变量

变量是程序的基本组成单位

不论是使用哪种高级程序语言编写程序，变量都是其程序的基本组成单位

//变量有三个基本要素（类型+名称+值）
public class Test
{
	public static void main(String[] args)
	{
		int a = 1;//定义了一个变量，类型int整型，名称a ，值1
		int b = 3;//定义了一个变量，类型int整型，名称b ，值3
		b = 89;//把89值赋值给b变量
		System.out.println(a);//输出a变量的值
		System.out.println(b);//输出b变量的值
	}
}

创建一个变量会在内存中开辟一段空间

实际上这个变量名在计算机中对应的是主存单元地址（详细见计算机组成原理）

35. 变量概念

35.1 概念

变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房价，而通过变量名可以访问到变量（值）。

35.2 变量使用的基本步骤

声明变量，如：int a;
赋值，如a = 60; //应该这么说：把60赋给a
使用System.out.println(a);//输出结果

也可以一步到位[int a = 60; //通常我们是一步完成]
声明变量的简单例子代码：

public class Var01
{
	public static void main(String[] args)
	{
		//声明变量
		int a;
		a = 100;
		System.out.println(a);

		//还可以这样使用
		int b = 800;
		System.out.println(b);
	}
}

编译运行结果：

36. 变量入门

36.1 变量使用入门案例

演示记录人的信息的代码，用不同的数据类型来记录这个人的信息。
代码：

public class Var02
{
	//编写一个main方法
	public static void main(String[] args)
	{
		//记录人的信息
		int age = 30;
		double score = 88.9;
		char gender = '男';
		String name = "king";
		//输出信息
		System.out.println("人的信息如下");
		System.out.println(name);
		System.out.println(age);
		System.out.println(score);
		System.out.println(gender);
	}
}

编译运行结果：

37. 变量细节

37.1 变量使用注意事项

变量表示内存中的一个存储区域[不同的变量，类型不同，占用的空间大小不同
比如:int 4 个字节， double 就是 8个字节,先有基本印象，后面说字节]
该区域有自己的名称[变量名]和类型[数据类型]
变量必须先声明，后使用，即有顺序
该区域的数据/值可以在同一类型范围内不断变化
变量在同一个作用域内不能重名
变量=变量名+值+数据类型，这一点请大家注意。变量三要素。

举例子的代码：

public class VarDetail
{
	public static void main(String[] args)
	{
		//变量必须先声明，后使用，即有顺序
		int a = 50;
		System.out.println(a);
	}
}

运行结果：

反过来不行：

如果后期赋值将a赋值为String类型也会报错，变量必须保持一个类型。

变量在同一个作用域里不能重复定义：

但是在不同的作用域（比如不同的类）可以重复定义同一个名字的变量：

38. 加号使用

38.1 程序中+号的使用

当左右两边都是数值型时，则作加法运算；
当左右两边有一方为字符串，则作拼接运算；
运算顺序是从左到右

下面代码输出什么？

System.out.println(100 + 98);//198
System.out.println("100" + 98);//10098
System.out.println(100 + 3 + "hello");//从左到右，先算数值型100+3=103，然后将1-3和hello字符串拼接最后得103hello
System.out.println("hello" + 100 +3);//先拼接hello字符串和数值100，然后变为字符串hello100后再拼接3，变成字符串hello1003

39. 数据类型

每一种数据都定义了明确得数据类型，再内存中分配了不同大小的内存空间（字节）。

上图说明

java 数据类型分为两大类基本数据类型，引用类型
基本数据类型有 8 中数值型 [byte , short , int , long , float ,double] char , boolean
引用类型 [类，接口，数组]

【注】String不是基本数据类型，它是一个类。

40. 整型使用

40.1 整数的类型

Java的整数类型就是用于存放整数值的，比如12，30，3456等等，范围是根据二进制位数来确定的，具体可见计算机组成原理。

类型	占用存储空间	范围
byte[字节]	1字节	-128~127
shott[短整型]	2字节	$-2^{15}\sim 2^{15}-1 \\ -32768\sim 32767$
int[整型]	4字节	$-2^{31}\sim 2^{31}-1\\-2147483648 \sim 2147483647$
long[长整型]	8字节	$-2^{63}\sim 2^{63}-1$

41. 整型细节

41.1 整型的使用细节

Java各整数类型有固定的范围和字段长度，不受具体OS[操作系统]的影响，以保证java程序的可移植性。
Java的整型常量(具体值)默认为int 型，声明long型常量须后加’l’或’L’；
比如：

int n1 = 1;
int n2 = 1l; //错的，左侧是int，右侧是long，无法赋值，编译器先发现右侧是long类型，占8个字节

这样写就对了：

long n3 = 1L;//或者写1l，小写的l也对

java程序中变量常声明为int型，除非不足以表示大数，才使用long；（尽可能占用的字节数少）
bit: 计算机中的最小存储单位。byte:计算机中基本存储单元,1byte =8 bit。
[二进制再详细说，简单举例一个 byte 3 和 short 3 ]

byte n1 = 3;
short n2 = 3:

思考题:long 类型，有几个 bit [8个字节*8bit= 64]
long n = 3;// 内存中存在形式（画八个字节，从右往左最开始第0位，第1位是1，剩下全是0）

42. 浮点数使用

Java的浮点类型可以表示一个小鼠，比如123.4，7.8，0.12等等

42.1 浮点型的分类

类型	占用存储空间	范围
单精度float	4字节	-3.403E38~3.403E38，即 $-3.403^{38}\sim3.403^{38}$
双精度double	8字节	-1.798E308~1.798E308，即 $-1.798^{308}\sim1.798^{308}$

【注】1)关于浮点数在机器中存放形式的简单说明，浮点数=符号位+指数位+尾数位；
2)尾数部分可能丢失，造成精度损失（小数都是近似值）

43. 44. 浮点数细节1,2

与整数类型类似，Java浮点类型也有固定的范围和字段长度，不受具体OS的影响。[float 4个字节，double 是8个字节]
Java的浮点型常量默认位double型，声明float型常量，须后加’f’或’F’；
浮点型常量有两种表示形式：
十进制数形式：如： 5.12 512.0f .512（必须有小数点）
科学计数法形式：如 5.12e2[] 5.12E-2[]
通常情况下，应该使用double型，因为它比float型更精确。
double num9 = 2.1234567851;
float num10 = 2.1234567851F;
浮点数使用陷阱：2.7和8.1/3比较

public class FloatDetail
{
	public static void main(String[] args)
	{
		//Java的浮点型常量默认位double型，声明float型常量，须后加'f'或'F'；
		//float num1 = 1.1; //不做任何处理占8个字节的double，这是错误的
		float num2 = 1.1F; //对的，明确告诉编译器这是float，写小写的f也可以
		double num3 = 1.1; //对的
		double num4 = 1.1F; //把占字节数小的float放入占8个字节的double中是可以的
		//十进制数形式：如： 5.12	512.0f	.512（必须有小数点）
		double num5 = .123; //等价于0.123
		System.out.println(num5);//打印出0.123
		//科学计数法形式：如 5.12e2[]	5.12E-2[]
		System.out.println(5.12e2);//512.0
		System.out.println(5.12E-2);//0.0512
		//通常情况下，应该使用double型，因为它比float型更精确。
		double num9 = 2.1234567851;
		float num10 = 2.1234567851F;
		System.out.println(num9);
		System.out.println(num10);
		//看卡一段代码
		double num11 = 2.7;
		double num12 = 8.1 / 3;//正常应该是2.7
		System.out.println(num11);
		System.out.println(num12);//接近2.7的一个小数，而不是2.7，小数进行运算的是近似运算
		//可以参考IEEE浮点数标准和计算机组成原理教材的除法器设计
		//得到一个重要的使用点：当我们对运算结果是小鼠的进行相等判断是，要小心
		//比较两个浮点数是否相等，应该是以两个数的差值的绝对值在某个精度范围内判断
		if(num11 == num12)
		{
			System.out.println("相等");//不会输出，不相等
		}
		//正确的写法，Math.abs是绝对值函数
		System.out.println(Math.abs(num11 - num12));//打印相差多少
		if(Math.abs(num11 - num12)<0.000001)//相差0.000001就算相等
		{
			System.out.println("插值非常小，到我的规定精度，认为相等……");//会输出
		}
		//细节：如果是直接查询得到的小数或者直接赋值，是可以判断相等
	}
}

运行结果：

45. Java API文档

APl(Application Programming Interface,应用程序编程接口)是 Java 提供的基本编程接口(java提供的类还有相关的方法)。中文在线文档:https://www.matools.com
Java语言提供了大量的基础类，因此 Oracle公司也为这些基础类提供了相应的API文档，用于告诉开发者如何使用这些类，以及这些类里包含的方法。
Java类的组织形式
举例说明如何使用API，查找ArrayList类：
知道在哪个包里：

不知道在哪个包里（比如找Math类）：

46. 字符型使用

字符类型可以表示单个字符,字符类型是char，char是两个字节(可以存放汉字)
多个字符我们用字符串String(我们后面详细讲解String)
演示代码：

//演示char的基本使用
public class Char01
{
	public static void main(String[] args)
	{
		char c1 = 'a';
		char c2 = '\t';
		char c3 = '韩';
		char c4 = 97; //说明：字符类型可以直接存放一个数字
		System.out.println(c1);
		System.out.println(c2);
		System.out.println(c3);
		System.out.println(c4);
	}
}

运行结果：
输出c4的时候，会输出97这个数字表示的那个字符，这里会涉及到编码的概念，后面详细介绍。

47. 字符型细节

47.1 字符类型使用细节

字符常量是用单引号(‘’)括起来的单个字符。例如:
char c1 =‘a’;
char c2 =‘中’;
char c3 =‘9’;
【注】用双引号引起来是字符串类型，如果char变量被赋值双引号括起来的字符，编译器会报错。
Java中海允许使用转义字符’‘来将其后的字符转变为特殊字符型常量。例如：
char c3 = ‘\n’; //’\n’表示换行符；
在Java中，char的本质是一个整数，在输出时，是unicode码对应的字符。转换可以用下面的网站：http://tool.chinaz.com/Tools/Unicode.aspx
可以直接给char赋一个整数，然后输出时，会按照对应的unicode字符输出[97]；
char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码。

测试代码：

public class CharDetail
{
	public static void main(String[] args)
	{
		//用unicode码赋值字符
		char c1 = 97;
		System.out.println(c1);
		//输出a对应的数字，将其转换为int类型
		char c2 = 'a';
		System.out.println((int)c2);
		char c3 = '韩';
		System.out.println((int)c3);//38889
		char c4 = 38889;
		System.out.println(c4);
		//char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码。
		System.out.println('a' + 10); //输出了107，单个字符char，不是刚才的字符串拼接String
		//课堂小测试
		char c5 = 'b' + 1;//98 + 1 = 99
		System.out.println((int)c5); //99
		System.out.println(c5); // c(编码表ASCII)
	}
}

运行结果：

48. 字符型本质

48.1 字符类型本质探讨

字符型存储到计算机中，需要将字符对应的码值（整数）找出来，比如’a’
存储：‘a’==>码值97==>二进制（110 0001）==>存储
读取：二进制（110 0001）=>97===>‘a’=>显示
字符和码值的对应关系是通过字符编码表决定的（是规定好）
ASCII (ASCII 编码表一个字节表示，
一个128 个字符,实际上一个字节可以表示256个字符,只用128个)
Unicode (Unicode 编码表固定大小的编码使用两个字节来表示字符，字母和汉字统一都是占用两个字节
这样浪费空间 )
utf-8(编码表，大小可变的编码字母使用1个字节，汉字使用3个字节,
gbk(可以表示汉字，而且范围广，字母使用1个字节，汉字2个字节)
gb2312(可以表示汉字，gb2312<gbk)
big5 码(繁体中文, 台湾，香港)
了解设计这些编码的思想可以看视频

49. 常用编码

49.1 ASCII 码

ASCII 码：上个世纪60年代，美国制定了一套字符编码(使用一个字节),对英语字符与二进制位之间的关系，做了统一规定，这被称为ASCII 码。ASCII码一共规定了128个字符的编码，只占用了一个字节的后面7位，最前面的1位统一规定为0。特别提示：一个字节可以表示256个字符，ASCII码只用了128个字符.
看一个完整的ASCIl码表[资料中]
缺点：不能表示所有字符。

49.2 Unicode 编码

Unicode的好处：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用 Unicode 没有乱码的问题。
Unicode 的缺点：一个英文字母和一个汉字都占用2个字节，这对于存储空间来说是浪费。
2的16次方是 65536,所以最多编码是65536个字符。
编码0-127的字符是与ASCII的编码一样.比如’a3在ASCII码是 0x61,在 unicode码是ox0061,都对应97.因此 Unicode码兼容 ASCl码.

49.3 UTF-8 编码

UTF-8是在互联网上使用最广的一种 Unicode的实现方式(改进)
UTF-8是一种变长的编码方式。它可以使用1-6个字节表示一个符号，根据不同的符号而变化字节长度。
使用大小可变的编码字母占1个字节，汉字占3个字节。

50. 布尔类型

布尔类型也叫boolean类型，boolean类型数据只允许取值true和false，无null
boolean类型占1个字节
boolean类型适于逻辑u那算，一般用于程序流程控制：
if条件控制语句
while循环抗旨语句
do-while循环控制语句
for循环控制语句

演示代码：

public class Boolean01
{
	public static void main(String[] args)
	{
		//演示判断成绩是否通过的案例
		//定义一个布尔变量
		boolean isPass = true;
		if(isPass == true){
			System.out.println("考试通过，恭喜");
		}else{
			System.out.println("考试没有通过，下次努力");
		}
	}
}

运行结果：

将isPass改成false，就提示考试不通过
【注】boolean类型不可以用0和非0的整数代替false和true，这点和C语言不同。

51. 自动类型转换基础

当Java程序在进行赋值或者运算时，精度小的类型自动转换为精度大得数据类型，这个就是自动类型转换。
数据类型按精度（容量）大小排序为：

测试代码：

public class AutoConvert
{
	public static void main(String[] args)
	{
		//演示自动转换
		int num = 'a';//正确，char->int
		double d1 = 80;//正确，int->double
		System.out.println(num);//97
		System.out.println(d1);//80.0
	}
}

运行结果：

52. 53. 自动类型转换细节1

有多种类型得数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
当我们把精度（容量）大的数据类型赋值给精度（容量）小的数据类型时，就会报错，反之就会进行自动类型转换。
(byte, short)和char之间不会相互自动转换。
byte, short, char他们三者可以计算，在计算时首先转换为int类型。
boolean不参与转换。
自动提升原则：表达式结果的类型自动提升为操作数中最大的类型。

public class AutoConvertDetail
{
	public static void main(String[] args)
	{
		//细节1：有多种类型得数据混合运算时，
		//系统首先自动将所有数据转换成容量最大的那种数据类型，
		//然后再进行计算。
		int n1 = 10;
		//float d1 = n1 + 1.1;//错误，n1 + 1.1的结果类型是double，因为默认转成容量最大的
		//double d1 = n1 + 1.1;//对
		float d1 = n1 + 1.1F; //对，让1.1不是double而是float

		//细节2：当我们把精度（容量）大的数据类型赋值给精度（容量）小的数据类型时，
		//就会报错，反之就会进行自动类型转换。
		// int n2 = 1.1;//错误，double->int，精度高的不能转换到精度低的
		//(byte, short)和char之间不会相互自动转换。
		//当把数赋值给byte类型的变量时，先判断该数是否在byte范围内，
		//如果是就可以
		byte b1 = 10;//byte的范围是-128~127
		// byte b1 = 1000;//错，超过-128~127的范围
		//细节3：byte,short 和char之间不会相互自动转换
		//把int赋值给byte不行
		// int n2 = 1;//n2是int类型
		// byte b2 - n2;//错，如果是变量赋值，判断变量的类型，是int高精度转byte低精度，不行
		// char c1 = b1;//错，byte,short 和char之间不会相互自动转换
		// short s1 = b1;//错，同上
		//细节4：byte, short, char他们三者可以计算，在计算时首先转换为int类型
		byte b2 = 1;
		byte b3 = 2;
		short s1 = 1;
		// short s2 = b2 + s1;//错，b2 + s1运算时先转换为int，结果是int类型，int不能转向更低精度的short
		int s2 = b2 + s1;//对，b2+s1运算时先转换为int，结果就是int类型
		// byte b4 = b2 + b3;//错，只要是byte类型之间作运算，其运算时自动转换为int类型
		//细节5：boolean不参与转换
		boolean pass = true;
		// int num100 = pass;//错，boolean不参与转换
		//细节6：自动提升原则：表达式结果的类型自动提升为操作数中最大的类型。
		byte b4 = 1;
		short s3 = 100;
		int num200 = 1;
		double num300 = 1.1;
		double num500 = b4 + s3 + num200 + num300;//整个运算的结果是操作数最大的类型即double
		// float num500 = b4 + s3 + num200 + num300;//错，操作数中最大的类型是double，double不能向更低精度float转换
		//b4 + s3 + num200 + num300的结果因为操作数最大的类型即double，所以只能让它赋值给double类型的变量
	}
}

54. 强制类型转换基础

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

public class ForceConvert
{
	public static void main(String[] args)
	{
		//演示强制类型转换
		int n1 = (int)1.9;
		System.out.println("n1=" + n1);//1，精度损失

		int n2 = 2000;
		byte b1 = (byte)n2;//byte的范围是-128~127
		System.out.println("b1=" + b1);//数据溢出
	}
}

运行结果：

byte范围是-128~127，byte 类型只有 256（ $2^8$ ）个可能的值（从 -128 到 127）。因此，当我们将一个超出这个范围的整数（如 2000）转换为 byte 时，实际存储的是这个整数值对 256 取模的结果。
计算 2000 % 256 的结果：
首先，计算 2000 除以 256，商为 7，余数为 2000 - 256 * 7 = 2000 - 1792 = 208。
结果 208 超过了 127，于是当转换为 byte 时会被看作 208 - 256，即：
208 - 256 = -48
（这么计算的原因详见计算机组成原理）

55. 强制类型转换细节

当进行数据的大小从大->小，就需要使用到强制类型转换；
强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级；
char类型可以保存int的常量值，但不能保存int的变量值，需要强转；
byte和short类型在进行运算时，当做int类型处理。

演示代码：

public class ForceConvertDetail
{
	public static void main(String[] args)
	{
		//演示强制类型转换
		//int x = (int)10*3.5+6*1.5;//错，强转符号只对最近的操作数有效，6*1.5是double，整个就是double
		int y = (int)(10*3.5+6*1.5);//用小括号提升优先级
		System.out.println(y);
		//char类型可以保存int的常量值，但不能保存int的变量值，需要强转
		char c1 = 100;//可以，保存的是常量值
		int m = 100;
		//char c2 = m;//不可以，保存的是int类型的变量值
		char c3 = (char)m;//可以，进行了强制类型转换
		System.out.println(c3);//100 ASCII码对应的字符d
	}
}

运行结果：

56. 类型转换练习

short s =12;//ok
s = s-9;//short,byte,char计算时首先转为int计算，所以s-9结果的类型是int类型，没法赋值给short类型的变量s
byte b = 10;//ok
b = b + 11;//short,byte,char计算时首先转为int计算，所以b + 11结果的类型是int类型，没法赋值给byte类型的变量b
b = (byte)(b+11);//可以转换，b+11计算结果类型是int且值为21，通过强制类型转换为byte类型，21在-128~127的范围内，所以可以赋值给byte类型的变量b
char c = ‘a’;//ok
int i = 16;//ok
float d = .314F;//ok
double result = c + i + d;//可以转换，最高精度的操作数类型是float，float可以向更高精度double转换
byte b = 16;
short s = 14;
short t = s + b;//short,byte,char计算时首先转为int计算，所以s + b结果的类型是int类型，没法赋值给short类型的变量t

57. String和基本类型转换

在程序开发中，我们经常需要将基本数据类型转成String类型。或者将String类型转成基本数据类型。
基本类型转String类型：将基本类型的值+""即可
String类型转基本数据类型：通过基本类型的包装类调用parseXX方法即可。

演示代码：

public class StringToBasic
{
	public static void main(String[] args)
	{
		//基本数据类型转String
		int n1 = 100;
		float f1 = 1.1F;
		double d1 = 4.5;
		boolean b1 = true;
		String s1 = n1 + "";
		String s2 = f1 + "";
		String s3 = d1 + "";
		String s4 = b1 + "";
		System.out.println(s1 + "\t" + s2 + "\t" + s3 + "\t" + s4);
		//把字符串转基本数据类型
		String s5 = "123";
		//会在讲面向对象oop的时候详细讲
		//使用基本数据类型对应的包装类的相应方法，得到基本数据类型
		int num1 = Integer.parseInt(s5);
		double num2 = Double.parseDouble(s5);
		float num3 = Float.parseFloat(s5);
		long num4 = Long.parseLong(s5);
		byte num5 = Byte.parseByte(s5);
		boolean b = Boolean.parseBoolean("true");
		short num6 = Short.parseShort(s5);
		System.out.println("====================");
		System.out.println(num1);//123
		System.out.println(num2);//123.0
		System.out.println(num3);//123.0
		System.out.println(num4);//123
		System.out.println(num5);//123
		System.out.println(b);//true
		System.out.println(num6);//123
		//怎么把字符串转成字符，char - >含义是指把字符串的第一个字符取到（类似C语言字符数组首地址）
		//s5.charAt(0)取得s5下标为0的（第一个）字符
		System.out.println(s5.charAt(0));
	}
}

运行结果：

58. String转基本数据类型细节

在将String 类型转成基本数据类型时，要确保String类型能够转成有效的数据，比如我们可以把"123",转成一个整数，但是不能把"hello" 转成一个整数。
如果格式不正确，就会抛出异常，程序就会终止，这个问题在异常处理章节中，会处理。

public class StringToBasicDetail
{
	public static void main(String[] args)
	{
		String str = "123";
		//String str = "hello";//字符串改成hello会抛出异常
		//转成int
		int n1 = Integer.parseInt(str);
		System.out.println(n1);
	}
}

输出结果：

如果将字符串"hello"转成整型int，就会抛出异常：

59. 60. 本章作业

【答】输出：
30
8

【答】
2)代码如下：

public class Homework02
{
	public static void main(String[] args)
	{
		char c1 = '\n';
		char c2 = '\t';
		char c3 = '\r';
		char c4 = '\\';
		char c5 = '1';
		char c6 = '2';
		char c7 = '3';
		System.out.println(c1);
		System.out.println(c2);
		System.out.println(c3);
		System.out.println(c4);
		System.out.println(c5);
		System.out.println(c6);
		System.out.println(c7);
	}
}

运行结果：

3)代码：

public class Homework03
{
	public static void main(String[] args)
	{
		//保存书名
		String book1 = "数学分析";
		String book2 = "高等代数";
		System.out.println(book1 + book2);
		//性别用char保存
		char c1 = '男';
		char c2 = '女';
		System.out.println(c1 + c2);//char,short,byte运算按int运算，得到的是男的码值与女的码值相加
		//保存书的价格
		double price1 = 123.56;
		double price2 = 100.11;
		System.out.println(price1 + price2);//两个数相加
	}
}

运行结果：

4)
代码：

public class Homework04
{
	public static void main(String[] args)
	{
		String name = "xx"; //姓名
		int age = 27; //年龄
		double grade = 90.5; //成绩
		char gender = '男'; //性别
		String hobby = "打篮球"; //爱好
		System.out.println("姓名\t年龄\t成绩\t性别\t爱好\n" + name + "\t" + age + "\t" + grade + "\t" + gender + "\t" + hobby);

	}
}