java基本语法_用java写嫁女儿的公式-CSDN博客

本文链接：https://blog.csdn.net/m0_49721664/article/details/120742564

java基本语法

分支结构
- if-else结构
- switch-case结构
循环结构
关键字和保留字
标识符
变量
自动/强制类型提升运算（变量运算规则）
String(字符串类型)
进制转换
运算符的使用
特殊关键字的使用

分支结构

if-else结构

在这里插入图片描述

/*
如何从键盘中获取不同类型的变量：需要使用Scanner这个类

具体实现步骤：
1.导包：import java,util.Scanner;
2.Scanner的实例化:Scanner scan = new.Scanner(System.in);
3.调用Scanner类的相关方法(next()/nextXxx())，来获取指定类的变量


注意:
需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchExcepetion
导致程序终止。


*/

import java.util.Scanner;

class ScannerTest{
	public static void main(String[] args) {
		//scanner的实例化
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入您的姓名：");
		String name = scan.next(); 
		System.out.println(name);
	
		System.out.println("请输入您的年龄：");
		int age = scan.nextInt();
		System.out.println(age);

		System.out.println("请输入您的体重：");
		double weight = scan.nextDouble();
		System.out.println(weight);

		System.out.println("你是不是人(true/false)：");
		boolean isHuman = scan.nextBoolean();
		System.out.println(isHuman);

		//对于char性的获取，Scanner没有提供相关的方法，只能获取一个字符串
		System.out.println("请输入您的性别(男/女)：");
		String gender = scan.next();
		char genderChar = gender.charAt(0);
		System.out.println(genderChar);
	}
}

RandomTest.java

/*
假设你想开发一个彩票游戏,程序随机产生一个两位数的彩票，提示用户输入一个两位数，然后按照一下的规则判定用户是否中奖
1.如果用户输入的数匹配带票的实际顺序，奖金10000
2.如果用户输入的数满足数字匹配彩票的所有数字，单数需不一样，奖金3000
3.如果用户输入的一个数字仅满足顺序情况匹配彩票的一个数字，奖金1000
4.如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500
5.如果用户输入的数字没有匹配彩票的任何一个数字，则彩票作废

提示：


*/


class RandomTest {
	public static void main(String[] args) {
		//如何获取一个随机数：10 ~ 99
		int value = (int)(Math.random() * 90 + 10);//Math.random()的范围[0.0,1.0) ---> [10.0,100.0) ---> [10,99]
		//公式：[a,b]  : (int)(Math.random() * (b - a + 1)) + a	
		
		System.out.println("彩票是：" + value);
	}
}

IfTest_3.java

/*
编写程序：有键盘输入三个整数分别存入变量num1,num2,num3
对他们进行排序(使用if-else if-else),并且从大到小输出.



*/

import java.util.Scanner;

class IfTest_3 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入三个整数：");
		int num1 = scan.nextInt();
		int num2 = scan.nextInt();
		int num3 = scan.nextInt();
		int temp;
		
		if(num1 > num2 && num1 > num3){

			if(num2 > num3){
			
			}else{
				temp = num3;
				num3 = num2;
				num2 = temp;
			}
		}else if(num2 > num1 && num2 > num3){
			temp = num2;
			num2 = num1;
			num1 = temp;
			if(num2 > num3){
				
			}else{
				temp = num3;
				num3 = num2;
				num2 = temp;
			}
		}else{
			temp = num3;
			num3 = num1;
			num1 = temp;
			if(num2 > num3){
				
			}else{
				temp = num3;
				num3 = num2;
				num2 = temp;
			}
		}
		
		System.out.println("这三个数从大到小排列分别是：" + num1 + " " + num2 + " " + num3);
	}
}

IfTest_2_video.java

/*
编写程序：有键盘输入三个整数分别存入变量num1,num2,num3
对他们进行排序(使用if-else if-else),并且从大到小输出.

说明：
1.if-else是可以嵌套的
2.如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略。不建议省略。


*/

import java.util.Scanner;

class IfTest_2_video{
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入三个整数：");
		int num1 = scan.nextInt();
		int num2 = scan.nextInt();
		int num3 = scan.nextInt();
		
		if(num1 >= num2){
			if(num3 > num1){
				System.out.println("这三个整数从大到小排分别是：" + num3 + " " + num1 + " " + num2);
			}else if(num3 > num2){
				System.out.println("这三个整数从大到小排分别是：" + num1 + " " + num3 + " " + num2);
			}else{
				System.out.println("这三个整数从大到小排分别是：" + num1 + " " + num2 + " " + num3);
			}
		}else{
			if(num3 > num2){
				System.out.println("这三个整数从大到小排分别是：" + num3 + " " + num2 + " " + num1);
			}else if(num3 > num1){
				System.out.println("这三个整数从大到小排分别是：" + num2 + " " + num3 + " " + num1);
			}else{
				System.out.println("这三个整数从大到小排分别是：" + num2 + " " + num1 + " " + num3);
			}
		}
	}
}

IfTest_2.java

/*
越小彭参加考试,他父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一台BMW
成绩为(80,99)时，奖励一个iphone 13
成绩是(60,79)时,奖励一个ipad 9
当成绩时其他时，什么奖励都没有
请从键盘输入越小彭的期末成绩，并加以判断

说明:
1.else 结构是可选的.
2.针对于条件表达式：
	如果多个条件表达式之间是“互斥”关系(或没有交集的关系)，哪个判断执行语句声明在上面还是下面，无所谓
	如果多个条件表达式之间有交集关系，需要根据实际情况，考虑清楚应将那个结构声明在上面。
	如果多个条件表达式之间又包含关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。

*/

import java.util.Scanner;

public class IfTest_2 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入越小彭的考试成绩(0-100)：");
		int score = scan.nextInt();

		if(score > 100 || score < 60){
			System.out.println("该成绩无奖励");
		}else if(score >= 80 && score < 100){
			System.out.println("奖励iphone13一台");
		}else if(score >= 60 && score < 80){
			System.out.println("奖励ipad9一台");
		}else{
			System.out.println("奖励BMW一辆");
		}
	}
}

IfTest.java

/*
分支结构中的if-else（条件判断结构）
1.三种结构
	1.
	if(条件表达式){
		执行语句
	}

	2.二选一
	if(条件表达式){
		执行语句1
	}else{
		执行语句2
	}
	
	3.多选一
	if(条件表达式){
		执行语句1
	}else if(条件表达式){
		执行语句2
	}
	........
	else{
		执行语句n
	}

*/

class IfTest {
	public static void main(String[] args) {
		
		//举例1
		int heartBeats = 75;
		if(heartBeats < 60 || heartBeats > 100){
			System.out.println("需要进一步检查");
		}
		
		System.out.println("检查结束");
		

		//举例2
		int age = 210;
		if(age < 18){
			System.out.println("不能玩王者.");

		}else{
			System.out.println("宁配吗？");
		}
		
		//举例3
		if(age < 0){
			System.out.println("您输入的数据非法");
		}else if(age < 18){
			System.out.println("青少年时期");
		}else if(age < 35){
			System.out.println("青壮年时期");
		}else if(age < 60){
			System.out.println("中年时期");
		}else if(age < 120){
			System.out.println("老年时期");
		}else{
			System.out.println("修仙时期");
		}
	}
}

IfExer.java

/*
女方家长要嫁女儿，当然要提出一定的条件：
高：180+  财产：1000W+  容貌：帅
1.如果同时满足三个条件：我一定要嫁给他
2.如果这三个条件有真的情况下：嫁吧，比上不足，比下有余
3.如果这三个条件都不满足：Fuck off



video:

String look = scannext();

if(tall >= 180 && wealth >= 100 && look.equals("是")){
	System.out.println("我一定要嫁给他。");
}else if(tall >= 180 || wealth >= 100 || look.equals("是")){
	System.out.println("嫁吧，比上不足，比下有余");
}else{
	System.out.println("Fuck off");
}

*/

import java.util.Scanner;

class IfExer {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入您的身高(cm):");
		int tall = scan.nextInt();

		System.out.println("请输入您的资产(W):");
		double wealth = scan.nextDouble();

		System.out.println("是否长得帅(ture/false):");
		boolean look = scan.nextBoolean();
		
		if(tall >= 180){
			if(wealth >= 1000){
				if(look){
					System.out.println("我一定要嫁给他.");
				}else{
					System.out.println("嫁吧，比上不足，比下有余.");
				}
			}else if(look){
				System.out.println("嫁吧，比上不足，比下有余.");
			}else{
				System.out.println("嫁吧，比上不足，比下有余.");
			}
		}else if(wealth >= 1000){
			if(look){
				System.out.println("嫁吧，比上不足，比下有余.");
			}else{
				System.out.println("嫁吧，比上不足，比下有余.");
			}
		}else{
			System.out.println("Fuck off!");
		}
	}
}

switch-case结构

在这里插入图片描述

/*
分支结构之二：switch-case

1.格式
switch(表达式){
case 常量1:
	执行语句1;
	break;//根据实际情况是否添加

case 常量2:
	执行语句2;
	break;

.......

default:
	执行语句n;
	break;
}

2.说明：
	1.根据switch表达式中的值，依次匹配各个case中的常量，一旦匹配成功，则进入相应的case结构中，调用起执行语句
	当调用完执行语句后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾为止结束
	
	2.break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
	
	3.switch结构中的表达式,只能是如下的6种数据类型之一：byte,short,char,int,枚举类型(JDK5.0新增),String类型(JDK7.0新增)

	4.case之后只能声明常量，不能声明范围。

	5.break关键字是可选的

	6.default相当于if-else中的else
		default结构是可选的，位置是灵活的
*/


class SwtichCaseTest{
	public static void main(String[] args) {
		
		int number = 1;
		switch(number){
			
		case 0:
			System.out.println("zero");
			break;
		case 1:
			System.out.println("one");
			break;
		case 2:
			System.out.println("two");
			break;
		default:
			System.out.println("other");
			break;
		}

		//################################################33
		
		//boolean isHandsome = true;

		//switch(isHandsome){
			//编译不通过switch()不支持boolean类型
			//case true:
			//	System.out.println("我好帅啊");
			//	break;
			//case false:
			//	System.out.println("我依然很帅");
			//	break;
			//default:
			//	System.out.println("还是帅");
			//	break;
		//}
	}
}

SwitchCaseExer4.java

/*
从键盘分别输入年，月，日，判断这一天是当年的第几天

注：判断那一年是否是闰年的标准：
	1.可以被4整除但不可以配100整除
	2.可以配400整除

说明：
1.凡是可以使用switch-case的结构,都可以转换为if-else，反之不成立
2.我们写分支结构时,当发现既可以使用switch-case,(同时，switch-case中表达式的取值情况不太多)
又可以使用if-else时，我们优先选择使用switch-case 原因:switch-case执行效率高

*/

import java.util.Scanner;

class SwitchCaseExer4 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入年份:");
		int year = scan.nextInt();
		System.out.println("请输入月份:");
		int month = scan.nextInt();
		System.out.println("请输入日期:");
		int day = scan.nextInt();

		int sumDays = 0;
		
		//if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
		//判断是否是闰年
		if(year % 4 == 0 && year % 100 != 0){
			switch(month){
				
				case 12:
					sumDays += 30;
				case 11:
					sumDays += 31;
				case 10:
					sumDays += 30;
				case 9:
					sumDays += 31;
				case 8:
					sumDays += 31;
				case 7:
					sumDays += 30;
				case 6:
					sumDays += 31;
				case 5:
					sumDays += 30;
				case 4:
					sumDays += 31;
				case 3:
					sumDays += 29;
				/*if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0){
					sumDays += 29;
				}else{
					sumDays += 28;
				}*/
				case 2:
					sumDays += 31;
				case 1:
					sumDays += day;
					System.out.println(year + "年，第" + month + "月，第" + day + "天是" + year + "的第" + sumDays + "天");
					break;
				default:
					System.out.println("火星来的？");
					break;
			}
		}else if(year % 400 == 0){
			switch(month){
				
				case 12:
					sumDays += 30;
				case 11:
					sumDays += 31;
				case 10:
					sumDays += 30;
				case 9:
					sumDays += 31;
				case 8:
					sumDays += 31;
				case 7:
					sumDays += 30;
				case 6:
					sumDays += 31;
				case 5:
					sumDays += 30;
				case 4:
					sumDays += 31;
				case 3:
					sumDays += 29;
				case 2:
					sumDays += 31;
				case 1:
					sumDays += day;
					System.out.println(year + "年，第" + month + "月，第" + day + "天是" + year + "的第" + sumDays + "天");
					break;
				default:
					System.out.println("火星来的？");
					break;
			}
		}else{
			switch(month){
				
				case 12:
					sumDays += 30;
				case 11:
					sumDays += 31;
				case 10:
					sumDays += 30;
				case 9:
					sumDays += 31;
				case 8:
					sumDays += 31;
				case 7:
					sumDays += 30;
				case 6:
					sumDays += 31;
				case 5:
					sumDays += 30;
				case 4:
					sumDays += 31;
				case 3:
					sumDays += 28;
				case 2:
					sumDays += 31;
				case 1:
					sumDays += day;
					System.out.println(year + "年，第" + month + "月，第" + day + "天是" + year + "的第" + sumDays + "天");
					break;
				default:
					System.out.println("火星来的？");
					break;
			}
		}
	}
}

SwitchCaseExer3.java

/*
编写程序：从键盘上输入2019年的"month"和"day",要求通过程序输入输出的日期为2019年的第几天

说明：switch-case中break是可选项
*/

import java.util.Scanner;

class SwitchCaseExer3 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入月份");
		int month = scan.nextInt();
		System.out.println("请输入日子");
		int day = scan.nextInt();

		//定义一个变量来保存总天数
		int sumDays = 0;
		
		//用if-else结构实现,不好用，太过冗余
		/*
		if(month == 1){
			sumDays = day;
			System.out.println("该日期为2019年的第" + sumDays + "天");
		}else if(month == 2){
			sumDays = 31 + day;
			System.out.println("该日期为2019年的第" + sumDays + "天");
		}else if(month == 3){
			sumDays = 28 + 31 + day;
			System.out.println("该日期为2019年的第" + sumDays + "天");
		}else if(month == 4){
			sumDays = 31 + 28 + 31 + day;
			System.out.println("该日期为2019年的第" + sumDays + "天");
		}else if(month == 5){
			sumDays = 30 + 31 + 28 + 31 + day;
			System.out.println("该日期为2019年的第" + sumDays + "天");
		}else if(month == 6){
			sumDays = 31 + 30 + 31 + 28 + 31 + day;
			System.out.println("该日期为2019年的第" + sumDays + "天");
		}else if(month == 7){
			sumDays = 30 + 31 + 30 + 31 + 28 + 31 + day;
			System.out.println("该日期为2019年的第" + sumDays + "天");
		}else if(month == 8){
			sumDays = 31 + 30 + 31 + 30 + 31 + 28 + 31 + day;
			System.out.println("该日期为2019年的第" + sumDays + "天");
		}else if(month == 9){
			sumDays = 31 + 31 + 30 + 31 + 30 + 31 + 28 + 31 + day;
			System.out.println("该日期为2019年的第" + sumDays + "天");
		}else if(month == 10){
			sumDays = 30 + 31 + 31 + 30 + 31 + 30 + 31 + 28 + 31 + day;
			System.out.println("该日期为2019年的第" + sumDays + "天");
		}else if(month == 11){
			sumDays = 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31 + 28 + 31 + day;
			System.out.println("该日期为2019年的第" + sumDays + "天");
		}else if(month == 12){
			sumDays = 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31 + 28 + 31 + day;
			System.out.println("该日期为2019年的第" + sumDays + "天");
		}else{
			System.out.println("火星来的？");
		}
		*/

		//用switch-case结构实现
		
		switch(month){
			
			case 12:
				sumDays += 30;
			case 11:
				sumDays += 31;
			case 10:
				sumDays += 30;
			case 9:
				sumDays += 31;
			case 8:
				sumDays += 31;
			case 7:
				sumDays += 30;
			case 6:
				sumDays += 31;
			case 5:
				sumDays += 30;
			case 4:
				sumDays += 31;
			case 3:
				sumDays += 28;
			case 2:
				sumDays += 31;
			case 1:
				sumDays += day;
				System.out.println("该日期是2019年的第" + sumDays + "天");
				break;
			default:
				System.out.println("火星来的？");
		}	
	}
}

SwitchCaseExer2.java

/*
根据用于指定月份，打印该月份所属的季节。
3,4,5为春季，6,7,8为夏季，9,10,11为秋季，12,1,2为冬季


*/

import java.util.Scanner;

class SwitchCaseExer2 {
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入月份：");

		int month = scan.nextInt();

		switch(month){
			
			case 3:
			case 4:
			case 5:
				System.out.println(month + "月为春季。");
				break;
			case 6:
			case 7:
			case 8:
				System.out.println(month + "月为夏季。");
				break;
			case 9:
			case 10:
			case 11:
				System.out.println(month + "月为秋季。");
				break;
			case 12:
			case 1:
			case 2:
				System.out.println(month + "月为冬季。");
				break;
			default:
				System.out.println("没有该月份。");
				break;
		}
	}
}

SwitchCaseExer1.java

/*
对学生成绩大于60分的,输出“合格”，低于60分的，输出“不合格”

说明：如果switch-case结构中的多个case的执行语句相同,则可以考虑合并
*/

import java.util.Scanner;

class SwitchCaseExer1 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入您的成绩：");

		int score = scan.nextInt();
		
		switch(score / 10){
			//除以60为更优解
			case 0:
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
				System.out.println("不合格");
				break;
			case 6:
			case 7:
			case 8:
			case 9:
			case 10:
				System.out.println("合格");
				break;
			default:
				System.out.println("该成绩无效");
				break;
		}
	}
}

SwitchCaseExer.java

/*
使用switch把小写类型的char型转为大写.只转换a,b,c,d,e.其他的输出"other"
提示:String word = scan.next(); char c = word.charAt(0); switch(c){}


*/

import java.util.Scanner;


class SwitchCaseExer {
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);
		
		//只转换a,b,c,d,e
		System.out.println("请输入你想转换的字母(小写)：");

		String word = scan.next();

		char c = word.charAt(0);//获取ascii索引

		switch(c){
		
		case 97:
			System.out.println("A");
			break;
		case 98:
			System.out.println("B");
			break;
		case 99:
			System.out.println("C");
			break;
		case 100:
			System.out.println("D");
			break;
		case 101:
			System.out.println("E");
			break;
		default:
			System.out.println("other");
			break;
		}
		
	}
}

循环结构

for循环

在这里插入图片描述

/*
for循环结构使用
1.循环结构的4个要素
	1.初始化条件
	2.循环条件 --->boolean类型
	3.循环体
	4.迭代条件

2.for循环的结构
for(1;2;3){
	4.
}

执行过程：1->2->3->4->2->3->4..........->2

*/

class ForTest {
	public static void main(String[] args){
		
		for(int i = 1;i <= 5;i++){
			
			System.out.println("hello world");

		}
		
		//i:在for循环内有效，出了for循环就失效了
		//System.out.println(i);

		//练习:
		int num = 1;
		for(System.out.print('a');num <= 3;System.out.print('c'),num++){
			System.out.print('b');
		}
		//输出结果：abcbcbc

		//例题：遍历100以内的偶数,输出所有偶数之和,偶数的个数
		int sum = 0;//记录偶数和
		int count = 0;//记录偶数个数
		for(int i = 1;i <= 100;i++){
			if(i % 2 == 0){
				System.out.println(i);
				sum += i;
				count++;
			}
		}
		System.out.println(sum);
		System.out.println(count);
	}
}

ForExer2.java

/*
输入两个正整数m,n求其最大公约数及最小公倍数
比如：12和20的最大公约数是4,最小公倍数是60
说明:break关键字

video:
获取两个数中的较小值
int min = (m <= n) ? m : n;

最小公倍数
int max = (m >= n) ? m : n;

for(int i = max;i <= m * n;i++){
	if(i % m == 0 && i % n == 0){
		System.out.println(i);
		break;
	}
}

*/

import java.util.Scanner;

class ForExer2 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入两个正整数");
		int m = scan.nextInt();
		int n = scan.nextInt();

		//找公约数
		if(m >= n){
			for(int i = n;i >= 1;i--){
				if(m % i == 0 && n % i == 0){
					System.out.println(m + "," + n + "的最大公约数是:" + i);
					System.out.println(m + "," + n + "的最小公倍数是:" + (m * n / i));//众所周知:m,n的最小公倍数 = m * n /最大公约数
					break;//跳出循环
				}
			}	
		}else{
			for(int i = m;i >= 1;i--){
				if(m % i == 0 && n % i == 0){
					System.out.println(m + "," + n + "的最大公约数是:" + i);
					System.out.println(m + "," + n + "的最小公倍数是:" + (m * n / i));//众所周知:m,n的最小公倍数 = m * n /最大公约数
					break;
				}
			}
		}		
	}
}

ForExer1.java

/*
输出所有水仙花数  指一个三位数，其各个位上的数字的立方和等于其本身
例如 153 = 1^3 + 5^3 + 3^3

*/

class ForExer1 {
	public static void main(String[] args) {
		for(int i = 100;i <= 999;i++){
			if((java.lang.Math.pow((i % 10),3) + java.lang.Math.pow((i / 100),3) + java.lang.Math.pow(((i / 10) % 10),3) == i)){
				System.out.println("水仙花数是：" + i);
			}
		}
	}
}

ForExer.java

/*
编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行数
上打印出foo在每个5的倍数行上打印biz在每个7的倍数行上打印输出baz

video:

for(int i = 1; i <= 150;i++){
	System.out.println(i + "  ");

	if(i % 3 == 0){
		System.out.print("foo");
	}

	if(i % 5 == 0){
		System.out.pring("biz");
	}

	if(i % 7 == 0){
		System.out.print("baz");
	}

	System.out.println();
}


*/


class ForExer {
	public static void main(String[] args) {
		for(int i = 1;i <= 150;i++){
			if(i % 3 == 0){
				if(i % 5 == 0){
					if(i % 7 == 0){
						System.out.println(i + " foo biz baz");
					}else{
						System.out.println(i + " foo biz");
					}
				}else if(i % 7 == 0){
					System.out.println(i + " foo baz");
				}else{
					System.out.println(i + " foo");
				}
			}else if(i % 5 == 0){
				if(i % 7 == 0){
					System.out.println(i + " biz baz");
				}else{
					System.out.println(i + " biz");
				}
			}else if(i % 7 == 0){
				System.out.println(i + " baz");
			}else{
				System.out.println(i);
			}
		}
	}
}

while循环

/*
while循环的使用

1.循环结构的4个要素
	1.初始化条件
	2.循环条件 --->boolean类型
	3.循环体
	4.迭代条件

2.while循环的结构

①
while(②){
	③;
	④;
}


*/


class WhileTest  {
	public static void main(String[] args) {
		//遍历100以内所有偶数
		int i = 1;
		while(i <= 100){
			if(i % 2 == 0){
				System.out.println(i);
				i++;				
			}
		}
	}
}

do-while循环

/*
1.循环结构的4个要素
	1.初始化条件
	2.循环条件 --->boolean类型
	3.循环体
	4.迭代条件

2.do-while循环结构:

①
do{
	③;
	④;

}while(②);

执行过程:① - ③ - ④ - ② - ③ - ④ - ②......

说明：
1.dowhile循环至少会执行一次循环体



*/

class  DoWhileTest{
	public static void main(String[] args) {
		//遍历100以内的偶数,并计算所有偶数的和和个数
		
		int i = 1;
		int sum = 0;
		int count = 0;
		
		do{
			if(i % 2 == 0){
				System.out.println(i);
				count++;
				sum += i;
			}
			i++;
		}while(i <= 100);

		System.out.println("偶数个数是" + count + ",偶数和是" + sum);
		//#####################################################
		


	}
}

嵌套循环

/*
遍历100以内所有质数
质数：只有1和本身的约数

对PrimeNumberTest.java文件质数输出问题的优化 方式2

*/

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

		int count = 0;//记录质数的个数

		//获取当前时间距离1970-01-01-00:00的一个毫秒数
		long start = System.currentTimeMillis();

		lable1:for(int i = 2;i <= 100000;i++){

			//优化二：对本身质数的自然数是有效的 优化后823ms
			for(int j = 2;j <= Math.sqrt(i);j++){
				if(i % j == 0){
					continue lable1;
				}
			}
			count++;//所花时间为105ms
		}
			//isFlag = true;
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为 " + count);
		System.out.println("所花费的时间为 " + (end - start));//15
		//System.out.println(start);
	}
}

PrimeNumberTestPro.java

/*
遍历100以内所有质数
质数：只有1和本身的约数

对PrimeNumberTest.java文件质数输出问题的优化 方式1

*/

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

		int count = 0;//记录质数的个数

		//获取当前时间距离1970-01-01-00:00的一个毫秒数
		long start = System.currentTimeMillis();

		for(int i = 2;i <= 100000;i++){
			boolean isFlag = true;//标识i是否被除尽，一旦除尽，修改值

			//优化二：对本身质数的自然数是有效的 优化后823ms
			for(int j = 2;j <= Math.sqrt(i);j++){
				if(i % j == 0){
					isFlag = false;
					//break;//优化1：只对本身是非质数的自然数是有效的
					//优化前：21851ms   +break 3338ms 
				}
			}
			if(isFlag){
				//System.out.println(i);
				count++;//所花时间为105ms
			}
			//isFlag = true;
		}
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为 " + count);
		System.out.println("所花费的时间为 " + (end - start));
		//System.out.println(start);
	}
}

PrimeNumberTest.java

/*
遍历100以内所有质数
质数：只有1和本身的约数

*/

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

		for(int i = 2;i <= 100;i++){
			boolean isFlag = true;//标识i是否被除尽，一旦除尽，修改值

			for(int j = 2;j < i;j++){
				if(i % j == 0){
					isFlag = false;
				}
			}
			if(isFlag){
				System.out.println(i);
			}
			//isFlag = true;
		}
	}
}

ForForTest.java

/*
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环

2.
外层循环：循环结构B
内层循环：循环结构A

3.说明
	内层循环遍历一边只相当于外层循环执行一次
	假设外层循环需要执行N次，内层循环需要执行M次。此时内层循环的循环体一共执行了M * N次

4.技巧
	外层循环控制行数，内层循环控制列数

*/


class  ForForTest{
	public static void main(String[] args) {
		
		//########################################
		//System.out.println("#########################");
		for(int i = 1;i < 20;i++){
			System.out.print("#");
		}
		System.out.println();

		/*
		#####
		#####
		#####
		#####
		*/
		for(int i = 1;i < 20;i++){
			for(int j = 1;j < 20;j++){
				System.out.print("# ");
			}
			System.out.println();
		}

		/*
		#
		##
		###
		####
		#####
		*/
		for(int i = 1;i <= 10;i++){//控制行数
			for(int j = i;j >= 1;j--){//控制列数
		  //for(int j = 1;j <= i;j++)
				System.out.print("# ");
			}
			System.out.println();
		}

		/*
		#####     i(行号)   j(#的个数) 规律：i + j = 5;j = 5 - i
		####       1		    4
		###		   2			3
		##		   3			2
		#		   4			1
		*/
		for(int i = 1;i <= 10;i++){
			for(int j = i;j <= 10;j++){
		  //for(int j = 1;j <= 5 - i;j++)
				System.out.print("# ");
			}
			System.out.println();
		}

		/*
				#
			   # #
			  # # #
			 # # # #
			# # # # #
			 # # # #
			  # # #
			   # #
			    #
		*/
		//上半部分
		for(int i = 1;i <= 10;i++){
			for(int j = 1;j <= 10 - i;j++){
				System.out.print(" ");
			}
			for(int k = 1;k <= i;k++){
				System.out.print("# ");
			}
			System.out.println();
		}
		//下半部分
		for(int i = 9;i <= 9 && i >= 0;i--){
			for(int j = 1;j <= 10 - i;j++){
				System.out.print(" ");
			}
			for(int k = 1;k <= i;k++){
				System.out.print("# ");
			}
			System.out.println();
		}
		//九九乘法表
		for(int i = 1;i <= 9;i++){
			for(int j = 1;j <= i;j++){
				System.out.print(j + " * " + i + " = " + i * j + "	");
			}
		System.out.println();
		}
	}
}

ForWhileExer.java

/*
从键盘读入个数不确定的整数,并判断读入的正数和负数的个数，输入为0时结束程序。

说明：
1.不在循环条件部分限制次数的结构：for(;;) 或 while(true)
2.结束循环有几种方式
	1.循环条件返回false
	2.在循环体中,执行break

*/

import java.util.Scanner;

class ForWhileExer {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		int positiveNumber = 0;//正数个数
		int negativeNumber = 0;//负数个数
		
		while(true){//for(;;)
			int number = scan.nextInt();
			//判断nmber的正负情况
			if(number > 0){
				positiveNumber++;
			}else if(number < 0){
				negativeNumber++;
			}else{
				break;
			}
		}
		
		System.out.println("输入正数的个数为 " + positiveNumber);
		System.out.println("输入负数的个数为 " + negativeNumber);
	}
}

关键字和保留字

关键字（keyword）
定义：被java语言赋予了特殊含义，用于专门用途的字符串（单词）。
特点：关键字中多有的字母都为小写的。

保留字（reverse word）
定义：现有Java版本尚未使用，但以后版本可能会作为关键字使用，自己命明标识符时要避免使用这些保留字。
goto、const

标识符

在这里插入图片描述

变量

在这里插入图片描述

/*
java定义的数据类型

1.变量按照数据类型来分：
	基本数据类型：
		整型：byte\short\long\int
		浮点型：float\double
		字符型：char
		布尔型：boolean
	
	应用数据类型：
		类：class
		接口：interface
		数组：array

2.变量在类中声明的位置：
	成员变量  局部变量
*/



class VariableTest_1 {
	public static void main(String[] args) {
		//1.整型：byte(1byte)\short(2byte)\int(4byte)\long(8byte)
		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 = 12345678L;
		System.out.println(l1);

		//2.浮点型：float(4byte)\double(8byte)
		double d1 = 123.3;
		System.out.println(d1 + 1);
		
		//定义float类型变量时末尾要以f或F结尾
		//通常定义浮点型变量用double
		float f1 = 12.3F;
		System.out.println(f1);

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

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

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

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

		boolean isMarried = false;
		if(isMarried){
			System.out.println("You can't join the single party.sorry about that.");
		}else{
			System.out.println("You can join\n the\\n single party.\"have fun\".");
		}
	}
}

VariableTest.java

/*
变量的使用
1.java定义变量的格式：数据类型 变量名 = 变量值；

2.说明：
	・变量必须先声明，后使用。
	・变量都定义在其作用域内。在作用域内，他是有效的。出了作用域也就失效了

3.同一个作用域内，不可以声明两个同名的变量

*/
class VariableTest {
	public static void main(String[] args) {
		//变量的定义
		int myAge = 21;
		//变量的使用
		System.out.println(myAge);

		//编译错误：使用myNumber之前未定义过myNumber
		//System.out.println(myNumber);
		
		//变量名的声明
		int myNumber;

		//编译错误:使用myNumber之前并未赋值过myNumber
		//System.out.println(myNumber);

		//变量的赋值
		myNumber = 190316023;

		//编译不通过
		//System.out.println(myClass)

		//不可以再同一个作用域内定义同名变量
		//int myAge = 20;
	}
	public void method(){
		int myClass = 1;
	}
}

自动/强制类型提升运算（变量运算规则）

VariableTest4.java

class VariableTest4 {
	public static void main(String[] args) {
		
	//1.编码情况：
	long l = 123213;
	System.out.println(l);

	//long l1 = 2983894294392438;编译失败，过大的整数，不加L/l 按int范围变量
	long l1 = 2983894294392438L;

	//##################################
	//编译失败
	//float f1 = 12.3;要加F/f

	//2.编码情况2：
	//整型常量默认类型是int型
	//浮点型常量,默认类型是double型
	byte b1 = 12;
	//byte b2 = b1 + 1;编译失败

	
	}
}

VariableTest3.java

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

*/


class VariableTest3 
{
	public static void main(String[] args) 
	{
		double d1 = 12.3;

		int i5 = (int)d1;//截断操作
		System.out.println(i5);

		long l1 = 123;
		short s2 = (short)l1;

		int i2 = 128;
		byte b1 = (byte)i2;
		System.out.println(b1);
	}
}

VariableTest2.java

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

前提：	这里只讨论七种数据变量之间的运算
		整型：byte\short\long\int
		浮点型：float\double
		字符型：char
		不包含布尔类型

1.自动类型提升：
	结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
	byte 、char 、short < int < long < float < double
	特殊情况：当byte 、char 、short三种类型的变量做运算是，结果为int型

说明：此时的容量大小指的是，表示数的范围的大和小，并不是数所占内存的大和小，比如：float容量要大于long的容量

2.强制类型提升：见variableTest3

*/


class  VariableTest2{
	public static void main(String[] args) {
		
		byte b1 = 2;
		int i1 = 12;
		
		//编译不通过
		//byte b2 = i1 + b1;

		int i2 = b1 + i1;
		System.out.println(i2);
		
		float f1 = b1 + i1;
		System.out.println(f1);

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

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

		short s2 = 10;
		//char s3 = c1 + s2;编译不通过
		
		byte b2 = 10;
		//char c3 = c1 + b2;编译不通过
	}
}

String(字符串类型)

在这里插入图片描述

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

*/

class StringTest {
    public static void main(String[] args) {
        
    String s1 = "hello world!";

    System.out.println(s1);
    
    String s2 = "a";
    String s3 = "";

    //char c = '';编译不通过char型变量引号内不得为空
    
    int i1 = 1001;
    String numberStr = "学号";
    String info = numberStr + i1;// + 为连接运算
    String info1 = info + true;

    System.out.println(info);
    System.out.println(info1);

    //#################################
    //练习1
    char c1 = 'a';//a = 97;A = 65
    int i2 = 10;
    String s4 = "hello";

    System.out.println(c1 + i2 + s4);//107hello
    System.out.println(c1 + s4 + i2);//ahello10
    System.out.println(c1 + (i2 + s4));//a10hello
    System.out.println((c1 + i2) + s4);//107hello
    System.out.println(s4 + i2 + c1);//hello10a

    //练习2
    //输出效果：* *
    
    char c2 = '*';
    String s5 = " ";

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

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

    //int i3 = s6;编译不通过
    //int i3 = (int)s6;编译不通过

    int i3 = Integer.parseInt(s6);
    System.out.println(i3);
    }
}

进制转换

在这里插入图片描述

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


*/

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);

	}
}

运算符的使用

在这里插入图片描述

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

*/


class SetValueTest{
	public static void main(String[] args) {
		//赋值符号
		int i1 = 10;
		int j1 = 10;

		int i2,j2;
		//连续赋值
		i2 = j2 = 10;

		int i3 = 10,j3 = 20;

		//##################################
		int num1 = 10;
		num1 += 2;
		System.out.println(num1);

		int num2 = 12;
		num2 %= 5;
		System.out.println(num2);

		short s1 = 10;
		s1 += 2;//不会改变变量本身的数据类型
		System.out.println(s1);

		//开发中，如果希望变量实现+2的操作，有几种方法 (前提：int num = 10)
		//方式1：num = num + 2;
		//方式2：num += 2;(推荐)

		//开发中，如果希望变量实现+1的操作，有几种方法 (前提：int num = 10)
		//方式1：num = num + 1;
		//方式2：num += 1;(推荐)
		//方式3：num++;++num

		//练习1；
		int i = 1;
		i *= 0.1;
		System.out.println(i);//0
		i++;
		System.out.println(i);//1

		//练习2
		int m = 2;
		int n = 3;
		n *= m++;
		System.out.println("m=" + m);//3
		System.out.println("n=" + n);//6

		//练习3
		int n1 = 10;
		n1 += (n1++) + (++n1);
		System.out.println(n1);//32
	}
}

SanYuanTest.java

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

3.凡是可以使用三元运算符的地方，都可以改写为if-else
*/


class SanYuanTest {
	public static void main(String[] args) {
		
		//获取两个整数的较大值
		int n = 10;
		int m = 20;
		int max= (m > n) ? m : n;

		System.out.println(max);

		//获取三个数的最大值

		int n1 = 30;
		int n2 = 20;
		int n3 = -10;

		int max1 = (n1 > n2) ? (n1 > n3) ? n1 : n3 : (n2 > n3) ? n2 : n3;
		System.out.println("max是 " + max1);

		//改写成if-else:
		if(m > n){
			System.out.println(m);
		}else{
			System.out.println(n);

		}

	}
}

LogicTest.java

/*
运算符之四：逻辑运算符

& && | || ! ^

说明：
1.逻辑运算符操作的都是boolean类型的变量
2.


*/


class LogicTest {
	public static void main(String[] args) {
		
		//区分&  &&
		//相同点1：&  && 的运算结果相同
		//相同点2：当符号左边是true时，二者都会执行符号右边的运算
		//不同点：当符号左边是false时，&继续执行符号右边的运算，&&则回停止符号右边的运算
		//开发中推荐使用&&

		boolean b1 = false;
		int num1 = 10;
		if(b1 & (num1++ > 0)){
			System.out.println("Now,I'm in BeiJing");
		}else{
			System.out.println("I'm not in BeiJing");
		}
		System.out.println("num1 = " + num1);



		boolean b2 = false;
		int num2 = 10;
		if(b2 && (num2++ > 0)){
			System.out.println("Now,I'm in BeiJing");
		}else{
			System.out.println("I'm not in BeiJing");
		}
		System.out.println("num2 = " + num2);



		// |  ||的区别
		//相同点1：|   ||的运算结果相同
		//相通电2：当符号左边为false时，二者都会执行符号右边的运算
		//不同点：当符号左边为true时，|继续执行符号右边的运算，||则停止符号右边的运算
		//开发中推荐使用||

		boolean b3 = false;
		int num3 = 10;
		if(b3 | (num3++ > 0)){
			System.out.println("我在北京");
		}else{
			System.out.println("我在芜湖");
		}
		System.out.println(num3);



		boolean b4 = true;
		int num4 = 10;
		if(b4 || (num4++ > 0)){
			System.out.println("我在北京");
		}else{
			System.out.println("我在芜湖");
		}
		System.out.println(num4);

	}
}

compareTest.java

/*
运算符之三：比较运算符
== != > < >= <= instanceof

结论：
1.比较运算符的结果是boolean类型
2.区分 == 和 =

*/


class compareTest {
	public static void main(String[] args) {
		int i = 10;
		int j = 20;

		System.out.println(i == j);//false
		System.out.println(i = j);//20
	}
}

BitTest.java

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


面试题：最高效的计算2 * 8?
2 << 3 或 8 << 1

*/

class  BitTest{
	public static void main(String[] args) {
		int i = 21;
		
		System.out.println("i << 2 = " + (i << 2));
		System.out.println("i << 3 = " + (i << 3));
		System.out.println("i << 26 = " + (i << 26));
		System.out.println("i << 27 = " + (i << 27));
	
		
		int m = 12;
		int n = 5;
		System.out.println("m & n :" + (m & n));
		System.out.println("m | n :" + (m | n));
		System.out.println("m ^ n :" + (m ^ n));
	
		//练习：交换两个变量的值
		//方法1：推荐使用
		int num1 = 10;
		int num2 = 30;
		int temp;

		temp = num1;
		num1 = num2;
		num2 = temp;

		System.out.println("num1 = " + num1 + ",num2 = " + num2);
		
		//方式2：
		//好处：不用定义临时变量
		//弊端：1.相加操作可能超出存储范围2.有局限性：只能适用于数值类型
		num1 = num1 + num2;
		num2 = num1 - num2;
		num1 -= num2;
		
		System.out.println("num1 = " + num1 + ",num2 = " + num2);

		//方式3：使用位运算符
		num1 = num1 ^ num2;
		num2 = num1 ^ num2;
		num1 = num1 ^ num2;

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



	}
}

AriTest.java

/*
运算符之一：算术运算符
+(正) -(负) +(加) -(减) * / % (前)++ (后)++ (前)-- (后)--




*/

class AriTest {
	public static void main(String[] args) {
		
		//除号：/
		int num1 = 12;
		int num2 = 5;
		int result1 = num1 / num2;
		System.out.println(result1);//2

		int result2 = num1 / num2 * num2;
		System.out.println(result2);//10

		double result3 = num1 / num2;
		System.out.println(result3);//2.0

		double result4 = num1 / num2 + 0.0;//2.0
		System.out.println(result4);

		double result5 = num1 / (num2 + 0.0);//2.4
		System.out.println(result5);
		
		double result6 = (double)num1 / num2;//2.4
		System.out.println(result6);

		//取余运算 %
		//结果与被取余的数的符号相同
		//开发中，经常使用%来判断能否被除尽的情况
		
		int m1 = 12;
		int n1 = 5;
		System.out.println("m1 % n1 = " + m1 % n1);

		int m2 = -12;
		int n2 = 5;
		System.out.println("m2 % n2 = " + m2 % n2);
		
		int m3 = 12;
		int n3 = -5;
		System.out.println("m3 % n3 = " + m3 % n3);
		int m4 = -12;
		int n4 = -5;
		System.out.println("m4 % n4 = " + m4 % n4);

		//(前)++:先自增1，然后再运算
		//(后)++先运算，后自增1

		int a1 = 10;
		int b1 = ++a1;
		System.out.println("a1 = " + a1 + ",b1 = " + b1);

		int a2 = 10;
		int b2 = a2++;
		System.out.println("a2 = " + a2 + ",b2 = " + b2);
		
		//注意：
		short s1 = 10;
		//s1 = s1 + 1;错误
		//s1 = (short)(s1 + 1);正确
		s1++;//自增1不会改变本身变量的数据类型
		System.out.println(s1);
		
		//问题：
		byte bb1 = 127;
		bb1++;
		System.out.println(bb1);

		//(前)--先自减1，在运算
		//(后)--先运算，在自减1

	}
}

AriExer.java

/*
练习：随意给出一个三位数的整数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：

例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1


*/

class AriExer {
	public static void main(String[] args) {
		
		int num1 = 187;
		int ge = num1 % 10;
		int shi = num1 % 100 / 10;
		int bai = num1 / 100;

		System.out.println("数字" + num1 + "的情况如下\n" + "个位数：" + ge + "\n十位数：" + shi + "\n百位数：" + bai);




	}
}

特殊关键字的使用

BreakContinueTest.java

/*
break和continue关键字的使用
			使用范围			循环中使用的作用(不同点)		相同点
			switch-case
break:		循环结构中			结束当前循环					关键字后面不能申明执行语句

continue:   循环结构中			结束档次循环


*/



class BreakContinueTest {
	public static void main(String[] args) {
		
		for(int i = 1;i < 10;i++){
			if(i % 4 == 0){
				break;//1 2 3
			}
			System.out.println(i);
		}

		for(int i = 1;i < 10;i++){
			if(i % 4 == 0){
				continue;//1 2 3 5 6 7 9
			}
			System.out.println(i);
		}
		System.out.println();

		//###################################################
		
		lable1:for(int i = 1;i <= 4;i++){
			for(int j = 1;j <= 10;j++){
				if(j % 4 == 0){
					break lable1;//结束指定标识的一层循环结构
					//break/continue默认跳出包裹此关键字最近的一次循环
				}
			System.out.print(j);
			}
		System.out.println();
		}

		System.out.println();

		lable2:for(int i = 1;i <= 4;i++){
			for(int j = 1;j <= 10;j++){
				if(j % 4 == 0){
					continue lable2;
				}
			System.out.print(j);
			}
		System.out.println();
		}
	}
}