Java数据类型与循环初识2

知识点1：变量

• 说明

1. java中的变量定义的规则：数据类型 变量名 = 变量值


2. 注意点：
① 变量必须在初始化之后，才能使用
② 每个变量都有其声明所在的作用域。在其作用域内都可以使用。出了作用域之后，就不能使用了。
③ 在同一个作用域内不允许定义两个同名的变量

• 代码演示

class VariableTest {

	
	public static void main(String[] args) {
		//编译错误：变量必须在声明之后才可以使用
		//System.out.println(weight);

		//1.1变量的声明
		double weight;
		
		//编译错误：变量必须在初始化之后，才能使用
		//System.out.println(weight);

		//1.2 变量的赋值
		weight = 80.6;

		//变量的声明和赋值操作同时完成
		int myAge = 12;
		
		System.out.println(weight);
		System.out.println(myAge);
		
		//编译错误
		//System.out.println(score);
		
		//编译错误：在同一个作用域内不允许定义两个同名的变量
		//int myAge = 30;
		System.out.println(myAge);
	}

	public static void show(){
		int score = 98;
		
		System.out.println(score);

		int myAge = 30;

	}
}

知识点2：8种基本数据类型

1. 变量的分类

• 变量按照数据类型来分：

• 变量按照在类中声明的位置来分：（了解）

2. 8种基本数据类型的使用

整型

//1.整型：byte(1个字节 = 8bit, 范围：-128 ~ +127) 、 short(2字节) 、 int(4字节)  、 long(8字节) 
//① 变量的赋值不能超出数据类型的表数范围
byte b1 = 12;

//b1 = 128;//编译不通过

//② 给long类型变量赋值时，需要以"l" 或"L"结尾
long l1 = 123L;
long l2 = 432l;
System.out.println(l1);//123
System.out.println(l2);//432

//③ 开发中，通常定义整型为int

浮点型

//2.浮点型:float(4字节,单精度)、double(8字节，双精度) 
//① float定义的变量值必须以"f"或"F"结尾
//② 开发中，默认我们可以使用double类型来定义浮点类型的变量
double d1 = 123.43;
double d2 = 5436345234.235234;

float f1 = 123.43F;
System.out.println(f1);

字符型

//3.字符型:char
//一个字符占2个字节
//① 通常使用一对单引号表示一个字符。内部只能有一个字符

char c1 = 'a';
char c2 = '1';
char c3 = 'セ';
char c4 = '中';
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);

//编译错误：内部只能声明一个字符
//char c5 = 'ab';
//char c6 = '123';
//char c7 = '';

//②其他表示方式：1.表示转义字符 2.使用Unicode值表示 
char c8 = '\n';//换行符
char c9 = '\t';//制表符

System.out.println("hello" + c8 +"world");
System.out.println("hello" + c9 +"world");

char c10 = '\u0026';
char c11 = '&';
System.out.println(c10);

• 常用的字符集：ASCII 、GB2312、GBK、Unicode、UTF-8

布尔型

//4. 布尔型：boolean
// 只有两个取值：true 、 false
// 通常使用在条件判断、循环结构中
boolean isMarried = true;

if(isMarried){
    System.out.println("好好珍惜自己的媳妇");

}else{
    System.out.println("可以多谈谈女朋友");
}
/*
int myAge = 18;
if(myAge > 18){

}
*/

知识点3: 基本数据类型间的运算规则

1. 自动类型提升

基本数据类型变量间运算的规则

1. 此时的运算规则涉及到的是7种基本数据类型，不包含boolean
2. 容量小的和容量大的数据类型的变量间做运算时，满足：自动类型提升

  > 容量小的和容量大的数据类型的变量间做运算时，结果的数据类型为容量大的数据类型。

	
  > 特别的：如果byte、short、char三者之间做运算的话，结果为int类型。

  总结：byte 、short、char -> int -> long -> float -> double 

说明：容量大小指的是表数的范围。

• 代码演示

class VariableTest2 {
	public static void main(String[] args) {
		
		long l1 = 123L;
		float f1 = 123.4F;
		//编译失败
		//long l2 = l1 + f1;

		float f2 = l1 + f1;

		byte b1 = 123;
		int i1 = 432;
		//编译失败
		//short s = b1 + i1;
		int i2 = b1 + i1;
		
		float f3 = i1;
		System.out.println(f3);//432.0

		//##########################
		char c1 = 'a';//97
		int i3 = 1;
		int i4 = c1 + i3;
		System.out.println(i4);

		//############################
		byte bb1 = 12;
		short ss1 = 13;
		//编译失败
		//short ss2 = bb1 + ss1;
		char cc1 = 97;
		//编译失败
		//char cc2 = bb1 + cc1;
		//编译失败
		//short ss3 = ss1 + cc1;

		byte bb2 = 32;
		//编译失败
		byte bb3 = bb1 + bb2;
	}
}

2. 强制类型转换

自动类型提升规则的逆运算：强制类型转换

1. 强制类型转换，可以将容量大的数据类型的变量转换为容量小的数据类型的变量
2. 强制类型转换，需要使用强制类型转换符

• 代码演示

class VariableTest3 {
	public static void main(String[] args) {
		
		long l1 = 123L;
		//编译失败
		//int i1 = l1;
		
		int i2 = (int)l1;
		System.out.println(i2);

		//损失精度的情况1：
		double weight = 140.23;

		int truncWeight = (int)weight;
		System.out.println(truncWeight);//140

		//损失精度的情况2：
		int num = 128;
		byte byteNum = (byte)num;
		System.out.println(byteNum);//-128

	}
}

3. 补充说明

//对于整型数据类型，常量的默认类型为：int
//对于浮点数据类型，常量的默认类型为：double

• 代码演示

class VariableTest4 {
	public static void main(String[] args) {
		
		long count = 2341234;
		System.out.println(count);
		//编译错误
		//long count1 = 2423535443654564;

		long count1 = 2423535443654564L;
		
		//编译错误
		//float f1 = 123.23;

		float f1 = (float)123.23;

		
		//
		byte b1 = 12;
		int i1 = b1 + 10;
		//编译错误
		//float f2 = b1 + 123.34;

	}
}

知识点4：String与基本数据类型间的运算规则

1. String的基本使用

• String类型的变量使用一对""进行定义。

String info = "Hello World!";
System.out.println(info);

String s1 = "";//可以编译通过

2. String与8种基本数据类型间的运算规则

1. String 与 8种基本数据类型之间只能做连接运算： +
2. 运算的结果是String类型

• 代码演示

String info = "Hello World!";
System.out.println(info);

String s1 = "";//可以编译通过

int num = 2;
String s2 = info + num + true;
System.out.println(s2);

//######################
//编译失败
//String s3 = num;

String s4 = "123";
//编译失败
//int i1 = (int)s4;

//超纲内容：包装类时讲
int i2 = Integer.parseInt(s4);
System.out.println(i2 + 1);

• 练习

/*
练习1：

*/
char c1 = 'a';//97
int i = 1;
String str = "hello";
System.out.println(c1 + i + str);//98hello
System.out.println(c1 + str + i);//ahello1
System.out.println(c1 + (i + str));//a1hello

/*
练习2：

*/
//*	*
System.out.println('*' + '\t' + '*');//93
System.out.println('*' + '\t' + "*");//51*
System.out.println("*" + '\t' + '*');//*	*
System.out.println("*" + "\t" + '*');//*	*
System.out.println("*\t*");//*	*

System.out.println("她很\"漂亮\"");//她很"漂亮"

知识点5：进制间的运算（了解）

1. 了解常见的几种进制

/*

二进制(binary)：0,1 ，满2进1.以0b或0B开头。   
十进制(decimal)：0-9 ，满10进1。
八进制(octal)：0-7 ，满8进1. 以数字0开头表示。
十六进制(hex)：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
    如：0x21AF +1= 0X21B0

*/
class BinaryTest {
	public static void main(String[] args) {
		int num1 = 0b10;
		int num2 = 010;
		int num3 = 10;
		int num4 = 0x10;
		System.out.println(num1);
		System.out.println(num2);
		System.out.println(num3);
		System.out.println(num4);
	}
}

2. 熟悉二进制的情况

• 计算机的底层都是使用二进制表示数据的

• 对于数值型的变量，底层使用数值的二进制数据的补码表示数据

• 二进制原码、反码、补码的关系：

  • 正数：原码、反码、补码，三码合一

  • 负数：

    负数的反码：是对原码按位取反，只是最高位（符号位）确定为1。
    负数的补码：其反码加1。
    

3. 二进制与十进制之间的转换

• 二进制转十进制

• 十进制转二进制：除2取余的逆

  

4. 与其他进制间的转换

• 二进制转换为八进制、十六进制

• 八进制、十六进制转换为二进制

知识6：运算符

1. 算术运算符

+  -  +  -  *  /  %  (前)++  (后)++  (前)--  (后)--  +

• 代码测试

class AriTest {
	public static void main(String[] args) {

		int num1 = 10;
		float f1 = 1.2F;
		
		float f2 = num1 * f1;
		System.out.println("f2 = " + f2);
		//关于除法：/
		int num2 = 12;
		int num3 = num2 / 5 * 5;

		System.out.println("num3 = " + num3);

		//关于取模： %
		//常用来判断被模数是否能被模数除尽。比如：是否是一个偶数  num % 2 == 0
		//取模运算结果的符号与被模数的符号相同

		System.out.println(12 % 5);
		System.out.println(12 % -5);
		System.out.println(-12 % 5);
		System.out.println(-12 % -5);

		//(前)++ ： 先自增1，再运算
		//(后)++ ：先运算，后自增1
		int a1 = 10;
		int b1 = ++a1;
		System.out.println("a1 = " + a1);//a1 = 11
		System.out.println("b1 = " + b1);//b1 = 11

		int a2 = 10;
		int b2 = a2++;
		System.out.println("a2 = " + a2);//a2 = 11
		System.out.println("b2 = " + b2);//b2 = 10
		
		//说明：++ 或 --的操作，并不会改变变量本身的数据类型
		
		short s1 = 10;
		//s1 = s1 + 1;//编译错误
		
		//s1 = (short)(s1 + 1);//之前的做法

		s1++;
		
		System.out.println(s1);
		
		//(前)-- ： 先自减1，再运算
		//(后)-- ：先运算，后自减1

		int a3 = 10;
		int b3 = --a3;
		//int b3 = a3--;
	}
}

2. 赋值运算符

= , +=, -=, *=, /=, %=

• 代码演示

class SetValueTest {
	public static void main(String[] args) {
		
		byte num1 = 10;

		int num2 = num1;//自动类型提升

		float num3 = 10.4F;
		num2 = (int)num3;//强制类型转换

		int m = 10;
		m += 5; //类似于 m = m + 5;
		System.out.println("m = " + m);

		short s1 = 10;
		s1 += 5;//运算以后的结果，仍为原数据类型
		System.out.println("s1 = " + s1);

		/*
		拓展1：
		int i = 1;
		i *= 0.1; 

		拓展2：
		int n = 10;
		n += (n++) + (++n);
		
		拓展3：
		int m = 2;
		int n = 3;
		n *= m++; 	//n = n * m++
		System.out.println("m=" + m);
		System.out.println("n=" + n);

		*/
		int n = 10;
		n += (n++) + (++n); //n = n + (n++) + (++n)
		System.out.println(n);//32
		
		//开发场景1：定义了int型变量，想让此变量自增1,如何操作？
		int i = 10;
		//方法一：
		//i = i + 1;
		//方式二：推荐
		//i++;
		//方式三：
		//i += 1;

		//开发场景2：定义了int型变量，想让此变量自增2,如何操作？
		int j = 10;
		//方法一：
		//j = j + 1;
		//方式二：推荐。因为不改变数据类型
		//j += 2;
		//错误的
		//(j++)++;
	}
}

3. 比较运算符

==  !=  >  <  >=  <=  instanceof(略)
说明：
① 运算的结果为boolean类型
② 特别小心== 和 = 的区别

• 代码演示

class CompareTest {
	public static void main(String[] args) {
		
		int a = 10;
		int b = 20;
		System.out.println(a == b);//false
		System.out.println(a = b);//20

		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b1 == b2);//false
		System.out.println(b2 = b1);//true

	}
}