Java学习笔记 第三天

第二章 运算符

2.2 赋值运算符

赋值运算符	含义
=，等号	/
+=，加等	a += 4 —> a = a + 4
-=，减等	a -= 4 —> a = a - 4
*=，乘等	a *= 4 —> a = a * 4
/=，除等	a /= 4 —> a = a / 4
%=，模等	a %= 4 —> a % a + 4

注意：
 1.只有变量才可以使用赋值运算符，常量不能进行赋值。如：5 = 3是错误写法
 2.复合赋值运算符其中隐含了一个强制类型转换。

byte x = 10;

//	x = x + 5
//	x = byte + int
//	x = int	+	int
//	x = int
//	x = (byte) x

x += 5;	//	输出的结果是byte类型的的15，不是int类型的15.

2.3 比较运算符

比较运算符	含义
==	比较运算符两边数据是否相等，相等结果是true
<	比较符号左边的数据是否小于右边的数据，如果小于，结果是true
>	略
<=	略
>=	略
!=	如果比较符号两边的数据不相等，结果是true

注意：
 1.比较运算符的结果一定是boolean值，成立是true，不成立就是false
 2.如果进行多次判断，不能连着写。如：不能按照数学中的1 < x < 3

2.4 逻辑运算符

逻辑运算符	含义
&&（与）	全部都是true，才会是true；否则就是false
||（或）	只要有一个是true，就是true；全都是false才是false
！（非）	原来是true，变为false；原来是false，变为true

注意：
 1.与“&&”，或“||”具有短路效果，如果根据左边已经可以判断出结果，那么右边的代码将不再执行，从而节省一定的性能。

int a = 10;
//	false && ...
System.out.println(3 > 4 && ++a < 100);	//	False
System.out.println(a);	//	返回结果是10,原因在于上面那行后面的++a < 100被短路了，实际并没有被执行

int b = 20;
//	true	||	...
System.out.println(3 < 4 || ++b < 100);	//	true
System.out.println(b);	//	返回结果是20,原因在于上面那行后面的++b < 100被短路了，实际并没有被执行

 2.逻辑运算符只能用于boolean值
 3.与、或需要左右各自有一个boolean值，但是取反只需有一个boolean值即可
 4.与、或两种运算符，如果有多个条件，可以连续写。
 两个条件: 条件A && 条件B
 多个条件; 条件A && 条件B && 条件C
 如：
  TIPS:对于1 < x < 3的情况，应该拆成两个部分，然后用逻辑运算符连接起来，即x > 1 && x < 3

2.5 三元运算符

• 一元运算符：只需要一个数据就可以进行操作的运算符。如：自增++、自减–、取反！
• 二元运算符：需要两个数据才可以进行操作的运算符。如：加法+、赋值=
• 三元运算符：需要三个数据才可以进行操作的运算符

格式：
数据类型 变量名称 = 条件判断？表达式A：表达式B；
流程：
首先判断条件是否成立：
   如果成立为true，那么将表达式A的值赋值给左侧的变量
   如果不成立为false，那么将表达式B的值赋值给左侧的变量
二者选其一
如：

public class Demo10Operator{
	public static void main(String[] args){
		int a = 10;
		int b = 20;

		//	数据类型 变量名称 = 条件判断？表达式A：表达式B；
		//	判断a	>	b是否成立，如果成立，将a的值赋值给max，如果不成立将b的值赋值给max，二者选其一
		int max = a > b?a : b;
	}
}

注意：
 1.必须保证三元运算符中表达式A和表达式B都符合左侧的数据类型的要求。
如：

// 尽管结果应该是是10，是int类型，但是2.5是double类型，不是int，也没有强制类型转换，故下面代码写法错误
int result = 3 > 4 ? 2.5 : 10;

 2.三元运算符的结果必须被使用，可以像上面的例子一样用变量去接受，也可以用来打印输出
如：

int a = 2;
int b = 10;
System.out.println(3 > 4 ? 2.5 : b);	//	正确写法


a > b ? a : b;	//	这是错误写法，因为三元运算符的结果并没有被使用

第一章 方法入门

定义：
 就是将一个功能抽取出来，将代码单独定义在一个大括号内，形成一个单独的功能
格式：

public static void 方法名称(){
	方法体
}

//	方法体的命名规则和变量一样，使用小驼峰（首个字母小写，后面每个单词的首字母大写）
//	方法体：也就是大括号当中的内容，可以包含任意条语句

注意事项：

• 方法定义的先后顺序无所谓
• 方法的定义不能产生嵌套包含关系
• 方法定义好了之后，不会执行的。如果要想执行，必须要对方法进行调用。

方法的调用格式：
方法名称();

如：

public class Demo08Operator{
	public static void main(String[] args){
		farmer();
		seller();
		customer();
	}
	//	顾客
	public static void customer(){
		System.out.println("买菜");
		System.out.println("洗菜");
		System.out.println("做饭");
		System.out.println("吃饭");
	}
	//	农名
	public static void farmer(){
		System.out.println("种菜");
		System.out.println("杀虫");
		System.out.println("收割");
		System.out.println("贩卖");
	}
	//	商贩
	public static void seller(){
		System.out.println("进菜");
		System.out.println("贩卖");
	}
}

第二章 Jshell脚本工具

2.1 Jshell

特点： 不需要创建.java文件，也不需要创建类，可直接一步一步和剧本一样脚本式运行
启动：
 在DOS命令窗口中输入jshell即可进入
退出：
 /exit
使用场景： 在代码量很少，很简单时候建议使用。

例子如下：

2.2 编译器的两点优化

第一点优化：

/*
对于byte、short、char三种类型来说，如果右侧赋值的数据没有超过左侧的数据范围，
且不是小数据范围向大数据范围的自动类型转换
那么即使没有人为添加强制类型转换
javac编译器也会自动为我们隐含的添加一个(byte)或(short)或(char)，以此来进行强制类型转换
但要注意byte、short、char三种类型在进行数学运算时后一定是先转化为int类型，然后再进行数学运算的

而对于非byte、short、char之外的int、long、float、double、boolean（不能发生数据类型转换）来说
如果右侧赋值的数据超过左侧的数据范围，而且没有认为添加强制类型转换，javac编译器直接报错
*/

public class Demo12Notice{
	public static void main(String[] args){
		//	右侧确实是一个int数字，但是没有超过左侧的范围，就是正确的。
		//	int ---> byte，不是自动类型转换
		byte num1 = (byte)30;	//	右侧没有超过左侧的范围
		System.out.println(num1);	//	30
		
		//	byte num2 = 128;	//	右侧超过了范围
		
		// int ---> char,不是自动类型转换
		//	右侧没有超过左侧的范围
		char zifu = 65;	
		System.out.println(zifu);	//	A
		
		int a = (int)6L;		//	虽然右侧也没有超过左侧的范围，也不是自动类型转换，但是int类型不是byte、short、char三种类型之一，所以这行代码错误
		System.out.println(a);
	}
}

第二点优化：

/*
在给变量进行赋值的时候，如果右侧的表达式全都是常量
那么编译器javac将会直接将若干个常量表达式直接计算出来
short result = 5 + 8；//	等号右边全是常量，没有任何变量参与运算
编译之后，得到的.class字节码文件相当于【直接就是】：
short result = 13；
右侧的常量结果数值，没有超过左侧范围，所以正确

这称为“编译器的常量优化”
但是注意：一旦赋值符号“=”右边的表达式中有变量参与，这种优化将不能进行，而且，这种优化只发生在byte、short、char三种变量赋值的时候
*/
public class Demo13Notice{
	public static void main(String[] args){
		short num1 = 10;	//	正确写法，int ---> short虽然不是自动类型转换，但是右侧没有超过左侧数据范围，因此javac编译器会自动添加(short)进行强制数据类型转换
		
		short a = 5;
		short b = 8;
		//	short + short ---> int + int ---> int
		//	short result = a + b	//	错误写法！左侧需要是int类型
		//	5 + 8 = 13明明没有超过左边short的数据范围，为什么没有按照上一个知识点所说发生隐含的强制数据类型转换呢？
		//	原因在于short result = a + b 在给short类型变量result赋值时候，“=”右边有变量参加，上个知识点中的隐含强制类型转换只能发生在“=”右边全是常量的情况下
		
		
		//	右侧不用变量，而用常量，而且只有常量,可以发生“编译器的常量优化”
		short result = 5 + 8;
		System.out.println(result);
		
		//	右侧有变量，不能发生“编译器的常量优化，下面代码错误”
		//	short result = 5 + a + 8;
	}
}