Java.Day02

最新推荐文章于 2022-12-07 14:01:13 发布

胥某

最新推荐文章于 2022-12-07 14:01:13 发布

阅读量203

点赞数 1

分类专栏： Java 文章标签： Java.Day03

本文链接：https://blog.csdn.net/weixin_45958862/article/details/103391018

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

所学知识点与代码

运算符

赋值运算符

/*	
	赋值运算符
*/
public class OperatorDemo {
	public static void main(String[] args) {
		//把10赋值给int类型的变量i
		int i = 10;
		System.out.println("i:" + i);
		
		// += 把左边和右边的数据做加法操作，结果赋值给左边
		i += 20;
		//i = i + 20;
		System.out.println("i:" + i);
		
		//注意：扩展的赋值运算符底层隐含了强制类型转换
		short s = 10;
		s += 20;
		//s = (short)(s + 20);
		System.out.println("s:" + s);
	}
}

关系运算符

/*
	关系运算符
*/
public class OperatorDemo {
	public static void main(String[] args) {
		//定义变量
		int i = 10;
		int j = 20;
		int k = 10;
		
		//==
		System.out.println(i == j);
		System.out.println(i == k);
		System.out.println("--------");
		
		//!=
		System.out.println(i != j);
		System.out.println(i != k);
		System.out.println("--------");

		//>
		System.out.println(i > j);
		System.out.println(i > k);
		System.out.println("--------");
		
		//>=
		System.out.println(i >= j);
		System.out.println(i >= k);
		System.out.println("--------");
		
		//不小心把==写成了=
		//把j的值赋值给了i，然后输出i的值
		System.out.println(i = j);
	}
}

逻辑运算符

/*
	逻辑运算符
*/
public class OperatorDemo01 {
	public static void main(String[] args) {
		//定义变量
		int i = 10;
		int j = 20;
		int k = 30;
		
		//& 有false则false
		System.out.println((i > j) & (i > k)); //false & false
		System.out.println((i < j) & (i > k)); //true & false
		System.out.println((i > j) & (i < k)); //false & true
		System.out.println((i < j) & (i < k)); //true & true
		System.out.println("--------");
		
		//| 有true则true
		System.out.println((i > j) | (i > k)); //false | false
		System.out.println((i < j) | (i > k)); //true | false
		System.out.println((i > j) | (i < k)); //false | true
		System.out.println((i < j) | (i < k)); //true | true
		System.out.println("--------");
		
		//^ 相同为false，不同为true
		System.out.println((i > j) ^ (i > k)); //false ^ false
		System.out.println((i < j) ^ (i > k)); //true ^ false
		System.out.println((i > j) ^ (i < k)); //false ^ true
		System.out.println((i < j) ^ (i < k)); //true ^ true
		System.out.println("--------");
		
		//!
		System.out.println((i > j)); //false
		System.out.println(!(i > j)); //!false
		System.out.println(!!(i > j)); //!!false
		System.out.println(!!!(i > j)); //!!!false
	}
}

/*
	短路逻辑运算符
*/
public class OperatorDemo02 {
	public static void main(String[] args) {
		//定义变量
		int i = 10;
		int j = 20;
		int k = 30;
		
		//&& 有false则false
		System.out.println((i > j) && (i > k)); //false && false
		System.out.println((i < j) && (i > k)); //true && false
		System.out.println((i > j) && (i < k)); //false && true
		System.out.println((i < j) && (i < k)); //true && true
		System.out.println("--------");
		
		//|| 有true则true
		System.out.println((i > j) || (i > k)); //false || false
		System.out.println((i < j) || (i > k)); //true || false
		System.out.println((i > j) || (i < k)); //false || true
		System.out.println((i < j) || (i < k)); //true || true
		System.out.println("--------");
		
		//&&和&
		//System.out.println((i++ > 100) & (j++ > 100)); //false & false
		System.out.println((i++ > 100) && (j++ > 100)); //false && false
		System.out.println("i:" + i);
		System.out.println("j:" + j);	
	}
}

三元运算符

/*
	三元运算符
	
	格式：
		关系表达式 ? 表达式1 : 表达式2;

	范例：
		a > b ? a : b;
	
	执行流程：
		首先计算关系表达式的值
		如果值为true，表达式1的值就是运算结果
		如果值为false，表达式2的值就是运算结果
*/
public class OperatorDemo {
	public static void main(String[] args) {
		//定义两个变量
		int a = 10;
		int b = 20;
		
		//获取两个数据中的较大值
		int max = a > b ? a : b;
		
		//输出结果
		System.out.println("max:" + max);
	}
}

/*
	两只老虎
	
	需求：
		动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，
		请用程序实现判断两只老虎的体重是否相同。
*/
public class OperatorTest01 {
	public static void main(String[] args) {
		//1：定义两个变量用于保存老虎的体重，单位为kg，这里仅仅体现数值即可。
		int weight1 = 180;
		int weight2 = 200;
		
		//2：用三元运算符实现老虎体重的判断，体重相同，返回true，否则，返回false。
		boolean b = weight1 == weight2 ? true : false;
		
		//3：输出结果
		System.out.println("b:" + b);
	}
}

/*
	三个和尚
	
	需求：
		一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，
		请用程序实现获取这三个和尚的最高身高。
*/
public class OperatorTest02 {
	public static void main(String[] args) {
		//1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
		int height1 = 150;
		int height2 = 210;
		int height3 = 165;
		
		//2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
		int tempHeight = height1 > height2 ? height1 : height2;
		
		//3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
		int maxHeight = tempHeight > height3 ? tempHeight : height3;
		
		//4：输出结果
		System.out.println("maxHeight:" + maxHeight);
	}
}

算术运算符

/*
	算术运算符
*/
public class OperatorDemo01 {
	public static void main(String[] args) {
		//定义两个变量
		int a = 6;
		int b = 4;
		
		System.out.println(a + b);
		System.out.println(a - b);
		System.out.println(a * b);
		System.out.println(a / b);
		System.out.println(a % b);
		//除法得到的是商，取余得到是余数
		
		//整数相除只能得到整数，要想得到小数，必须有浮点数的参与
		System.out.println(6.0 / 4);
	}
}

/*
	字符的"+"操作
*/
public class OperatorDemo02 {
	public static void main(String[] args) {
		//定义两个变量
		int i = 10;
		char c = 'A'; //'A'的值是65
		c = 'a'; //'a'的值是97
		c = '0'; //'0'的值是48
		System.out.println(i + c);
		
		//char ch = i + c;
		//char类型会被自动提升为int类型
		int j = i + c;
		System.out.println(j);
		
		//int k = 10 + 13.14;
		double d = 10 + 13.14;
	}
}

/*
	字符串的"+"操作
*/
public class OperatorDemo03 {
	public static void main(String[] args) {
		System.out.println("it" + "heima");
		System.out.println("itheima" + 666);
		System.out.println(666 + "itheima");
		
		System.out.println("黑马" + 6 + 66);
		System.out.println(1 + 99 + "年黑马");
	}
}

自增自减运算符

/*	
	自增自减运算符
*/
public class OperatorDemo {
	public static void main(String[] args) {
		//定义变量
		int i = 10;
		System.out.println("i:" + i);
		
		//单独使用
		//i++;
		//++i;
		//System.out.println("i:" + i);
		
		//参与操作使用
		//int j = i++;
		int j = ++i;
		System.out.println("i:" + i);
		System.out.println("j:" + j);
	}
}

数据输入

/*
	数据输入：
		导包：
			import java.util.Scanner;
		创建对象：
			Scanner sc = new Scanner(System.in);
		接收数据：
			int x = sc.nextInt();
*/
import java.util.Scanner;

public class ScannerDemo {
	public static void main(String[] args) {
		//创建对象
		Scanner sc = new Scanner(System.in);
		
		//接收数据
		int x = sc.nextInt();
		
		//输出数据
		System.out.println("x:" + x);
	}
}

/*
	三个和尚
	
	需求：
		一座寺庙里住着三个和尚，他们的身高必须经过测量得出，请用程序实现获取这三个和尚的最高身高。
*/
import java.util.Scanner;

public class ScannerTest {
	public static void main(String[] args) {
		//身高未知，采用键盘录入实现。首先导包，然后创建对象。
		Scanner sc = new Scanner(System.in);
		
		//键盘录入三个身高分别赋值给三个变量。
		System.out.println("请输入第一个和尚的身高：");
		int height1 = sc.nextInt();
		
		System.out.println("请输入第二个和尚的身高：");
		int height2 = sc.nextInt();
		
		System.out.println("请输入第三个和尚的身高：");
		int height3 = sc.nextInt();
		
		//用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
		int tempHeight = height1 > height2 ? height1 : height2;
		
		//用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
		int maxHeight = tempHeight > height3 ? tempHeight : height3;
		
		//输出结果。
		System.out.println("这三个和尚中身高最高的是：" + maxHeight +"cm");
	}
}

分支语句

if语句

/*
	if语句格式1

	格式：
		if (关系表达式) {
			语句体;	
		}
	
	执行流程：
		1:首先计算关系表达式的值
		2:如果关系表达式的值为true就执行语句体
		3:如果关系表达式的值为false就不执行语句体
		4:继续执行后面的语句内容
*/
public class IfDemo {
	public static void main(String[] args) {
		System.out.println("开始");
		
		//定义两个变量
		int a = 10;
		int b = 20;
		
		//需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
		if(a == b) {
			System.out.println("a等于b");
		}
		
		//需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
		int c = 10;
		if(a == c) {
			System.out.println("a等于c");
		}
		
		System.out.println("结束");
	}
}

/*
	if语句格式2

	格式：
		if (关系表达式) {
			语句体1;	
		} else {
			语句体2;	
		}
	
	执行流程：
		1:首先计算关系表达式的值
		2:如果关系表达式的值为true就执行语句体1
		3:如果关系表达式的值为false就执行语句体2
		4:继续执行后面的语句内容
*/
public class IfDemo02 {
	public static void main(String[] args) {
		System.out.println("开始");
		
		//定义两个变量
		int a = 10;
		int b = 20;
		b = 5;
		
		//需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，如果不是，在控制台输出：a的值不大于b
		if(a > b) {
			System.out.println("a的值大于b");
		} else {
			System.out.println("a的值不大于b");
		}
		
		System.out.println("结束");
	}
}

/*
	if语句格式3

	格式：
		if (关系表达式1) {
			语句体1;	
		} else if (关系表达式2) {
			语句体2;	
		} 
		…
		else {
			语句体n+1;
		}

	
	执行流程：
		1:首先计算关系表达式1的值
		2:如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
		3:如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
		4:…
		5:如果没有任何关系表达式为true，就执行语句体n+1。
*/

import java.util.Scanner;

public class IfDemo03 {
	public static void main(String[] args) {
		System.out.println("开始");
		
		//需求：键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入一个星期数(1-7)：");
		int week = sc.nextInt();
		
		if(week == 1) {
			System.out.println("星期一");
		} else if(week == 2) {
			System.out.println("星期二");
		} else if(week == 3) {
			System.out.println("星期三");
		} else if(week == 4) {
			System.out.println("星期四");
		} else if(week == 5) {
			System.out.println("星期五");
		} else if(week == 6) {
			System.out.println("星期六");
		} else {
			System.out.println("星期日");
		}
		
		System.out.println("结束");
	}
}

/*
	奇偶数
	
	需求：
		任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。
*/

import java.util.Scanner;

public class IfTest01 {
	public static void main(String[] args) {
		//为了体现任意给出一个整数，采用键盘录入一个数据。(导包，创建对象，接收数据)
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入一个整数：");
		int number = sc.nextInt();
		
		//判断整数是偶数还是奇数要分两种情况进行判断，使用if..else结构		
		//判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0
		//根据判定情况，在控制台输出对应的内容
		if(number%2 == 0) {
			System.out.println(number + "是偶数");
		} else {
			System.out.println(number + "是奇数");
		}
		
	}
}

/*
	考试奖励
	
	需求：
		小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分，
		请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
		
	奖励：
		95~100		山地自行车一辆
		90~94		游乐场玩一次
		80~89		变形金刚玩具一个
		80以下		胖揍一顿
*/

import java.util.Scanner;

public class IfTest02 {
	public static void main(String[] args) {
		//小明的考试成绩未知，可以使用键盘录入的方式获取值
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入一个分数：");
		int score = sc.nextInt();
		
		//由于奖励种类较多，属于多种判断，采用if...else...if格式实现
		//为每种判断设置对应的条件
		//为每种判断设置对应的奖励
		/*
		if(score>=95 && score<=100) {
			System.out.println("山地自行车一辆");
		} else if(score>=90 && score<=94) {
			System.out.println("游乐场玩一次");
		} else if(score>=80 && score<=89) {
			System.out.println("变形金刚玩具一个");
		} else {
			System.out.println("胖揍一顿");
		}
		*/
		
		//数据测试：正确数据，边界数据，错误数据
		if(score>100 || score<0) {
			System.out.println("你输入的分数有误");
		} else if(score>=95 && score<=100) {
			System.out.println("山地自行车一辆");
		} else if(score>=90 && score<=94) {
			System.out.println("游乐场玩一次");
		} else if(score>=80 && score<=89) {
			System.out.println("变形金刚玩具一个");
		} else {
			System.out.println("胖揍一顿");
		}
	}
}

顺序结构

/*
	顺序结构
*/
public class OrderDemo {
	public static void main(String[] args) {
		System.out.println("开始");
		
		System.out.println("语句A");
		System.out.println("语句B");
		System.out.println("语句C");
		
		System.out.println("结束");
	}
}