java从入门到入土第3天

Day03

public class Test01{
	/**
		知识点：运算符
		分类：
			算数运算符
			赋值运算符
			关系运算符
			逻辑运算符
			三目运算符
			位运算符
			
		知识点：算数运算符的使用
		符号：+、-、*、/、%、++、--
		
		int a = 10;
		int b = 3;
		int result = a + b;
		System.out.println(result);//13
		System.out.println(a + b);//13
		System.out.println(10 + 3);//13
		System.out.println(10 - 3);//7
		System.out.println(10 * 3);//30
		System.out.println(10 / 3);//3
		System.out.println(10 % 3);//1
		
		//++：
		//++a：先自增1，再使用
		int a = 10;
		System.out.println(++a);//11
		System.out.println(a);//11
		//b++：先使用，再自增1
		int b = 10;
		System.out.println(b++);//10
		System.out.println(b);//11
		
		//--：
		//--c：先自减1，再使用
		int c = 10;
		System.out.println(--c);//9
		System.out.println(c);//9
		//d--：先使用，再自减1
		int d = 10;
		System.out.println(d--);//10
		System.out.println(d);//9
	*/
	public static void main(String[] args){
		
		
		
	}
}

public class Test02{
	/**	
		知识点：算数运算符的深入
		符号：+、-、*、/、%、++、--
		
		//特殊点1：byte类型做运算会先向上转型成int类型
		//注意：
		//	1.自动转型使用最高位补位
		//	2.强制转型从最高位开始舍弃
		byte b1 = 10;
		byte b2 = 20;
		
		//b1 - byte：0000,1010
		//	    int：0000,0000,0000,0000,0000,0000,0000,1010
		//b2 - byte：0001,0100
		//		int：0000,0000,0000,0000,0000,0000,0001,0100
		//		int：0000,0000,0000,0000,0000,0000,0001,1110
		//	 (byte)：0001,1110
		
		byte result = (byte)(b1 + b2);
		System.out.println(result);
		
		//特殊点2：short类型做运算会先向上转型成int类型
		short s1 = 10;
		short s2 = 20;
		
		//s1 - short：0000,0000,0000,1010
		//	     int：0000,0000,0000,0000,0000,0000,0000,1010
		//s2 - short：0000,0000,0001,0100
		//		 int：0000,0000,0000,0000,0000,0000,0001,0100
		//		 int：0000,0000,0000,0000,0000,0000,0001,1110
		//	 (short)：0000,0000,0001,1110
		
		short result = (short)(s1 + s2);
		System.out.println(result);
		
		//特殊点3：byte和short类型做运算会先向上转型成int，其余数值型按照取值范围大的类型返回数据
		byte b = 10;
		short s = 10;
		int i = 10;
		long l = 10;
		float f = 10;
		double d = 10;
		
		System.out.println(b + b);//结果的数据类型是：int
		System.out.println(b + s);//结果的数据类型是：int
		System.out.println(b + i);//结果的数据类型是：int
		System.out.println(i + l);//结果的数据类型是：long
		System.out.println(i + f);//结果的数据类型是：float
		System.out.println(l + f);//结果的数据类型是：float
		System.out.println(l + d);//结果的数据类型是：double
		System.out.println(f + d);//结果的数据类型是：double
		
		//特殊点4：++a; 和 b++;没有区别，因为分号是执行语句的结束，不管先加还是后加都给我加
		int a = 10;
		++a;
		System.out.println(a);//11
		
		int b = 10;
		b++;
		System.out.println(b);//11
		
		//特殊点5：
		int num = 10;
		//底层实现：num = (int)(num+1);
		++num;
		System.out.println(num);
		
		//特殊点6：char类型可以做运算
		char c = 'a';//'a'的码值是97
		int i = c+1;
		System.out.println(i);//98
		
		经典面试题一：输出结果为？
			int a = 8;
			int b = (a++)+(++a)+(a*10);
			//a = 10
			//b = 8 + 10 + 10*10
			System.out.println(b);
			
		经典面试题二：输出结果为？
			int i = 0 ;   
			//底层实现：
			// i = (int)(i+1);
			// i = i;
			i = ++i; 
			System.out.println(i);//1
			
		经典面试题三：输出结果为？
			int i = 0;   
			//底层实现：
			// int temp = i;//temp作为临时变量，记录了i最初始的值 -- 0
			// i = (int)(i+1);//i确确实实自增了-- 1
			// i = temp;//将temp赋值给i -- 0
			i = i++;  
			System.out.println(i);//0
	*/
	public static void main(String[] args){
		
		
		
	}
}

public class Test03{
	/**	
		知识点：赋值运算符
		符号：=、+=、-=、*=、/=、%=
		
		注意：
			=为赋值运算符，将右边的值赋值给左边的变量
			
		int num = 10;
		
		num += 5;//num = (int)(num+5);
		num -= 5;//num = (int)(num-5);
		num *= 5;//num = (int)(num*5);
		num /= 5;//num = (int)(num/5);
		num %= 3;//num = (int)(num%3);
		
		System.out.println(num);
		
		经典面试题一：输出结果为？
			int a,b; //一次性声明多个变量
			a = b = 100;//将100赋值给b，再将b赋值给a
			System.out.println(a); //100
			System.out.println(b); //100
			
		经典面试题二：下面的两种写法结果分别是？
			short s=1; 
			s = s+1; //short和int做运算会向上转型成int，如果没有强转就会报错

			short s=1; 
			s += 1;
			
		赋值规则：
					 s   += 1                s  = (short)((s)  +    (1))
			复合赋值 E1 op= E2等价于简单赋值 E1 = (T)((E1) op 	(E2))，其中T是E1的类型。
	*/
	public static void main(String[] args){
		
		
	}
}

public class Test04{
	/**	
		知识点：关系运算符
		符号：==、!=、>、>=、<、<=
		
		注意：
			==判断两个值是否相等
			!=判断两个值是否不相等
			关系运算符的结果必须是boolean
		
		boolean bool = 10 == 20;
		System.out.println(bool);//false
		System.out.println(10 != 20);//true
		System.out.println(10 >  20);//false
		System.out.println(10 >= 20);//false
		System.out.println(10 <  20);//true
		System.out.println(10 <= 20);//true
		
		经典面试题一：输出结果为？
			int x = 10;
			int y = 10;
			boolean flag = (x == y);
			System.out.println(flag);//true
			flag = (x = y);//会报错 -- 因为boolean类型不能与其他类型兼容
			System.out.println(flag);
			
		经典面试题二：输出结果为？
			boolean b1 = true;
			boolean b2 = false;
			boolean b3 = (b1 == b2);
			System.out.println(b3);//false
			boolean b4 = (b1 = b2);
			System.out.println(b4);//false
	*/
	public static void main(String[] args){
		
		
		
	}
}

public class Test05{
	/**	
		知识点：字符串拼接符
		符号：+
		
		注意：
			+两侧都是数值，该符号为算数运算符
			+两侧有一侧或两侧是字符串，该符号为字符串拼接符
	*/
	public static void main(String[] args){
		
		System.out.println(1 + 2 + "abc" + "def" + 1 + 2);
		//					 3   + "abc" + "def" + 1 + 2
		//					    "3abc"   + "def" + 1 + 2
		//							"3abcdef"    + 1 + 2
		//								"3abcdef1"   + 2
		//									"3abcdef12"
		
	}
}

//导包
import java.util.Scanner;

public class Test06{
	/**	
		知识点：Scanner类
		理解：Scanner是Java提供的专门用于在控制台输入数据的类
	*/
	public static void main(String[] args){
	
		//创建Scanner类的对象
		//人类  郭丹 = 新建 人类();
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入int类型的数据：");
		int i = scan.nextInt();//用户可以在控制台输入数据，并把数据赋值给i
		
		System.out.println("请输入double类型的数据：");
		double d = scan.nextDouble();
	
		System.out.println("请输入字符串类型的数据：");
		String str = scan.next();

		System.out.println(i);
		System.out.println(d);
		System.out.println(str);
		
		//错误示范：Scanner没有输入字符的功能
		//System.out.println("请输入字符类型的数据：");
		//char c = scan.nextChar();
		//System.out.println(c);
	}
}

import java.util.Scanner;
public class Test07{
	/**	
		知识点：逻辑运算符
		符号：
			&与		&&短路与
			|或		||短路或
			^异或
			!非
			
		注意：
			1.逻辑运算符运行结果都是boolean类型
			2.&、&&、|、||、^ 两侧都是boolean类型数据
			
		//&与：前后两侧都是boolean值，两侧都为true，结果才为true
		System.out.println(true & true);//true
		System.out.println(false & true);//false
		System.out.println(true & false);//false
		System.out.println(false & false);//false

		//&&短路与：前后两侧都是boolean值，两侧都为true，结果才为true
		System.out.println(true && true);//true
		System.out.println(false && true);//false
		System.out.println(true && false);//false
		System.out.println(false && false);//false	

		//& vs &&
		//&与：判断前者为false后，还会判断后者
		//&&短路与：判断前者为false后，不会判断后者，直接返回false，所以效率更高
		//ArithmeticException - 算数异常
		System.out.println(false && 10/0>3);

		//|或：前后两侧都是boolean值，两侧有为true，结果就为true
		System.out.println(true | true);//true
		System.out.println(false | true);//true
		System.out.println(true | false);//true
		System.out.println(false | false);//false	

		//||短路或：前后两侧都是boolean值，两侧有为true，结果就为true
		System.out.println(true || true);//true
		System.out.println(false || true);//true
		System.out.println(true || false);//true
		System.out.println(false || false);//false
		
		//| vs ||
		//|或：判断前者为true后，还会判断后者
		//||短路或：判断前者为true后，不会判断后者，直接返回true，所以效率更高
		System.out.println(true || 10/0>3);
		
		//^异或：前后两侧都是boolean值，两侧相同为false，不同为true
		System.out.println(true ^ true);//false
		System.out.println(false ^ true);//true
		System.out.println(true ^ false);//true
		System.out.println(false ^ false);//false
		
		//!非：置反
		boolean bool1 = true;
		System.out.println(!bool1);//false
		
		boolean bool2 = false;
		System.out.println(!bool2);//true
		
		练习题：在dos窗口输入一个数字，判断是否在50~100的区间内
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入数字：");
		int num = scan.nextInt();
		
		boolean bool = num>=50 && num<=100;
		System.out.println("输入的数字是否在50~100的区间内：" + bool);
	*/
	public static void main(String[] args){
	

		
	}
}

import java.util.Scanner;
public class Test08{
	/**	
		知识点：表达式
			5+6 算数表达式
			5>6 关系表达式
	
		知识点：三目运算符/三元运算符
		
		语法规则：变量 = (表达式)?值1:值2;
			
		理解：表达式的结果必须是boolean值
			true - 将值1赋值给变量
			false- 将值2赋值给变量
			
		做实验：
			int num = (false)?10:20;
			System.out.println(num);
			
		案例1：在控制台输入两个int类型的数据，判断大小，输出最大值
			Scanner scan = new Scanner(System.in);
		
			System.out.println("请输入第一个数字：");
			int a = scan.nextInt();
			System.out.println("请输入第二个数字：");
			int b = scan.nextInt();
			
			int max = (a>b)?a:b;//判断a是否大于b，如果成立就返回a，否则返回b
			System.out.println("最大值为：" + max);
			
		案例2：在控制台输入三个int类型的数据，判断大小，输出最大值
			Scanner scan = new Scanner(System.in);
		
			System.out.println("请输入第一个数字：");
			int a = scan.nextInt();
			System.out.println("请输入第二个数字：");
			int b = scan.nextInt();
			System.out.println("请输入第三个数字：");
			int c = scan.nextInt();
			
			//解题思路：先判断前两个数字，再跟第三个数字比较
			int max = (a>b)?a:b;
			max = (max>c)?max:c;
			System.out.println("最大值为：" + max);
			
		案例3：在控制台输入二个int类型的数据，判断大小，输出最小值
			Scanner scan = new Scanner(System.in);
		
			System.out.println("请输入第一个数字：");
			int a = scan.nextInt();
			System.out.println("请输入第二个数字：");
			int b = scan.nextInt();
			
			int min = (a<b)?a:b;
			System.out.println("最小值为：" + min);
			
		案例4：在控制台输入三个int类型的数据，判断大小，由小到大输出
			Scanner scan = new Scanner(System.in);
		
			System.out.println("请输入第一个数字：");
			int a = scan.nextInt();
			System.out.println("请输入第二个数字：");
			int b = scan.nextInt();
			System.out.println("请输入第三个数字：");
			int c = scan.nextInt();
			
			//最大值
			int max = (a>b)?a:b;
			max = (max>c)?max:c;
			
			//最小值
			int min = (a<b)?a:b;
			min = (min<c)?min:c;
			
			//中间值
			int mid = a+b+c-max-min;
			
			System.out.println(min + "<" + mid + "<" + max);
			
		扩展面试题1：
			System.out.println((false)?10.9:9);//9.0
			
		扩展面试题2：
			char x = 'x';//码值 - 120
			int i = 10;
			System.out.println(false?i:x);//120
			
		扩展面试题3：
			char x = 'x';//码值 - 120
			System.out.println(false?100:x);//x
			System.out.println(false?100000:x);//120
			
		扩展 - 常量：在程序执行过程中，不可发生改变的量
		注意：数字字面量就是常量的一种
		
		三目运算符返回值规则：
			1.值1和值2都是常量的情况，按照取值范围大的类型返回数据
			2.值1和值2都是变量的情况，按照取值范围大的类型返回数据
			3.值1和值2一个是常量一个是变量的情况，判断常量是否在变量所属类型的取值范围里
				在 - 按照变量类型返回数据
				不在-按照常量类型返回数据
	*/
	public static void main(String[] args){
	
		
		
	}
}

public class Test09{
	/**	
		知识点：位运算符
		理解：将十进制的数据转换为二进制做运算符
		符号：
			&与		|或		^异或
			<< 左移
			>> 右移
			>>> 无符号位右移
			
		//&与：同位比较，两者为1，结果才为1
		byte b1 = 19;//0001,0011
		byte b2 = 21;//0001,0101
					 //0001,0001
		
		//b1 - byte：0001,0011
		//	    int：0000,0000,0000,0000,0000,0000,0001,0011
		//b2 - byte：0001,0101
		//		int：0000,0000,0000,0000,0000,0000,0001,0101
		//		int：0000,0000,0000,0000,0000,0000,0001,0001
		//	 (byte)：0001,0001
		byte result = (byte)(b1 & b2);
		System.out.println(result);//17 - 0001,0001
		
		//|或：同位比较，两者有1，结果就为1
		int i1 = 19;//0000,0000,0000,0000,0000,0000,0001,0011
		int i2 = 21;//0000,0000,0000,0000,0000,0000,0001,0101
					//0000,0000,0000,0000,0000,0000,0001,0111
		System.out.println(i1 | i2);//23
		
		//^异或：同位比较，两者不同为1，相同为0
		int i1 = 19;//0000,0000,0000,0000,0000,0000,0001,0011
		int i2 = 21;//0000,0000,0000,0000,0000,0000,0001,0101
					//0000,0000,0000,0000,0000,0000,0000,0110
		System.out.println(i1 ^ i2);//6
		
		注意：
			&、|、^前后两侧是数值，该符号为位运算符
			&、|、^前后两侧是布尔值，该符号为逻辑运算符
			
		//<<左移：整体向左移动n位，就用n个0补位(补到最低位)
		//注意：左移一位相等于乘2
		int i = 1024;//0000,0000,0000,0000,0000,0100,0000,0000
					 //0000,0000,0000,0000,0001,0000,0000,0000
		System.out.println(i << 2);//4096
		
		//>>右移：整体向右移动n位，就用n个最高位/符号位补位(补到最高位)
		//注意：右移一位相等于除2
		int a = 1024;//0000,0000,0000,0000,0000,0100,0000,0000
					 //0000,0000,0000,0000,0000,0001,0000,0000
		System.out.println(a >> 2);//256
		int b = -1024;//1111,1111,1111,1111,1111,1100,0000,0000
					  //1111,1111,1111,1111,1111,1111,0000,0000
		System.out.println(b >> 2);//-256
		
		//>>>无符号位右移：整体向右移动n位，就用n个0补位(补到最高位)
		//注意：>>和>>>在处理正数的情况下没有区别
		int c = 1024;//0000,0000,0000,0000,0000,0100,0000,0000
					 //0000,0000,0000,0000,0000,0001,0000,0000
		System.out.println(c >> 2);//256
		int d = -1024;//1111,1111,1111,1111,1111,1100,0000,0000
					  //0011,1111,1111,1111,1111,1111,0000,0000
		System.out.println(d >>> 2);//1073741568
		
		面试题：描述下列代码运行结果
		考点：char类型的取值范围没有负数，向上转型是用0补位
		//-1 - int：1111,1111,1111,1111,1111,1111,1111,1111
		//    byte：1111,1111
		//	  char：1111,1111,1111,1111
		//	   int：0000,0000,0000,0000,1111,1111,1111,1111
		System.out.println((int)(char)(byte)-1);//65535
	*/
	public static void main(String[] args){
			
		
	}
}

public class Work01{
	/**	
		1.请实现两个整数变量的交换
		
	*/
	public static void main(String[] args){
		
		int a = 1;
	   	int b = 2;
		
		//经过交换之后，这里需要大家实现交换的代码		                                                
     	
		//解决方案1：
		//缺点：有第三方变量的介入
		//int temp = a;
		//a = b;
		//b = temp;
		
		//解决方案2：
		//缺点：如果数字过大，做运算可能会失去精度
		//a = a+b;//a-3
		//b = a-b;//b-1
		//a = a-b;//a-2
		
		//解决方案3：
		a = a^b;//a - 3
		b = a^b;//b - 1
		a = a^b;//a - 2
		
		System.out.println(a);//2
		System.out.println(b);//1
	}
}

public class Work02{
	/**	
		2.求长方形的周长 和 面积 长为1.5 宽为 4
	*/
	public static void main(String[] args){
		
		double length = 1.5;
		double width = 4;
		
		double perimeter = (length+width)*2;
		double area = length * width;
		
		System.out.println("周长为：" + perimeter);
		System.out.println("面积为：" + area);
		
	}
}

public class Work03{
	/**	
		3.一辆汽车 以40km/h的速度行驶,行驶了45678.9km,求所用的时间
	*/
	public static void main(String[] args){
		
		double length = 45678.9;
		double v = 40;
		
		double t = length/v;

		System.out.println("所有时间为：" + t);
		
	}
}

public class Work04{
	/**	
		4.定义字符变量赋值为 'A' -->输出 'a'
		
		'A' - 65
		'a' - 97
	*/
	public static void main(String[] args){
		
		char c = 'A';
		
		c = (char)(c+32);
		
		System.out.println(c);
	}
}

import java.util.Scanner;
public class Work05{
	/**	
		5.键盘录入两个整数 求 两个整数的 乘积
	*/
	public static void main(String[] args){

		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入第一个数字：");
		int a = scan.nextInt();
		System.out.println("请输入第二个数字：");
		int b = scan.nextInt();
	
		int result = a*b;
		System.out.println("乘积为：" + result);
	}
}

总结及作业

1.算数运算符（+、-、*、/、%、++、–）
注意：特殊点和面试题

2.赋值运算符（=、+=、-=、*=、/=、%=）
注意：复合赋值的底层公式

3.关系运算符（==、!=、>、>=、<、<=）
注意：关系运算符的结果都是boolean类型的值

4.字符串拼接符（+）

5.Scanner类
注意：感受面相对象的思想

6.逻辑运算符（&、&&、|、||、^、!）
注意：逻辑运算符的结果都是boolean类型的值

7.三目运算符
注意：语法结构、返回值规则

8.位运算符（&、|、^、<<、>>、>>>）

9.运算符的优先级别（不用记，灵活运用小括号）

作业：
1.知识点的梳理文档 – Day03.md
2.代码至少3遍
3.课后作业
4.复习：标识符、关键字、变量、基本数据类型及转型
5.预习：分支语句（if、switc）、循环语句（for）