java学习笔记2

 关键字与保留字

 标识符(Identifier)

Java中的名称命名规范

/*
标识符的使用
1.标识符：凡是自己可以起名字的地方都叫标识符。
   比如：类名、变量名、方法名、接口名、包名...

2.标识符的命名规则：--> 如果不遵守如下的规则，编译不通过！需要大家严格遵守

> 由26个英文字母大小写，0-9 ，_或 $ 组成  
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。

3. Java中的名称命名规范： --->如果不遵守如下的规范，编译可以通过！建议大家遵守

包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

4.
注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。 


*/
class IdentifierTest{

	public static void main(String[] args){
		
		//int myNumber = 1001;
		//System.out.println(myNumber);
		int mynumber = 1002;
		System.out.println(mynumber);

		//int 学号 = 1003;
		//System.out.println(学号);
		
	
	}


}

class Hello1_${

}
//class 1Hello{
//}
class staticpublic{
}
class Static{
}

class User{
}

class Account{
}

变 量

class VariableTest
{
	public static void main(String[] args){
		//定义变量的方式1：
		char gender; // 过程1：变量的声明
		gender = '男'; // 过程2：变量的赋值（或初始化）

		gender = '女';
		// 定义变量的方式2：声明和初始化合并
		int age = 10;
		System.out.println(age);
		System.out.println("age = " + age);
		System.out.println("gender = " + gender);
		//在同一作用域内不能声明相同的变量
		//char gender = '女'; // 会报错
		gender = '女'; // 已声明的变量重新赋值不会报错
		//由于number前没有声明类型，即当前number变量没有提前定义，所以编译不通过
		//number = 10;
	}
	public static void mian123(String[] args){
		//直接输出变量gender会报错，该变量只在声明他的作用域生效
		
		//System.out.println("gender = " + gender);
		// 在不同的作用域声明相同的变量没有问题
		char gender = '女';
	}
}

整数类型 

浮点类型

class VariableTest1
{
	public static void main(String[] args){
		//1.测试整型变量的使用
		// byte(1字节=8bit）...
		byte b1 = 12;
		byte b2 = 127;
		//byte b3 = 128; //不兼容的类型: 从int转换到byte可能会有损失
		short s1 = 1234;
		
		int i1 = 123234123;

		long l1 = 123123123L;
		double d1 = 12.3;
		float f1 = 12.3f;
		System.out.println("f1 = " + f1);
		//测试浮点型变量的精度
		//结论：通过测试发现浮点型变量的精度不高，如果在开发中，需要极高的精度，需要使用BigDecimal类替换浮点型变量
		// 测试1
		System.out.println(0.1+0.2); // 0.30000000000000004
		//测试2
		float ff1 = 123123123f;
		float ff2 = ff1 + 1;
		System.out.println(ff1); //1.2312312E8
		System.out.println(ff2); //1.2312312E8
		System.out.println(ff1 == ff2); // true
	}
}

字符类型 char

ASCII码

 Unicode 编码

UTF-8

布尔类型：boolean

class VariableTest2
{
	public static void main(String[] args){
		char c1 = 'a';
		char c2 = '中';
		char c3 = '1';
		char c4 = '%';
		char c5 = 'γ'; // 错误: 空字符文字
		//编译不通过
		//char c6 = ''; // 错误: 空字符文字
		//char c7 = 'ab'; // 错误: 不是语句，两个字符了，内部有且仅有一个字符
		//表示形式2：直接使用 Unicode 值来表示字符型常量
		char c8 = '\u0036';
		System.out.println(c8); // 6
		// 表示形式3：使用转义字符
		char c9 = '\n';
		char c10 = '\t';
		System.out.println("hello" + c9 + "world");
		System.out.println("hello" + c10 + "world");
		//表示形式4：使用具体字符对应的数值（比如ASCII码）
		char c11 = 97;
		System.out.println(c11); // a
		char c12 = '1';
		char c13 = 1;
		//2.布尔类型：boolean
		//只有两个值：true，false
		boolean bo1 = true;
		boolean bo2 = false;
		//编译不通过
		//boolean bo3 = 0; // 错误: 不兼容的类型: int无法转换为boolean
		boolean isMarried = true;
		if(isMarried) {
			System.out.println("很遗憾，不能参加单身派对了");
		}else {
			System.out.println("可以多谈几个女朋友或男朋友");
		}

	}
}


/*
Java定义的数据类型

一、变量按照数据类型来分：

	基本数据类型：
		整型：byte \ short \ int \ long
		浮点型：float \ double
		字符型：char
		布尔型：boolean


	引用数据类型：
		类(class)
		接口(interface)
		数组(array)


二、变量在类中声明的位置：
		成员变量  vs  局部变量
*/
class VariableTest1 {
	public static void main(String[] args) {
		//1. 整型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
		//① byte范围：-128 ~ 127
		//
		byte b1 = 12;
		byte b2 = -128;
		//b2 = 128;//编译不通过
		System.out.println(b1);
		System.out.println(b2);
		// ② 声明long型变量，必须以"l"或"L"结尾
		// ③ 通常，定义整型变量时，使用int型。没有特殊情况的话
		short s1 = 128;
		int i1 = 1234;
		long l1 = 3414234324L;
		System.out.println(l1);

		//2. 浮点型：float(4字节) \ double(8字节)
		//① 浮点型，表示带小数点的数值
		//② float表示数值的范围比long还大

		double d1 = 123.3;
		System.out.println(d1 + 1);
		//③ 定义float类型变量时，变量要以"f"或"F"结尾
		float f1 = 12.3F;
		System.out.println(f1); // 运行结果12.3，不会带上f
		//④ 通常，定义浮点型变量时，使用double型。因为精度更高
		//float 类型表数范围要大于long类型的表数范围，但是精度不高

		//3. 字符型：char (1字符=2字节)
		//① 定义char型变量，通常使用一对'',内部只能写一个字符
		char c1 = 'a';
		//编译不通过
		//c1 = 'AB';
		System.out.println(c1);

		char c2 = '1';
		char c3 = '中';
		char c4 = 'ス';
		System.out.println(c2);
		System.out.println(c3);
		System.out.println(c4);

		//② 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
		char c5 = '\n';//换行符
		c5 = '\t';//制表符
		System.out.print("hello" + c5);
		System.out.println("world");

		char c6 = '\u0043';
		System.out.println(c6);

		//4.布尔型：boolean
		//① 只能取两个值之一：true 、 false
		//② 常常在条件判断、循环结构中使用，常常使用在流程控制语句中
		boolean bb1 = true;
		System.out.println(bb1);

		boolean isMarried = true;
		if(isMarried){
			System.out.println("你就不能参加\"单身\"party了！\\n很遗憾");
		}else{
			System.out.println("你可以多谈谈女朋友！");
		}
		//了解：我们不谈boolean类型占用空间的大小，但是，真正在内存中分配的话，使用的是4个字节
	}
}

练习题：

练习1
class FloatDoubleExer
{
	public static void main(String[] args){
		//定义圆周率变量
		double pi = 3.14;
		//定义三个圆的半径
		double radius1 = 1.2;
		double radius2 = 2.5;
		int radius3 = 6;
		//计算面积
		double area1 = pi * radius1 * radius1;
		double area2 = pi * radius2 * radius2;
		double area3 = pi * radius3 * radius3;
		//输出
		System.out.println("圆1的半径为："+radius1+"，面积为：" + area1);
		System.out.println("圆2的半径为："+radius2+"，面积为：" + area2);
		System.out.println("圆3的半径为："+radius3+"，面积为：" + area3);
		//圆1的半径为：1.2，面积为：4.521599999999999
		//圆2的半径为：2.5，面积为：19.625
		//圆3的半径为：6，面积为：113.03999999999999
	}
}

练习2
/*
	案例2：小明要到美国旅游，可是哪里的温度是以华氏度为单位记录的
	他需要一个程序将华氏温度（80度）转化为摄氏度，并以华氏度和摄氏度为单位分别显示该温度
	℃=(℉-32)/1.8
*/
class FloatDoubleExer1
{
	public static void main(String[] args){
		double hua = 80.0;
		double she = (hua - 32) / 1.8;
		System.out.println("华氏度" + hua + "℉ 对应的摄氏度为" + she + "℃");
		//华氏度80.0℉ 对应的摄氏度为26.666666666666664℃
	}
}

基本数据类型转换

1
/*
基本数据类型之间的运算规则：

前提：这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。

1. 自动类型提升：
    结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
	byte 、char 、short --> int --> long --> float --> double 

	特别的：当byte、char、short三种类型的变量做运算时，结果为int型
	
2. 强制类型转换：见VariableTest3.java


说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
*/
class VariableTest2 {
	public static void main(String[] args) {
		
		byte b1 = 2;
		int i1 = 129;
		//编译不通过
		//byte b2 = b1 + i1;
		int i2 = b1 + i1;
		long l1 = b1 + i1;
		System.out.println(i2);

		float f = b1 + i1;
		System.out.println(f);

		short s1 = 123;
		double d1 = s1;
		System.out.println(d1);//123.0

		//***************特别地*********************
		char c1 = 'a';//97
		int i3 = 10;
		int i4 = c1 + i3;
		System.out.println(i4);

		short s2 = 10;
		//char c2  = c1 + s2;//编译不通过

		byte b2 = 10;
		//char c3 = c1 + b2;//编译不通过

		//short s3 = b2 + s2;//编译不通过

		//short s4 = b1 + b2;//编译不通过
		//****************************************

	}
}

2
class VariableTest3
{
	public static void main(String[] args){
		int i1 = 10;
		int i2 = i1;
		long l1 = i1;
		float f1 = l1;
		byte b1 = 12;
		int i3 = b1+i1;
		//编译不通过
		//byte b2 = b1 + i1; // 错误: 不兼容的类型: 从int转换到byte可能会有损失
		byte b3 = 12;
		short s1 = 10;
		//编译不通过
		//short s2 = b3 + s1; //错误: 不兼容的类型: 从int转换到short可能会有损失
		i3 = b3 + s1;
		byte b4 = 10;
		//编译不通过
		// 错误: 不兼容的类型: 从int转换到byte可能会有损失
		//byte b5 = b3 + b4; //byte与byte之间做运算，short与short之间做运算很容易超过byte或short这个范围，char同理，或者两者交叉运算
		// 特别的：byte，short，char类型的变量之间做运算，结果为int类型
		//特殊情况2: char
		char c1 = 'a';
		//编译不通过
		//char c2 = c1 + b3;  //错误: 不兼容的类型: 从int转换到char可能会有损失
		int i4 = c1 + b3;


		//**********************************
		//练习1：
		long l2 = 123L;
		long l3 = 123; //理解为自动类型提升 （int ---> long）
		//错误: 整数太大
		//long l4 = 123123123123; //123123123123理解为int类型，因为超出了int范围，所以报错
		long l5 = 123123123123L; //此时123123123123L就是使用8个字节存储的long类型的值

		//练习3：
		float f2 = 12.5F;
		//编译不通过
		//错误: 不兼容的类型: 从double转换到float可能会有损失
		//float f3 = 12.3;  //不满足自动类型提升的规则（double ---> float)，所以报错

		//练习3：
		// 规定1：整型常量规定为int类型
		byte b5 = 10;
		//byte b6 = b5 + 1; // 错误: 不兼容的类型: 从int转换到byte可能会有损失
		int ii1 = b5 + 1;
		//规定2：浮点型的常量规定是double类型
		double dd1 = b5 + 12.3;
		//练习4：说明为什么不允许变量名是数字开头的，为了“自洽”
		/*int 123L = 12; //错误: 不是语句
		long l6 = 123L; //这样不太确定123L是变量，还是定义的数字类型
		*/
	}
}

字符串类型：String

视频代码
class StringTest
{
	public static void main(String[] args){
		String str1 = "Hello World!";
		System.out.println("str1"); //str1
		System.out.println(str1); //Hello World!

		String str2 = "";
		String str3 = "a";  // char c1 = 'a';
		//测试连接运算
		int num1 = 10;
		boolean b1 = true;
		String str4 = "hello";
		System.out.println(str4 + b1); //hellotrue
		String str5 = str4 + b1;
		String str6 = str4 + b1 + num1;
		System.out.println(str6); //hellotrue10
		//思考：如下的声明编译能通过吗？不能
		//错误: 二元运算符 '+' 的操作数类型错误, 第一个类型:  boolean，第二个类型: int
		//String str7 = b1 + num1 + str4;
		//如何将String类型的编码转化为基本数据类型？
		String str8 = "abc"; //不能考虑转换为基本数据类型的
		int num2 = 10;
		String str9 = num2 + ""; // "10"
		//编译不通过
		//int num3 = (int)str9; // 错误: 不兼容的类型: String无法转换为int
		//如何实现呢？使用Integer
		int num3 = Integer.parseInt(str9);
		System.out.println(num3 + 1); //11
	}
}

原代码
/*
String类型变量的使用
1. String属于引用数据类型,翻译为：字符串
2. 声明String类型变量时，使用一对""
3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
4. 运算的结果仍然是String类型
5.String声明的字符串可以包含0个，1个或多个字符

*/
class StringTest {
	public static void main(String[] args) {
		
		String s1 = "Hello World!";

		System.out.println(s1);

		String s2 = "a";
		String s3 = "";

		//char c = '';//编译不通过

		//***********************
		int number = 1001;
		String numberStr = "学号：";
		String info = numberStr + number;// +：连接运算
		boolean b1 = true;
		String info1 = info + b1;// +：连接运算
		System.out.println(info1);

		//***********************
		//练习1
		char c = 'a';//97   A:65
		int num = 10;
		String str = "hello";
		System.out.println(c + num + str);//107hello
		System.out.println(c + str + num);//ahello10
		System.out.println(c + (num + str));//a10hello
		System.out.println((c + num) + str);//107hello
		System.out.println(str + num + c);//hello10a

		//练习2
		//*	*
		System.out.println("*	*");
		System.out.println('*' + '\t' + '*');
		System.out.println('*' + "\t" + '*');
		System.out.println('*' + '\t' + "*");
		System.out.println('*' + ('\t' + "*"));


		//***********************

		//String str1 = 123;//编译不通过
		String str1 = 123 + "";
		System.out.println(str1);//"123"
		
		//int num1 = str1;
		//int num1 = (int)str1;//"123"

		int num1 = Integer.parseInt(str1);
		System.out.println(num1);//123
	}
}

String与基本数据类型之间的转换

class StringExer1
{
	public static void main(String[] args){
		//练习1：
		//String str1 = 4; //判断对错：no
		String str2 = 3.5f + ""; //判断str2对错：yes
		System.out.println(str2); //输出：”3.5”
		System.out .println(3+4+"Hello!"); //输出：7Hello!
		System.out.println("Hello!"+3+4); //输出：Hello!34
		System.out.println("a"+1+"Hello!"); //输出：98Hello!
		System.out.println("Hello"+"a"+1); //输出：Helloa1
		//练习2：
		System.out.println("*    *"); 
		System.out.println("*\t*"); 
		System.out.println("*"+"\t"+"*"); 
		System.out.println('*'+"\t"+"*"); //char与string连接，再与char连接
		System.out.println('*'+'\t'+"*"); //cahr与char做加法运算，然后与string连接
		System.out.println('*'+"\t"+'*'); //char与string做拼接，在与char做拼接
		System.out.println("*"+'\t'+'*'); //字符串与char之间连接的结果是字符串，在与char做拼接
		System.out.println('*'+'\t'+'*'); //三个char做加法运算
		/*
			*    *
			*       *
			*       *
			*       *
			51*
			*       *
			*       *
			93
			需要注意的是做加法等运算，还是做拼接，产生的结果不一样
		*/
	}
}

强制类型转换

s-2，b+4，s+b是int类型，原因：byte，short，char类型的变量之间做运算，结果为int类型

视频练习
class VariableTest4
{
	public static void main(String[] args){
		double d1 = 12; // 自动类型提升
		//编译不通过
		//int i1 = d1; //错误: 不兼容的类型: 从double转换到int可能会有损失
		int i2 = (int)d1;
		System.out.println(i2); //12
		long l1 = 123;
		//short s1 = l1; // 错误: 不兼容的类型: 从long转换到short可能会有损失
		short s2 = (short)l1;
		System.out.println(s2); // 123
		//练习
		int i3 = 12;
		float f1 = i3; //自动类型提升
		System.out.println(f1); //12.0
		float f2 = (float)i3; //编译可以通过，只不过可以省略而已，12.0
		System.out.println(f2);
		//精度损失的例子1：
		double d2 = 12.3;
		int i4 = (int)d2; 
		System.out.println(i4); //12
		//精度损失的例子2：
		int i5 = 128;
		byte b1 = (byte)i5;
		//编译通过，但是值为-128
		System.out.println(b1); //-128 
		
		//实际开发举例：
		byte b2 = 12;
		method(b2);

		long l2 = 12L;
		//编译不通过
		method((int)l2); //错误: 不兼容的类型: 从long转换到int可能会有损失
	}
	public static void method(int num){ //int num = b2;自动类型提升
		System.out.println("num = " + num);
	}
}

//原代码

/*
强制类型转换：自动类型提升运算的逆运算。
1.需要使用强转符：()
2.注意点：强制类型转换，可能导致精度损失。



*/
class VariableTest3 {
	public static void main(String[] args) {
		
		double d1 = 12.9;
		//精度损失举例1
		int i1 = (int)d1;//截断操作
		System.out.println(i1);
		
		//没有精度损失
		long l1 = 123;
		short s2 = (short)l1;
		
		//精度损失举例2
		int i2 = 128;
		byte b = (byte)i2;
		System.out.println(b);//-128

	}
}

进 制

二进制

第一位表示的是符号位，那么-1的二进制码也就是10000001，取反之后为11111110

进制间转化

视频练习代码
class BinaryTest
{
	public static void main(String[] args){
		int num1 = 103; // 十进制
		int num2 = 0b10; // 二进制
		int num3 = 023; // 八进制
		int num4 = 0X23a; //十六进制
		System.out.println(num1); //103
		System.out.println(num2); // 2
		System.out.println(num3); //19
		System.out.println(num4); //570
	}
}


原代码
/*
计算机中不同进制的使用说明

对于整数，有四种表示方式：
> 二进制(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 = 0b110;
		int num2 = 110;
		int num3 = 0127;
		int num4 = 0x110A;

		System.out.println("num1 = " + num1);
		System.out.println("num2 = " + num2);
		System.out.println("num3 = " + num3);
		System.out.println("num4 = " + num4);

	}
}

运算符

算术运算符

//视频练习代码1
/*
	为了抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？
*/
class AriExer1
{
	public static void main(String[] args){
		int hours = 89;
		int day = hours / 24;
		int hour = hours % 24;
		System.out.println("共奋战了：" + day + "天零" + hour + "小时"); //共奋战了：3天零17小时

		// 额外的练习1：
		System.out.println("5+5 = " + 5 + 5); //5+5=55
		System.out.println("5+5 = " + (5 + 5)); //5+5=10
		
		// 额外的练习2：
		byte bb1 = 127;
		bb1++;
		System.out.println("bb1 = " + bb1); //bb1 = -128

		// 额外的练习3：
		//int i = 1;
		//int j = i++ + ++i * i++;
		//       4  +  3  *  2  从左到右运算
		//System.out.println("j = " + j); //j = 10

		// 额外的练习4：
		int i = 2;
		int j = i++; // i先把值赋给别人，然后自己+1
		System.out.println("j = " + j); //2

		int k = 2;
		int z = ++k; //先增加，并把值赋给别人
		System.out.println(z); // 3
		// 额外的练习5：
		int m = 2;
		m = m++;
		System.out.println("m = " + m); //2
	}
}

//视频练习代码2
/*
运算符之一：算术运算符
+ - + - * / % (前)++ (后)++ (前)-- (后)-- +


*/
class AriTest
{
	public static void main(String[] args){
		//除数：/
		int m1 = 12;
		int n1 = 5;
		int k1 = m1 / n1;
		System.out.println(k1); //2
		System.out.println(m1 / n1 * n1); // 10

		//取模（或取余）：%
		int i1 = 12;
		int j1 = 5;
		System.out.println(i1 % j1); // 2
		//开发中，经常用来判断某个数num1能整除另一个数num2。 num1 % num2 == 0
		//开发中，经常使用%来判断能否被除尽的情况。
		//比如判断num1是否为偶数： num1 % 2 == 0
		//结果的符号与被模数的符号相同
		int i2 = -12;
		int j2 = 5;
		System.out.println(i2 % j2); //-2
		int i3 = 12;
		int j3 = -5;
		System.out.println(i3 % j3); //2
		int i4 = -12;
		int j4 = -5;
		System.out.println(i4 % j4); //-2
		
		//（前）++：先自增1，在运算
		//（后）++：先运算，后自增1，存储空间的值改变了
		int a1 = 10;
		int b1 = ++a1;
		System.out.println("a1 = " + a1 + "，b1 = " + b1); // a1 = 11，b1 = 11 

		int a2 = 10;
		int b2 = a2++;
		System.out.println("a2 = " + a2 + "，b2 = " + b2); // a1 = 11，b1 = 10 
		//练习1：
		int i = 10;
		//i++;
		++i;
		System.out.println("i = " + i); //11
		//练习2：
		short s1 = 10;
		//方式1：
		//编译不通过
		//s1 = s1 + 1;  // 错误: 不兼容的类型: 从int转换到short可能会有损失
		s1 = (short)(s1 + 1); //自增1不会改变本身变量的数据类型
		System.out.println(s1); 

		//方式2：
		s1++;
		System.out.println(s1); //12
		
		//***************************
		//(前）--：先自减1，在运算
		//(后）--：先运算，在自减1
		

		//+：连接符，只适用于String与其他类型的变量间的运算，而且运算的结果也是String类型
	}
}

//视频练习代码3
class AriExer
{
	public static void main(String[] args){
		int num = 153;
		int ge = num % 10; //个位
		int shi = num / 10 % 10; //十位  int shi = num % 100 / 10
		int bai = num / 100;
		System.out.println("个位是：" + ge);
		System.out.println("十位是：" + shi);
		System.out.println("百位是：" + bai);
		/*
			个位是：3
			十位是：5
			百位是：1
		*/
	}
}

 赋值运算符

/*
运算符之二：赋值运算符
=  +=  -=  *=  /=  %= 


*/
class SetValueTest
{
	public static void main(String[] args){
		int i = 5;
		long l = 10; //自动类型提升
		byte b = (byte)i; // 强制类型转换
		//操作方式1：
		int a1 = 10;
		int b1 = 10;
		//操作方式2：连续赋值
		int a2;
		int b2;
		//或合并：int a2,b2;
		a2 = b2 = 10;

		System.out.println(a2 + "," + b2); // 10,10

		//操作方式3：
		//int a3 = 10;
		//int b3 = 10;
		int a3 = 10,b3 = 20;
		System.out.println(a3 + "," + b3); //10,20

		//******************************
		//说明 += 的使用
		int m1 = 10;
		m1 += 5; // 类似于m1 = m1 + 5
		System.out.println(m1); //15

		byte by1 = 10;
		by1 += 5; // by1 = by1 + 5操作会编译报错，应该写为：by1 = (byte)(by1 + 5)
		System.out.println(m1); //15
		
		int m2 = 1;
		m2 *= 0.1; // 等价于m2 = (int)(m2 * 0.1)
		System.out.println(m2); //0

		//练习1：如何实现变量的值增加2
		//方式1：
		int n1 = 10;
		n1 = n1 + 2;

		//方式2：推荐
		int n2 = 10;
		n2 += 2;

		//练习2：如何实现变量的值增加1
		//方式1：
		int i1 = 10;
		i1 = i1 + 1;

		//方式2：
		int i2 = 10;
		i2 += 1;

		//方式3：推荐
		int i3 = 10;
		i3++; // ++i3
	}
}

针对于short类型的自增 

比较运算符

/*
运算符之三：比较运算符
1.==  !=  >  <  >= <=  instanceof
2.说明
instanceof 在面向对象的多态性的位置的讲解
==  !=  >  <  >=  <= 适用于除boolean类型之外的其他7种基本数据类型
运算的结果为boolean类型
了解： ==  !=  可以适用于引用数据类型
区分：==  与 =


结论：
1.比较运算符的结果是boolean类型
2.区分 ==  和  = 
*/
class CompareTest
{
	public static void main(String[] args){
		int m1 = 10;
		int m2 = 20;
		int compare1 = m1 > m2;
		System.out.println(compare1);

		int n1 = 10;
		int n2 = 20;
		System.out.println(n1 == n2); // false
		System.out.println(n1 = n2); // 20

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

逻辑运算符

视频练习代码1
/*
运算符之四：逻辑运算符

&  && |  || ! ^

说明：
1.逻辑运算符操作的都是boolean类型的变量
2.逻辑运算符运算的结果也是boolean类型
3.逻辑运算符常使用条件判断结构，循环结构中

*/
class LoginTest
{
	public static void main(String[] args){
		//区分& 与 &&
		//相同点：两个符号表达的都是”且“的关系，只有当符号左右两边的类型值均为true时，结果才为true
		//相同点1：& 与  && 的运算结果相同
		//相同点2：当符号左边是true时，二者都会执行符号右边的运算
		//不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
		//开发中，推荐使用&&
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		if(b1 & (num1++ > 0)){
			System.out.println("床前明月光");
		}else {
			System.out.println("我叫郭德纲");
		}
		System.out.println("num1 = " + num1);
		/*
				b1与b2值为true的结果：
				床前明月光
				num1 = 11
				床前明月光
				num2 = 11
		*/
		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		if(b2 && (num2++ > 0)){ //b2为false时，语法没有执行
			System.out.println("床前明月光");
		}else {
			System.out.println("我叫郭德纲");
		}
		System.out.println("num2 = " + num2);
		/*
			b1与b2值为false的结果：
			我叫郭德纲
			num1 = 11
			我叫郭德纲
			num2 = 10
		*/

		// 区分：| 与 || 
		//相同点1：| 与  || 的运算结果相同
		//相同点2：当符号左边是false时，二者都会执行符号右边的运算
		//不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
		//开发中，推荐使用||
		boolean b3 = false;
		b3 = true;
		int num3 = 10;
		if(b3 | (num3++ > 0)){
			System.out.println("床前明月光");
		}else {
			System.out.println("我叫郭德纲");
		}
		System.out.println("num3 = " + num3);
		/*
				b1与b2值为false的结果：
				床前明月光
				num3 = 11
				床前明月光
				num4 = 11
		*/
		boolean b4 = false;
		b4 = true;
		int num4 = 10;
		if(b4 || (num4++ > 0)){ //b2为false时，语法没有执行
			System.out.println("床前明月光");
		}else {
			System.out.println("我叫郭德纲");
		}
		System.out.println("num4 = " + num4);
		/*
			b1与b2值为true的结果：
			床前明月光
			num3 = 11
			床前明月光
			num4 = 10
		*/
	}
}
视频练习代码2

/*
1.定义类 LogicExer
2.定义main方法
3.定义一个int类型变量a，变量b，都赋值为20；
4.定义boolean类型变量bo1，判断++a，是否被3整除，并且a++是否被7整除，将结果赋值给bo1
5.输出a的值，bo1的值
6.定义boolean类型变量bo2，判断b++是否被3整除，并且++b是否被7整除，将结果赋值给bo2
7.输出b的值，bo2的值
*/
class LoginExer {
	public static void main(String[] args) {
		int a,b;
		a = b = 20;

		boolean bo1 = (++a % 3 == 0) && (a++ % 7 == 0);
		System.out.println("a = " + a + "，bo1 = " + bo1); //a = 22，bo1 = true
		boolean bo2 = (b++ % 3 == 0) && (++b % 7 == 0);
		System.out.println("b = " + b + "，bo2 = " + bo2); //b = 21，bo2 = false
	}
}

位运算符

视频练习1
/*
运算符之五：位运算符 （了解）

结论：
1. 位运算符操作的都是整型的数据
2. << ：在一定范围内，每向左移1位，相当于 * 2
   >> :在一定范围内，每向右移1位，相当于 / 2



面试题：最高效方式的计算2 * 8 ？  2 << 3  或 8 << 1
*/

class BitTest {
	public static void main(String[] args) {
		int num1 = 7;
		System.out.println("num1 << 1：" + (num1 << 1)); //num1 << 1：14
		System.out.println("num1 << 2：" + (num1 << 2)); //num1 << 2：28
		System.out.println("num1 << 3：" + (num1 << 3)); //num1 << 3：56
		System.out.println("num1 << 28：" + (num1 << 28)); //num1 << 28：1879048192
		System.out.println("num1 << 29：" + (num1 << 29)); //num1 << 29：-536870912  过犹不及，最高位会变成1，也就是负数了

		int num2 = -7;
		System.out.println("num2 << 1：" + (num2 << 1)); //num2 << 1：-14
		System.out.println("num2 << 2：" + (num2 << 2)); //num2 << 2：-28
		System.out.println("num2 << 3：" + (num2 << 3)); //num2 << 3：-56
		System.out.println(~9); -10
		System.out.println(~-10); 9
	}
}


视频练习2
/*
	案例2：如何交换两个int型变量的值？ String呢？
*/

class BitExer {
	public static void main(String[] args) {
		int m = 10;
		int n = 20;
		System.out.println("m = " + m + ",n = " + n);  //m = 10,n = 20
		

		//交换两个变量的值
		//方式1：声明一个临时变量（推荐）
		int temp = m;
		m = n;
		n = temp;
		System.out.println("m = " + m + ",n = " + n); //m = 20,n = 10

		//方式2：优点：不需要定义临时变量，缺点：难，适用性差（不适用于非数值类型），可能超出int的范围
		m = m + n; // 30 = 10 + 20;
		n = m - n; // 10 = 30 - 20;
		m = m - n; // 20 = 30 - 10;
		System.out.println("m = " + m + ",n = " + n);//m = 10,n = 20

		//方式3：优点：不需要定义临时变量。优点：真难，适用性差（不适用于非数值类型）
		m = m ^ n;
		n = m ^ n; // (m ^ n) ^ n ---> m
		m = m ^ n;
		System.out.println("m = " + m + ",n = " + n);//m = 20,n = 10
	}
}

三元运算符

//视频练习题
/*
运算符之六：三元运算符
1.结构：(条件表达式)? 表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
  如果表达式为true，则执行表达式1。
  如果表达式为false，则执行表达式2。
③ 表达式1 和表达式2要求是一致的。
④ 三元运算符可以嵌套使用

3. 
凡是可以使用三元运算符的地方，都可以改写为if-else
反之，不成立。

4. 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。
*/
class ConditionTest {
	public static void main(String[] args) {
		String info = (2 > 1) ? "表达式1" : "表达式2";
		System.out.println(info); // 表达式1
		double result = (2 > 1) ? 1 : 2.0; 
		System.out.println(result); //1.0

		//练习1：获取连个整数的较大值
		int m = 10;
		int n = 20;
		int max = (m > n) ? m : n;
		System.out.println("较大值为：" + max); //较大值为：20
		//练习2：获取三个整数的最大值
		int i = 20;
		int j = 30;
		int k = 23;
		int tempMax = (i > j) ? i : j;
		int finalMax = (tempMax > k) ? tempMax : k;
		System.out.println("较大值为：" + finalMax); //较大值为：30
		int finalMax1 = (((i > j) ? i : j) > k) ? (i > j) ? i : j : k;
		System.out.println("较大值为：" + finalMax1);  //较大值为：30
	}
}

/*
	今天是周二，10天后是周几？
	要求：控制台输出“今天是周2,10天后是周x”
*/
class ConditionExer {
	public static void main(String[] args) {
		int week = 2;
		//week = 4; //注意是整周的情况，除以7是0
		week += 10;
		week %= 7;
		
		System.out.println("今天是周2,10天后是周" + ((week == 0) ? "日" : week));  //今天是周2,10天后是周5
	}
}