【尚硅谷】Day02学习笔记

第3章 变量

3.1 为什么需要变(变化)量(值)

3.2 变量的介绍

3.2.1概念

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

3.2.2变量使用的基本步骤

• 声明变量
  int a;

• 赋值
  a = 60;

• 使用 System.out.println(a);

• 也可以一步到位[int a = 60; 通常我们是一步完成

3.3变量快速入门

看演示并对代码进行说明， 演示记录 人的信息的代码

//快速入门小案例
public class VarDemo
{
	public static void main(String[] args) {
		//希望使用变量来描述一个人信息
		//名字, 年龄， 工资，性别 => 不同的属性，可以使用不同的类型来记录
		
		String name = "张三";
		int age = 20;
		double sal = 40000.5;
		char gender = '男';

		//使用4句输出
		System.out.println(name);
		System.out.println(age);
		System.out.println(sal);
		System.out.println(gender);

		//细节 该区域的数据可以在同一类型范围内不断变化
		age = 21;
		//变量在同一个作用域(简单理解成在一个方法中)内不能重名
		//int age = 60;


	}
}

class Cat
{
	public static void main(String[] args) { 
		int age = 40;
	}
}

3.4变量使用注意事项

1)变量表示内存中的一个存储区域 [不同的变量，类型不同，占用的空间大小不同， 比如：int 4 个字节， double 就是 8个字节]
2)该区域有自己的名称[变量名]和类型[数据类型]
3)变量必须先声明，后使用, 即有顺序
4)该区域的数据可以在同一类型范围内不断变化 (原因 java 是强数据类型语言)
5)变量在同一个作用域内不能重名
6)变量=变量名+值+数据类型，这一点请大家注意。变量三要素

3.5程序中 +号的使用

1)当左右两边都是数值型时，则做加法运算
2)当左右两边有一方为字符串，则做拼接运算 []
3)代码

//快速入门小案例
public class PlusDemo
{
	public static void main(String[] args) {
		
		//当左右两边都是数值型时，则做加法运算

		int num1 = 20;
		int num2 = 40;
		System.out.println(num1 + num2);  //加法运算
		System.out.println("hello" + num2); //拼接

	}
}

3.6数据类型

3.6.1概述

3.7整数类型

3.7.1整型的使用细节

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

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

3)java程序中变量常声明为int型，除非不足以表示大数，才使用long

4)bit: 计算机中的最小存储单位。byte:计算机中基本存储单元,1byte = 8 bit。[二进制再详细说，简单举例一个 byte 3 和 short 3 ]

5)思考题: long 类型，有几个 bit [8 * 8 = 64 bit]
long n = 3;// 内存中
代码如下:

//整型的细节
public class IntDetail
{
	public static void main(String[] args) {
		
		//Java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’

		long n1 = 2147483648m;

		//java程序中变量常声明为int型，除非不足以表示大数，才使用long
		//原则：尽量使用小的数据类型，可以节省空间.
		//long age = 100;

		byte n2 = 3;
		short n3 = 3;

	}
}

3.8浮点类型

说明一下：

1. 关于浮点数在机器中存放形式的简单说明,浮点数=符号位+指数位+尾数位

2. 尾数部分可能丢失，造成精度损失(小数都是近似值)。

3. 浮点型的存储分为三部分：符号位+指数位+尾数位 在存储过程中，精度会有丢失

3.8.1浮点型使用细节

1、与整数类型类似，Java 浮点类型也有固定的范围和字段长度，不受具体OS的影响。[float 4 个字节 double 是 8个字节]

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

3、浮点型常量有两种表示形式
十进制数形式：如：5.12 512.0f .512 (必须有小数点）
科学计数法形式:如：5.12e2 [ ] 5.12E-2 []

• 通常情况下，应该使用double型，因为它比float型更精确。[举例说明]
  double num9 = 2.1234567851;
  float num10 = 2.1234567851F;

4、浮点数使用陷阱: 2.7 和 8.1 / 3 比较

5、代码

//浮点数的细节
public class FloatDetail
{
	public static void main(String[] args) {
		
			//细节 Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’
			// 1.1 默认 double , 直接在 1.1F
			float f1 = 1.1F;

			//2. 十进制数形式：如：5.12       512.0f        .512   (必须有小数点)
			//    科学计数法形式:如：5.12e2 [5.12 *10^2 ]      5.12E-2   [5.12 /(10^2) ] 
			double d1 = .512;

			double d2 = 5.12E2; // 512.0
			double d3 = 5.12E-2;
			System.out.println(d2);
			System.out.println(d3); //0.0512

			//3. 通常情况下，应该使用double型，因为它比float型更精确
			double num9 = 2.1234567851;
			float num10 =  2.1234567851F;
			System.out.println(num9);
			System.out.println(num10);

			//4. 浮点数使用陷阱: 2.7 和 8.1 / 3  比较
			//不好理解

			double d4 = 2.7;
			double d5 = 8.1 / 3; // 数学 2.7 , 但是在计算运算时，发生了精度损失 2.69999999997
			System.out.println("d4=" + d4);
			System.out.println("d5=" + d5);

			//在开发中，如果需要比较两个小数是否相等， 可以比较两个数的差值的绝对值，是否在某个精度范围
			//System.out.println(Math.abs(d4-d5));
			if( d4 == d5) {
				System.out.println("相等");
			}

			if( Math.abs(d4-d5) < 0.0000001) {  //比较
				System.out.println("相等");
			}
	}
}

3.9字符类型(char)

3.9.1基本介绍

字符类型可以表示单个字符,字符类型是char，char是两个字节(可以存放汉字)，多个字符我们用字符串,在java中String这种，数据类型表示，但是String不是基本数据类型，而是类,类是复合数据类型[关于类我们后面详细讲解.]
案例演示：

3.9.2字符类型使用细节

代码演示

//浮点数的细节
public class CharDetail
{
	public static void main(String[] args) {
		
			//基本使用
			char gender = '男';
			System.out.println("gender=" + gender);

			//使用注意点
			//字符常量是用单引号(‘ ’)括起来的单个字符
			char c1 = 'a'; //ok 


			//在java中，char的本质是一个整数，在输出时，是unicode码对应的字符
			//  字符 <------>  数 
			char c2 = '韩'; 
			System.out.println("c2=" + c2); //韩
			System.out.println("c2=" + (int)c2); //韩 -> 对应数字

			char c3 = 'a';
			System.out.println("c3=" + c3); // 'a'
			System.out.println("c3=" + (int)c3); // 97

			//可以直接给char赋一个整数，然后输出时，会按照对应的unicode 字符输出
			char c4 = 74; 
			System.out.println("c4=" + c4); // J
			System.out.println("c4=" + (int)c4); // 74

			//char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码

			char c5 = 'a'; //---> 97
			System.out.println(c5 + 10); // 编译器，会找到 'a' 字符对应的 数字 + 10 = 107
	}
}

3.9.3字符类型本质探讨

1)字符型 存储到 计算机中，需要将字符对应的码值（整数）找出来 , 比如’a’
存储： ‘a’ ==> 码值 97 ==> 二进制 ==> 存储
读取：二进制 => 97 ===> ‘a’ => 显示

2)字符和码值的对应关系是通过字符编码表决定的(是规定好)

3)介绍一下字符编码表 [editplus测试]

ASCII (ASCII 编码表 一个字节表示 , 一个128 个 字符)
Unicode (Unicode 编码表 固定大小的编码 使用两个字节来表示字符，字母和汉字统一都是占用两个字节，这样浪费空间 )
utf-8 (编码表，大小可变的编码 字母使用1个字节，汉字使用3个字节)
gbk (可以表示汉字，而且范围广 =>ANSI, 字母使用1个字节，汉字2个字节)
gb2312 (可以表示汉字，gb2312 < gbk)
big5 码(繁体中文, 台湾，香港)

3.10布尔类型：boolean

3.10.1基本介绍

1)布尔类型也叫boolean类型，booolean类型数据只允许取值true和false，无null

2)boolean类型占1个字节。

3)boolean 类型适于逻辑运算，一般用于程序流程控制[这个后面会详细介绍]：

4)if条件控制语句；

while循环控制语句；
do-while循环控制语句；
for循环控制语句

3.10.2案例演示：

//布尔
public class BooleanDemo
{
	public static void main(String[] args) {
		
			boolean isPass;
			isPass = true;
			//if - else 
			if(isPass) { //真 
				System.out.println("通过考试");
			} else { //假
				System.out.println("没有通过考试");
			}
	}
}

3.11基本数据类型转换

3.11.1自动类型转换

3.11.2自动类型转换

• 案例演示
  演示一下基本数据类型转换的基本情况。

3.11.3自动类型转换细节说明(!!!)

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

2)当我们把精度(容量)大 的数据类型赋值给精度(容量)小 的数据类型时，就会报错，反之就会进行自动类型转换。

3)(byte, short) 和 char之间不会相互自动转换。

4)byte，short，char 他们三者可以计算，在计算时首先转换为int类型。

5)boolean 不参与转换

6)自动提升原则： 表达式结果的类型自动提升为 操作数中最大的类型

7)代码

//数据类型自动转换的细节
public class TypeConvertDetail
{
	public static void main(String[] args) {
		
		//基本使用
		char c1 = 'a';
		int num = c1;  // char -> int
		long l = c1; // char -> long

		byte b1 = 1;
		short s1 = b1; // byte -> short
		//有多种类型的数据混合运算时，系统首先自动将所有数据
转换成容量最大的那种数据类型，然后再进行计算
		double d1 = 1.1;
		int n2 = 1;
		//float res = d1 + n2; //错误  double -> float
		double res2= d1 + n2; //对


		//细节: 当我们把精度(容量)大 的数据类型赋值给精度(容量)小 的数据类型时，就会报错，反之就会进行自动类型转换。

		double d2 = 1.1;
		//int n3 = d2; //错误 

		int i = 1; 
		//byte b2 = i; // 错误 byte -> int


		//(byte, short) 和 char之间不会相互自动转换

		byte b3 = 2;
		//char c3 = b3; // byte 和 char 没有自动转换 
	
		//byte，short，char  他们三者可以计算，在计算时首先转换为int类型。

		byte b4 = 1;
		short s2 = 1;

		//short i2 = b4 + s2; // 错误 int -> short


	}
}

3.11.4强制类型转换

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

//数据类型强制转换的细节
public class TypeConvert2Detail
{
	public static void main(String[] args) {
		
		int i =  (int)1.99; //ok
		System.out.println(i); //把小数点后面，全部去掉

		int j = 10000; // 如果j 大了，就有数据溢出
		byte b = (byte)j;
		System.out.println("b=" + b); 


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

		int res = (int)(10 * 3.5 + 6 * 1.5);
		System.out.println("res=" + res);

		//强制转换，并不会对原来的变量的数据类型有任何影响
		
		double d = 1.1;
		int k = (int)d;

		//d的数据类型仍然是 double!!!!


		//char类型可以保存 int的常量值，但不能保存int的变量值，需要强转
	//	int n = 1;
	//	char c = n; //当代码执行到这里 , n 是已经有空间

		//下面的逻辑
		//(1) 1 是一个具体值
		//(2) 编译器先判断 1 是否能够保存到 char 范围类, 如果可以，则通过，否则，就不通过
		char c2 = 6553;

		
	}
}

3.11.5强制类型转换细节说明

具体案例，看上面的代码

3.12 基本数据类型转换-练习题

判断是否能够通过编译 5min 14:12 评讲 
1）short  s = 5; //ok
      s = s-2;  // 错误, 原因      int -> short       
2） byte b = 3;  //ok
       b = b + 4;   //错误   int -> byte           
       b = (byte)(b+4);   // ok, 使用强制转换
3）char c = 'a';  // ok
      int  i = 5; // ok
      float d = .314F;  //ok 等价  float d = 0.314F;
      double result = c + i + d;  // 对  float -> double
4） byte b = 5;  // ok
       short s = 3; //ok
       short t = s + b;  //     错误  (s+b) 是 int , int -> short

3.13基本数据类型和String类型的转换

3.13.1介绍

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

或者将String类型转成基本数据类型。

3.13.2基本类型转String类型

语法： 将基本类型的值+"" 即可

案例演示：

//数据类型自动转换的细节
public class BasicTypeToString
{
	public static void main(String[] args) {
		
		// 
		int num = 100;
		float price = 34.5F;
		boolean b = true;
		char c = '男';

		//说明
		//1. num + "" 结果是 String ,并赋给str1变量
		//2. num 本身没有影响
		String str1 = num + "";
		String str2 = price + "";
		String str3 = b + ""; //"true"
		String str4 = c + ""; // "男"
		System.out.println(str1);
		System.out.println(str2);
		System.out.println(str3);
		System.out.println(str4); //ctrl + j [表示复制当前行]

		System.out.println(str1 + 200); // 结果是 100200
		System.out.println(num + 200); // 结果是 300

	}
}

3.13.3 String类型转基本数据类型

语法：通过基本类型的包装类调用parseXX方法即可

案例演示：

//String 转成 基本数据类型
public class StringToBasicType
{
	public static void main(String[] args) {
		
		String str1 = "123.5";

		//将str1 -> double
		//方法
		//1. 使用 包装类 Double 有一个方法 parseDouble()
		//2. 返回 结果是 double , 对str1 没有影响
		double d1 = Double.parseDouble(str1);

		String str2 = "100";
		int i = Integer.parseInt(str2);

		String str3 = "123.6";
		float f = Float.parseFloat(str3);

		//
		String str4 = "尚硅谷";
		//str4 ->  char => 理解成取出 字符串的第几位字符
		//注意，字符串的每个字符编号从 0开始
		char c = str4.charAt(0);
		System.out.println(c);


		//在将String 类型转成 基本数据类型时，要确保String类型能够转成有效的数据，
		//比如 我们可以把 "123" , 转成一个整数，但是不能把 "hello" 转成一个整数

		String str5 = "hello";
		//String str5 = "123";
		int i2 = Integer.parseInt(str5); //抛出异常

	}
}

3.13.4注意事项

1)在将String 类型转成 基本数据类型时，要确保String类型能够转成有效的数据，比如 我们可以把 “123” , 转成一个整数，但是不能把 “hello” 转成一个整数

2)如果格式不正确，就会抛出异常，程序就会终止， 这个问题在异常处理章节中，会处理