第3章变量

# 第 3 章变量

变量介绍
+号是你用
数据类型（重点）
编码
数据类型转换

‍

# 为什么需要变量

35讲

一个程序就是一个世界，例如我们现实中有这样的物体：房子，车子，人；在程序里，我们就用变量代表他们。

‍

变量是程序的基本组成单位，不论是使用哪种高级程序语言编写程序，变量都是其程序的基本组成单位，变量有三个基本要素（类型+名称+值）

class Test{
	public static void main(String []arargs){
		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变量的值
	}
}

1
2
3
4
5
6
7
8
9
10

上面对于零基础的人可能还是难以理解，这里画个原理图

‍

我们假设黄色的框框代表计算机，类似人；计算机有个东西叫内存，类似人的大脑，可以存储很多东西。

当我们定义了一个变量a，值为1的时候，内存里就会有一个地方存储了1，而a是内存的地址（内存的地址用来寻找内存的值，也就是1）；当我们定义了第二个变量后同理。

后面两个输出语句，输出的时候，就会根据内存的地址a，找到1，并输出

‍

# 变量的概念

第36讲

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

变量使用的基本步骤

声明变量
赋值
使用：

也可以一步到位通常我们是一步完成。

‍

练习：

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

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

1
2
3
4
5
6
7
8
9
10
11
12

‍

# 变量入门

37讲

演示记录人的信息的代码

数据类型是有多种的，就好比现实世界中有男有女，有小孩有老人

public class Var02 {
  public static void main(String[] args) {
    //记录人的信息
    int age = 20;
    double score = 88.6;
    char gendar = '男';
    String name = "韩顺平";
    //输出信息，
    System.out.println("人的信息如下:");
    System.out.println(name);
    System.out.println(age);
    System.out.println(score);
    System.out.println(gendar);
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

‍

# 变量细节

38讲

变量表示内存中的一个存储区域不同的变量，类型不同，占用的空间大小不同，比如：int 4个字节，double就是8个字节，先有基本印象，后面说字节）
该区域有自己的名称【变量名】和类型【数据类型】
变量必须先声明，后使用，即有顺序
该区域的数据/值可以在同一类型范围内不断变化，例如给int a赋值后，再次赋值给88，能不断变化。但不能赋值字符类型，编译会报错
变量在同一个作用域内不能重名，我们后面讲作用域是什么。就好比一个课室里有两个同名的人，那么光叫名字就不知道是具体指谁。如果是不同课室的人有重名，那么在一个课室内叫人就不会叫错了；
```
int a = 1;
int a = 2; //会报错。
```
1
2
变量变量名+值+数据类型，这一点请大家注意。变量三要素

‍

# 加号的使用

39讲

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

课堂测试题1min

System.out.println(100 + 98);	// 198
System.out.println("100" + 98);	// 10098
System.out.println(100 + 3 + "hello");	// 103hello 
System.out-println("hello" + 100 + 3);	// hello1003

1
2
3
4

‍

# 数据类型（重点）

40讲

每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间(字节)。就好比买家具，一个身高1.8米的人买床，2米的就够了；买3米4米完全就是浪费；

byte类型占1个字节，short占2个字节（中括号里面的是占的字节数）

char类型是占2个字节的，虽然ASCII码占的很少，但还有汉字这种存在，因此2个。

上图说明 [老韩要求小伙伴，]

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

我们之前用的String是一个类，我们后面学面向对象再说

‍

# 整型使用

41讲

Java 的整数类型就是用于存放整数值的，比如 12 , 30, 3456 等等

演示：

byte n1 = 10;	//1 个字节
short n2 = 10;	//2 个字节
int n3 = 10;	//4 个字节
long n4 = 10; 	//8 个字节

1
2
3
4

‍

类型名	范围	存储大小
byte	-2 ~ 2-1 (-128 ~ 127)	1字节
short	-2 ~2-1 ( -32 768 ~ 32 767)	2字节
int	-2 ~ 2 -1 ( -2 147 483 648) 147 483 647).	4字节
1ong	-2 ~2-1 即-9223 372 036 854 775 808 ~ 9 223 372 036 854 775 807)	8字节

‍

不同数据类型，其能存储的值也是不一样的，就好比10平方的房间和100平方的房间，能存放的东西不同。至于具体数值，例如为什么1个字节能存放-128 ~ 127的值，int的类型能表示这么多数量，得讲二进制，我们后面再讲。

比long更长的类型，有BigDecimal，我们后续再说

# 整型细节

42讲

Java各整数类型有固定的范围和字段长度，不受具体OS【操作系统】的影响，以保证java程序的可移植性。（也就是说，只要你定义了一个int类型的变量，在所有操作系统上都是4个字节）
Java的整型常量（具体值）默认为int型，声明long型常量须后加英文字母L（大小写都行）
java程序中变量常声明为int型，除非不足以表示大数，才使用long （一般我们用int就够了，如果不确定的话可以用long）
bit：计算机中的最小存储单位。byte：计算机中基本存储单元，1byte=8bit。【二进制再详细说，简单举例一个byte3和short3】byte n1=3；short n2=3；示意图如下：

‍

思考题：long类型，有几个bit【8个字节*8bit=64

longn=3：//内存中存在形式

‍

# 浮点型的分类

43讲

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

‍

# 浮点型使用细节

FloatDetail.java

与整数类型类似，Java浮点类型也有固定的范围和字段长度，不受具体OS的影响。【float4个字节，double是8个字节】
Java的浮点型常量（具体值）默认为double型，声明float型常量，须后加字母F（小写f也行）
浮点型常量有两种表示形式
十进制数形式：如：5.12 512.0f .512（必须有小数点）
科学计数法形式：如：5.12e2【5.12*10的2次方】 5.12E-2【5.12/10的2次方】

通常情况下，应该使用double型，因为它比float型更精确。【举例说明】

double num9 = 2.1234567851;
   float num10 = 2.1234567851F;
   System.out.println(num9); //2.1234567851
    System.out.println(num10);  //2.1234567

1
2
3
4

浮点数使用陷饼：2.7 和 8.1/3 比较。因为8.1在计算机里存储的不是非常精确的，可能会认为8.10000001

  double num11 = 2.7;
  double num12 = 8.1 / 3; //2.7
  System.out.println(num11);  //2.7
  System.out.println(num12);  //2.6999999999999997 接近2.7的小数

1
2
3
4
5
6

‍

得到一个重要的使用点: 当我们对运算结果是小数的进行相等判断是，要小心应该是以两个数的差值的绝对值，在某个精度范围类判断（具体情况具体分析，例如金额的判断的话，没有1分钱以下的）

 		// 错误写法
		if( num11 == num12) {
			System.out.println("num11 == num12 相等");
		}

		//正确的写法
		if(Math.abs(num11 - num12) < 0.000001 ) {
			System.out.println("差值非常小，到我的规定精度，认为相等...");
		}
		// 可以通过java API  来看 下一个视频介绍如何使用API
		System.out.println(Math.abs(num11 - num12));   
		//细节:如果是直接查询得的的小数或者直接赋值，是可以判断相等

1
2
3
4
5
6
7
8
9
10
11
12

计算得到的话，计算机可能会认为8.1是8.100001，计算出来的结果不准确；直接赋值的话就可以判断相等。

# Java文档

46讲

我们上节课用了Math类的方法，怎么看Java有什么API呢？什么是API呢？

1.APl（Application Programming Interface应用程序编程接口）是Java提供的基本编程接口（java提供的类还有相关的方法）。中文在线文档：https://www.matools.com。老师也提供看

Java语言提供了大量的基础类，因此Oracle公司也为这些基础类提供了相应的API文档，用于告诉开发者如何使用这些类，以及这些类里包含的方法

‍

那么怎么找呢？得聊聊Java类的组织形式【图】

由于Java的类有很多很多，因此Java是按包来组织的（可以理解为就是文件夹，不同的文件夹放了不同的类），每个包下面有很多类，接口和异常：

‍

我们打开韩顺平 2021零基础学Java 【软件资料代码笔记】\资料\分享资料\java API 文档\JDK_API_1.6_zh_中文.CHM

可以看到左侧上方就是包，点击具体的包，就能看到下面的类、接口和异常

‍

我们这里找ArrayList类为例，是在Java.util包下面的；因此我们先找到java.util包，然后找到类，就可以看到这个ArrayList的文档了，有哪些方法和类了。

小结：如何查看ArrayList类有哪些方法根据：包->类->方法

如果不知道是哪个包怎么办？直接搜索。例如我们找Math类，先点击显示

‍

输入math后回车

‍

选择上面这个是文档

‍

就能看到有ABS类了

‍

# 字符型char

47讲

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

案例演示 Char01.java

public class Char01 {
  public static void main(String[] args) {
    char c1 = 'a';
    char c2 = '\t';
    char c3 = '韩';
    char c4 = 97; //说明：字符类型可以直接存放一个数字，因为字符在计算机里就是用数字来存储的，而 字符a 在计算机里存储的就是97 =》涉及到编码的概念

    System.out.println(c1);
    System.out.println(c2);
    System.out.println(c3);
    System.out.println(c4);
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

‍

这里老师穿插了sublime快捷键和修改快捷键的说明，并且说了快捷键冲突的问题

# 字符型细节

48讲

‍

字符常量是用单引号（‘’）括起来的单个字符。例如： char c1='a';。注意不能用双引号
Java中还允许使用转义字符来将其后的字符转变为特殊字符型常量。例如：char c3=\n；// \n表示换行符，这并不代表一个字符，而是换行符
在java中，char的本质是一个整数，在输出时，是unicode码对应的字符，具体可以参考：http://tool.chinaz.com/Tools/Unicode.aspx
可以直接给char赋一个整数，然后输出时，会按照对应的unicode字符输出【97-）a】
char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码

‍

public class CharDetail {
  public static void main(String[] args) {
    char c1 = 97;
    System.out.println(c1); //输出a

    char c2 = 'a';
    System.out.println((int)c2); //输出97

    char c3 = '韩';
    System.out.println(c3); //韩
    System.out.println((int)c3); //38889
    char c4 = 38889;
    System.out.println(c4); //韩

    //char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码
    System.out.println('a' + 10); //输出107  编译器会将a转换成97

    //课堂小测试
    char c5 = 'b' + 1;            //98 + 1 = 99
    System.out.println(c5);       //输出c
    System.out.println((int)c5); //输出99
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

‍

# 字符型本质

49讲

字符型存储到计算机中，需要将字符对应的码值（整数）找出来，比如'a'

存储：'a'> 码值97 > 二进制（1100001）==>存储。存储a的时候，首先找到码制为97，然后转为二进制存储到计算机里。

读取：二进制（1100001）=> 97 ===> 'a' => 显示。显示则是会将二进制转换为97，然后根据ASCII表显示字符 a
字符和码值的对应关系是通过字符编码表决定的（是规定好，就好比我们平时写字，某个字的写法是固定的，不是说改就改）

介绍一下字符编码表，世界上有很多编码，我们介绍后续会接触到的。

ASCII（ASCII编码表，每个字符用一个字节表示，一共128个字符，实际上一个字节可以表示256个字符，只用128个，因为当时发明的时候，128个足够用了，英文字母就这么多
Unicode（Unicode编码表固定大小的编码，使用两个字节来表示字符，字母和汉字统一都是占用两个字节，这样浪费空间。后来其他国家也用计算机了，而ASCII才128个，不够用，因此用2个字节表示字符。
utf-8（编码表，大小可变的编码，字母使用1个字节，汉字使用3个字节）
gbk（可以表示汉字，而且范围广，字母使用1个字节，汉字2个字节）
gb2312（可以表示汉字，gb2312<gbk）
bg5码（繁体中文，台湾，香港）

编码是比较难的，以前老师在新浪做邮件系统的时候，专门有一个开发小组负责处理各个国家的编码。

‍

举个例子，我们新建一个Temp.java，设置编码为UTF8（一般默认就是UTF8，可能不用修改编码）里面放内容为abc，然后文件属性可以看到占3个字节；

‍

我们再加一个汉字韩，可以看到变成了6个字节

‍

如果我们修改为GBK编码，就是5个字节，不再演示了。gb2312用的就比较少，汉字比较少。

为什么会有UTF8编码？因为Unicode统一是用2个字节表示字符的，如果一个文件中，只有1个汉字，其他都是英文，那么每个英文其实用1个字节就够表示了，有浪费；因此用了UTF8就是汉字用3个字节，英文就1个字节。

GBK只用了2个字节表示中文，UTF8用了3个，因为能表示的中文没有UTF8多。所以有时候UTF8文件，转为GBK会报错，因为有些汉字GBK没有。

‍

# 常用编码

50讲，

ASCII介绍(了解)

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

‍

Unicode 编码介绍(了解)，Uni就是统一的意思

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

‍

UTF-8 编码介绍(了解)

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

‍

# 布尔类型：boolean

51讲

布尔类型也叫boolean类型，booolean类型数据只允许取值true和false，无null
boolean类型占1个字节。
boolean类型适于逻辑运算，一般用于程序流程控制【这个后面会详细介绍】：

if条件控制语句；
while循环控制语句；
do-while循环控制语句；
for循环控制语句

‍

细节：不能用0或者非0的整数，来代替false和true（C语言可以）

public class Boolean01 {
  public static void main(String[] args) {
    boolean pass = true;
    if(pass){
      System.out.println("pass");
    }else{
      System.out.println("not pass");
    }
  }
}

1
2
3
4
5
6
7
8
9
10

# 自动类型转换基础

52讲

当java程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数据类型，这个就是自动类型转换。

数据类型按精度（容量）大小排序为（背，规则），也就是从低精度向高精度转换，即使是跨了几个也行，例如char向long转换。

案例：AutoConvert.java

int a = 'c'; //ok
double d = 80; //ok，会输出80.0

1
2

‍

# 自动转换的细节

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

看老师演示AutoConvertDetail.java

‍

//自动类型转换细节
public class AutoConvertDetail { 

//编写一个main方法
public static void main(String[] args) {
	//细节1： 有多种类型的数据混合运算时，
	//系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算
	int n1 = 10; //ok
	//float d1 = n1 + 1.1;//错误 n1 + 1.1 => 结果类型是 double
	//double d1 = n1 + 1.1;//对 n1 + 1.1 => 结果类型是 double
	float d1 = n1 + 1.1F;//对 n1 + 1.1 => 结果类型是 float

	//细节2: 当我们把精度(容量)大 的数据类型赋值给精度(容量)小 的数据类型时，
	//就会报错，反之就会进行自动类型转换。
	//
	//int n2 = 1.1;//错误 double -> int 

	//细节3: (byte, short) 和 char之间不会相互自动转换
	//当把具体数赋给 byte 时，(1)先判断该数是否在byte范围内，如果是就可以
	byte b1 = 10; //对  , -128-127
	// int n2 = 1; //n2 是int 
	// byte b2 = n2; //错误，原因： 如果是变量赋值，判断类型
	// 
	// char c1 = b1; //错误， 原因 byte 不能自动转成 char
	// 
	// 

	//细节4: byte，short，char  他们三者可以计算，在计算时首先转换为int类型

	byte b2 = 1;
	byte b3 = 2;
	short s1 = 1;
	//short s2 = b2 + s1;//错, b2 + s1 => int，虽然结果没有超过byte的范围
	int s2 = b2 + s1;//对, b2 + s1 => int

	//byte b4 = b2 + b3; //错误: b2 + b3 => int
	//

	//boolean 不参与转换
	boolean pass = true;
	//int num100 = pass;// boolean 不参与类型的自动转换

	//自动提升原则： 表达式结果的类型自动提升为 操作数中最大的类型
	//看一道题

	byte b4 = 1;
	short s3 = 100;
	int num200 = 1;
	float num300 = 1.1F;

	double num500 = b4 + s3 + num200 + num300; //float -> double
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

‍

# 强制类型转换

55讲

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

演示：

public class ForceConvert {
  public static void main(String[] args) {
    int i  = (int)1.9;
    System.out.println(i);  //输出1

    int j = 100;
    byte b1 = (byte)j;
    System.out.println(b1);

    int n2 = 2000;
    byte b2= (byte) n2;
    System.out.println("b2=" + b2); //输出-48
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

‍

# 强制类型转换

56讲

ForceConvertDetail.java

‍

当进行数据的大小从大一>小，就需要使用到强制转换

强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

int x = (int) 10 * 3.5 + 6 * 1.5;  //只会将10转换成int，最后结果还是double，会编译失败
//正确方法：
int x2 = (int) (10 * 3.5 + 6 * 1.5);

1
2
3

char类型可以保存int的常量值，但不能保存int的变量值，需要强转

char c1 = 100; //对
int m = 100;  //对
char c2 = m; //错误的  编译器看类型都不匹配，并且char类型精度低于int
char c3 = (char)m; //ok
System.out.println(c3); //输出d 100对应的字符

1
2
3
4
5

byte和short,char类型在进行运算时，当做int类型处理。

‍

# 类型转换练习题

57讲

先判断是否能编译通过，再听老师讲课：

//1
short s = 12; 
s = s-9;

//2
byte b = 10;
b = b+11;
b = (byte) (b+11);

//3
char c = 'a';
int i = 16;
float d = .314f;
double result = c + i + d;

//4
byte b = 16;
short s = 14;
short t = s + b;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

‍

评讲：

//1
short s = 12;  //可以，12在short的范围内；
s = s-9;	//错误的，结果是int类型，不能赋值给short类型

//2
byte b = 10; 	//可以，10在byte的范围内
b = b+11;	//不可以，结果是int类型，不能赋值
b = (byte) (b+11);	//正确，强转

//3
char c = 'a';	//可以
int i = 16;	//可以
float d = .314f;//可以
double result = c + i + d; //可以，float转换为double

//4
byte b = 16;	//可以
short s = 14;	//可以
short t = s + b;	//只要有byte和short,char类型在进行运算时，当做int类型处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

‍

# String和基本类型转换

58讲

在程序开发中，我们经常需要将基本数据类型转成String类型。或者将String类型转成基本数据类型。

基本类型转String类型：将基本类型的值+双引号即可““。案例演示：StringToBasic.java

    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 + " " + s2 + " " + s3 + " " + s4 + " " + s5 +" ");

1
2
3
4
5
6
7
8
9
10

‍

String类型转基本数据类型【体验】

语法：通过基本类型的包装类调用parseXXX方法。每一个基本数据类型都有一个包装类，用这个包装类就能转换。我们在OOP里详细描述，我们先看看文档：

案例演示：StringToBasic.java

//解读，使用基本数据类型对应的包装类 的相应方法，得到基本数据类型
    byte num1 = Byte.parseByte("123");
    short num2 = Short.parseShort("123");
    int num3 = Integer.parseInt("123");
    long num4 = Long.parseLong("123");
    float num5 = Float.parseFloat("123.45");
    double num6 = Double.parseDouble("123.45");  
    boolen num7 = Boolean.parseBoolean("true");

1
2
3
4
5
6
7
8

从输出结果来看，确实看不出区别，但实际上确实是转换了的。

对于char类型，需要取某个特定的字符，因此char只能存储一个字符。

String s5 = "123";
char c1 = s5.charAt(0); //'1

1
2

‍

# String转基本类型细节

59讲

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

我们学习是有顺序的，不可能提到什么就去学什么，主线不能乱

‍

public class StringToBasicDetail {
  public static void main(String[] args) {
    String str = "123";
    int n1 = Integer.parseInt(str);
    System.out.println(n1);

    str = "hello";
    n1 = Integer.parseInt(str);
    System.out.println(n1);
  }
}

1
2
3
4
5
6
7
8
9
10
11

编译能正常，但是运行的时候会报错，这是我们遇到的第一个类型。

> javac .\StringToBasicDetail.java
> java StringToBasicDetail
123
Exception in thread "main" java.lang.NumberFormatException: For input string: "hello"
        at java.lang.NumberFormatException.forInputString(Unknown Source)
        at java.lang.Integer.parseInt(Unknown Source)
        at java.lang.Integer.parseInt(Unknown Source)
        at StringToBasicDetail.main(StringToBasicDetail.java:8)

1
2
3
4
5
6
7
8

‍

# 本章作业

60讲，61讲

1.程序阅读题，看看输出什么 Homework01.java

public class Homework01 {
  public static void main(String[] args) {
    int n1;
    n1 = 13;
    int n2;
    n2 = 17;
    int n3;
    n3 = n1 + n2;
    System.out.println("n3 = " + n3);//20

    int n4 = 38;
    int n5 = n4 - n3;
    System.out.println("n5 = " + n5);//8
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

‍

2.使用char类型，分别保存\n \t \r \ 1 2 3 等字符，并打印输出Homework02.java

‍

3.编程，保存两本书名，用+拼接，看效果。保存两个性别，用加号拼接，看效果。
保存两本书价格，用加号拼接，看效果Homework03，java

public class Homework03 {
  public static void main(String[] args) {
    //编程，保存两本书名，用+拼接，看效果。保存两个性别，用加号拼接，看效果。保存两本书价格，用加号拼接，看效果
    String book1 = "天龙八部";
    String book2 = "笑傲江湖";
    System.out.println(book1 + book2);


    char c1 = '男';
    char c2 = '女';
    System.out.println(c1 + c2); //字符类型的本质是整数，所以加起来后是个整数

    float price = 123.56f;
    float price2 = 100.00f;
    System.out.println(price + price2);
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

不同加号的效果是不一样的。输出如下：

> java Homework03
天龙八部笑傲江湖
52906
223.56

1
2
3
4

‍

4.编程实现如下效果Homework04.java。考察小伙伴们能不能用正确类型的变量存储

姓名年龄成绩性别爱好
XX XX XX XX XX要求：

1）用变量将姓名、年龄、成绩、性别、爱好存储
2）使用+
3）添加适当的注释
4）添加转义字符，使用一条语句输出

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

1
2
3
4
5
6
7
8
9
10
11

‍

大家切忌眼高手低，再简单的题也要动手做，很多小伙伴一开始不做，到了后面简单的题目不想做，难的题目做不出来，一定要练习一遍，不看老师的代码去敲一遍

‍

# 本章小结

变量：为什么需要变量，一个程序就是一个世界，方便理解

变量三要素：类型，名称，值

变量原理示意图

‍

变量的介绍和概念

使用步骤：声明变量，赋值；也可以合在一起
变量注意事项，每个变量的存储空间不同，必须先声明再使用；变量在同一类型中可以在其范围内变化，不能重名
加号的使用

‍

数据类型（重点，要背下来）：八大数据类型，byte, short, int, long, float, double, char, boolen，面试要问的

JavaAPI文档：如何查文档，Java类的组织形式

字符类型，字符编码（重点）

布尔类型：只有true和false

基本数据类型转换（重点）：自动类型转换 + 强制转换（有精度丢失，千万注意）

基本类型和String转换：基本转String就很简单，也没异常；String转基本注意String类型能转换，不然会有异常。

最后是本章的作业，一定要自己敲

在GitHub上编辑此页

上次更新: 2023/1/21 22:11:12

← 第2章 Java概述第4章运算符→