打怪升级之小白的大数据之旅＜Java基础知识点巩固习题＞

最新推荐文章于 2022-01-12 14:35:54 发布

GaryLea

最新推荐文章于 2022-01-12 14:35:54 发布

阅读量1.1k

点赞数 1

文章标签： java 大数据编程语言

本文链接：https://blog.csdn.net/Li_G_yuan/article/details/115518665

版权

我整理一下最近学习的知识点相关的练习题及答案,希望可以帮到大家对所学的知识点进行查漏补缺(尽量先不看答案)

Java基础语法相关练习集

Java基本程序相关题集

第一题

按步骤编写代码，效果如图所示：
编写步骤：

定义类 Test1
定义 main方法
控制台输出5行字符串类型常量值
控制台输出5行字符类型常量值

答案:

 class Test1{
        public static void main(String[] args){
            System.out.println("善学如春起之苗");
            System.out.println("不见其增，日有所长");
            System.out.println("假学如磨刀之石");
            System.out.println("不见其损，年有所亏");
            System.out.println("加油吧！少年");
            
            System.out.println("J");
            System.out.println("A");
            System.out.println("V");
            System.out.println("A");
            System.out.println("!");
        }
    }

第二题

按步骤编写代码，效果如图所示：
编写步骤：
1. 定义类 Test5
2. 定义 main方法
3. 定义2个 float类型变量,分别赋值,并输出在控制台.
4. 定义2个 double类型变量,分别赋值,并输出在控制台.
答案

public class Test2{
	public static void main(String[] args) {
		// 方法1 逐行打印
		float num1 = -3.14f, num2 = 3.14f;
		double num3 = -3.4, num4 = 3.4;
		System.out.println(num1);
		System.out.println(num2);
		System.out.println(num3);
		System.out.println(num4);
	}
}

第三题

按步骤编写代码，效果如图所示：
步骤图解：
开发提示：定义变量不赋值的格式
// 数据类型变量名；
int temp；
编写步骤：
1. 定义类 Test3
2. 定义 main方法
3. 定义两个整数变量a，b并赋值
4. 控制台输出变量a，b互换前的值
5. 定义一个第三方变量temp，使a，b的值互换
6. 控制台输出变量a，b互换后的值
答案

  public class Test3 {
    	public static void main(String[] args) {
    		int a = 10;
    		int b = 20;
    		System.out.println("互换前：");
    		System.out.println("a = " + a);
    		System.out.println("b = " + b);
    		
    		int temp = a;
    		a = b;
    		b = temp;
    		System.out.println("互换后：");
    		System.out.println("a = " + a);
    		System.out.println("b = " + b);
    	}
    
    }

第四题

按步骤编写代码，效果如图所示：
开发提示：四则运算的符号
加: +
减: -
乘: *
除: /
编写步骤：
1. 定义类 Test4
2. 定义 main方法
3. 定义2个int类型变量x、y，x赋值为100，y赋值为200
4. 定义新变量add，保存变量x，y的和并打印到控制台
5. 定义新变量sub，保存变量x，y的差并打印到控制台
6. 定义新变量mul，保存变量x，y的积并打印到控制台
7. 定义新变量div，保存变量x，y的商并打印到控制台

public class Test4 {
    	public static void main(String[] args) {
    		int x = 100;
    		int y = 200;
    		System.out.println("x,y的和为：" + (x+y));
    		System.out.println("x,y的差为：" + (x-y));
    		System.out.println("x,y的积为：" + (x*y));
    		System.out.println("x,y的商为：" + (x/y));
    	}
    
    }

第五题

按步骤编写代码，效果如图所示：
开发提示：观察小数类型数值运算后的结果.
小数运算经常出现精度丢失的问题,不建议使用基本类型运算.
编写步骤：
1. 定义类 Test5
2. 定义 main方法
3. 定义2个double类型变量x、y，x赋值为100.8，y赋值为20.6
4. 定义新变量add，保存变量x，y的和并打印到控制台
5. 定义新变量sub，保存变量x，y的差并打印到控制台
6. 定义新变量mul，保存变量x，y的积并打印到控制台
7. 定义新变量div，保存变量x，y的商并打印到控制台
提示：
1. 加法：+
2. 减法：-
3. 乘法：*
4. 除法：/
答案

 public class Test5 {
    
    	public static void main(String[] args) {
    		double x = 100.8;
    		double y = 20.6;
    		
    		double add = x + y;
    		System.out.println("x,y的和为：" + add);
    		
    		double sub = x - y;
    		System.out.println("x,y的差为：" + sub);
    		
    		double mul = x * y;
    		System.out.println("x,y的积为：" + mul);
    		
    		double div = x / y;
    		System.out.println("x,y的商为：" + div);
    	}
    
    }

简答题

1、如何用最有效的的方法计算2乘以8
答案: 2<<3

Java运算符&数据类型相关题集

第一题

按步骤编写代码，效果如图所示：
编写步骤：

定义类 Test1
定义 main方法
定义两个byte类型变量b1,b2,并分别赋值为10和20.
定义变量b3,保存b1和b2的和,并输出.
定义两个short类型变量s1,s2,并分别赋值为1000和2000.
定义变量s3,保存s1和s2的和,并输出.
定义一个char类型变量ch1赋值为’a’,一个int类型变量i1赋值为30.
定义变量ch3,保存c1和i1的差,并输出.

答案

    public class Test01 {
    	public static void main(String[] args) {
    		byte b1 = 10;
    		byte b2 = 20;
    		byte b3 = (byte)(b1 + b2);
    		System.out.println("byte类型的b1和b2的和为：");
    		System.out.println(b3);
    		
    		short s1 = 1000;
    		short s2 = 2000;
    		short s3 = (short)(s1 + s2);
    		System.out.println("short类型的s1和s2的和为：");
    		System.out.println(s3);
    		
    		char c1 = 'a';
    		int i1 = 30;
    		int ch3 = c1 - i1;
    		System.out.println("char类型的ch1和int类型的i1的差：");
    		System.out.println(ch3);
    	}
    }

第二题

按步骤编写代码，效果如图所示：
编写步骤：
1. 定义类 Test2
2. 定义 main方法
3. 定义 int类型变量i1 和 long类型变量l1
4. 定义变量add,保存i1和l1的和,并输出.
5. 定义 long类型变量l2 和 float类型变量f2
6. 定义变量add2,保存l2和f2的和,并输出.
7. 定义 int类型变量i3 和 double类型变量d3
8. 定义变量add3,保存i3和d3的和,并输出.
9. 定义 float类型变量f4 和 double类型变量d4
10. 定义变量add4,保存f4和d4的和,并输出.
答案

 public class Test2 {
    	public static void main(String[] args) {
    		int i1 = 100;
    		long l1 = 200;
    		long add = i1 + l1;
    		System.out.println("add的值：" + add);
    		
    		long l2 = 1000000L;
    		float f2 = 0.44F;
    		float add2 = l2 + f2;
    		System.out.println("add2的值：" + add2);
    		
    		int i3 = 100000;
    		double d3 = 0.45;
    		double add3 = i3 + d3;
    		System.out.println("add3的值：" + add3);
    		
    		float f4 = 1000000;
    		double d4 = 1.2625;
    		double add4 = f4 + d4;
    		System.out.println("add4的值：" + add4);
    	}
    }

第三题

按步骤编写代码，效果如图所示：
编写步骤：
1. 定义类 Test3
2. 定义 main方法
3. 定义char类型变量ch,赋值为’J’
4. 使用强制转换的方式,将变量ch转换为小写’j’,并输出
5. 定义char类型变量ch2,赋值为’a’
6. 使用+=的方式,将变量ch2转换为大写’A’,并输出
7. 定义double类型变量d3,int类型变量i3
8. 定义double变量sum3,保存d3与i3的和,输出sum3的值和sum3去除小数部分的值
9. 定义double类型变量d4,int类型变量i4
10. 定义int变量mul4,保存d4和i4乘积的整数部分,并输出
答案

 public class Test03 {
    
    	public static void main(String[] args){
    		char ch = 'J';
    		char ch1 = (char)(ch + 32);
    		System.out.println(ch1);
    		
    		char ch2 = 'a';
    		ch2 -= 32;
    		System.out.println(ch2);
    		
    		double d3 = 100.5;
    		int i3 = 3;
    		double sum3 = d3 + i3;
    		int sum4 = (int)sum3;
    		System.out.println("sum3的值：" + sum3);
    		System.out.println("sum3的整数部分的值：" + sum4);
    		
    		double d4 = 4.0;
    		int i4 = 435;
    		int mul4 = (int)(d4 * i4);
    		System.out.println("mul4的整数部分的值：" + mul4);
    	}
    
    }

第四题

按步骤编写代码，效果如图所示：
编写步骤：
1. 定义类 Test4
2. 定义 main方法
3. 定义两个int类型变量a1和a2,分别赋值10,11,判断变量是否为偶数,拼接输出结果
4. 定义两个int类型变量a3和a4,分别赋值12,13,判断变量是否为奇数,拼接输出结果
答案

public class Test04 {
    	public static void main(String[] args) {
    		int a1 = 10;
    		int a2 = 11;
    		int a3 = 12;
    		int a4 = 13;
    		System.out.println("10是偶数？" + (a1 % 2 == 0));
    		System.out.println("11是偶数？" + (a2 % 2 == 0));
    		System.out.println("12是奇数？" + (a3 % 2 != 0));
    		System.out.println("13是奇数？" + (a4 % 2 != 0));
    	}
    }

第五题

按步骤编写代码，效果如图所示：
编写步骤：
1. 定义类 Test5
2. 定义 main方法
3. 定义一个int类型变量a,变量b,都赋值为20.
4. 定义boolean类型变量bo , 判断++a 是否被3整除,并且a++ 是否被7整除,将结果赋值给bo
5. 输出a的值,bo的值.
6. 定义boolean类型变量bo2 , 判断b++ 是否被3整除,并且++b 是否被7整除,将结果赋值给bo2
7. 输出b的值,bo2的值.
答案

  public class Test05 {
    	public static void main(String[] args){
    		int a = 20;
    		int b = 20;
    		boolean bo = ((++a % 3) == 0) && ((a++ % 7) == 0);
    		boolean bo2 = ((b++ % 3) == 0) && ((++b % 7) == 0);
    		
    		System.out.println("bo的值：" + bo);
    		System.out.println("a的值：" + a);
    		System.out.println("----------------------------");
    		System.out.println("bo2的值：" + bo2);
    		System.out.println("b的值：" + b);
    	}
    }

第六题

案例：为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？

按步骤编写代码，效果如图所示：
编写步骤：
1. 定义类Test6
2. 定义main方法
3. 定义一个int类型变量hours，赋值为89
4. 定义一个int类型变量day，用来保存89小时中天数的结果
5. 定义一个int类型变量hour，用来保存89小时中不够一天的剩余小时数的结果
6. 输出结果
答案

 public class Test06 {
    	public static void main(String[] args){
    		int hours = 89;
    		int day = hours / 24;
    		int hour = hours % 24;
    		System.out.println("为抵抗洪水，战士连续作战89小时：");
    		System.out.println(hours + "是" + day + "天" + hour +"小时");
    	}
    }

第七题

案例：今天是周2，100天以后是周几？

按步骤编写代码，效果如图所示：
编写步骤：
1. 定义类Test7
2. 定义main方法
3. 定义一个int类型变量week，赋值为2
4. 修改week的值，在原值基础上加上100
5. 因为week的值加上100后超过了星期的范围，重写修改week的值
6. 输出结果，在输出结果的时候考虑特殊值，例如周日
答案

public class Test07 {
    
    	public static void main(String[] args){
    		int week = 2;
    		week += 100;
    		week %= 7;
    		System.out.println("今天是周2,100天以后是周" + (week==0?"日":week));
    	}
    
    }

第八题

案例：求三个整数x,y,z中的最大值

按步骤编写代码，效果如图所示：
编写步骤：
1. 定义类Test8
2. 定义main方法
3. 定义三个int类型变量,x,y,z，随意赋值整数值
4. 定义一个int类型变量max，先存储x与y中的最大值（使用三元运算符）
5. 再次对max赋值，让它等于上面max与z中的最大值（使用三元运算符）
6. 输出结果
答案

public class Test08 {
    	public static void main(String[] args) {
    		int x = 3;
    		int y = 4;
    		int z = 1;
    		int max = x > y ? x : y;
    		max = max > z ? max : z;
    		System.out.println(x + "," + y + "," + z + "中的最大值是：" + max);
    	}
    }

第九题

案例：给定一个年份，判断是否是闰年

闰年的判断标准是：

   1）可以被4整除，但不可被100整除

   2）可以被400整除

按步骤编写代码，效果如图所示：
编写步骤：
1. 定义类Test9
2. 定义main方法
3. 定义一个int类型变量year，随意赋值一个年份
4. 定一个一个boolean类型变量，用来保存这个年份是否是闰年的结果
5. 输出结果
答案

 public class Test09 {
    
    	public static void main(String[] args) {
    		int year = 2018;
    		boolean result = year%4==0 && year%100!=0 || year%400==0;
    		System.out.println(year + (result ? "是闰年" : "不是闰年"));
    	}
    
    }

第十题

案例：小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。它需要一个程序将华氏温度（80度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。

按步骤编写代码，效果如图所示：
编写步骤：
1. 定义类Test10
2. 定义main方法
3. 定义一个double类型变量hua，存储华氏温度80
4. 定义一个double类型变量she，存储摄氏温度，根据公式求值
5. 输出结果
答案

 public class Test10 {
    	public static void main(String[] args) {
    		double hua = 80;
    		double she = (hua-32)/1.8;
    		System.out.println("华氏度" + hua+"℉转为摄氏度是" +she+"℃");
    	}
    }

阅读代码题：

第一题

如下代码的计算结果是：

 int i = 1;
 i *= 0.2;  
 i++;
 System.out.println("i=" + i);
 答案: //i=1

第二题

如下代码的运算结果是：

int i = 2;
i *= i++;
    
int j = 2;
j *= j+1; 
    
int k = 2;
k *= ++k;
System.out.println("i=" + i);//答案: i=4
System.out.println("j=" + j);//答案: i=6
System.out.println("k=" + k);//答案: i=6

第三题

public static void main(String[] args) {
    		int a = 3;
    		int b = 1;
    		if(a = b){//答案: 编译报错
    			System.out.println("Equal");
    		}else{
    			System.out.println("Not Equal");
    		}
    	}

第四题

public static void main(String[] args) {
	int a= 8, b = 3;
	System.out.println(a>>>b);
	/*
	0000 1000
	0000 0001
	因此,答案是: 1*/ 
	System.out.println(a>>>b | 2);
	/*
	0000 0010
	0000 0011
	因此,答案是: 3*/
}

Java流程控制&循环相关题集

第1题：成绩及格

从键盘输入一个分数，如果60分（含）以上，就打印合格，如果60分以下，就打印不合格
答案

// 第一种方法
public class TestExer01{
	public static void main(String[] args){
		java.util.Scanner input = new java.util.Scanner(System.in);
		
		System.out.print("请输入成绩：");
		int score = input.nextInt();
		
        if(score >= 60){
            System.out.println("合格");
        }else{
            System.out.println("不合格");
        }
	}
}
// 第二种方法
public class TestExer01{
	public static void main(String[] args){
		java.util.Scanner input = new java.util.Scanner(System.in);
		
		System.out.print("请输入成绩：");
		int score = input.nextInt();
		
		System.out.println(score >= 60 ? "合格" : "不合格");
	}
}

第2题：成绩奖励

岳小鹏参加Java考试，他和父亲岳不群达成承诺：如果：
1. 成绩为100分时，奖励一辆BMW；
2. 成绩为(80，99]时，奖励一台iphone7plus；
3. 当成绩为[60,80]时，奖励一个 iPad；
4. 其它时，什么奖励也没有。
5. 请从键盘输入岳小鹏的期末成绩，并加以判断
答案:

// 第一种方法
public class TestExer2{
	public static void main(String[] args){
		java.util.Scanner input = new java.util.Scanner(System.in);
		System.out.print("请输入岳小鹏的成绩：");
		int score = input.nextInt();
		
        if(score<0 || score>100){
            System.out.println("你输入的成绩有误！");
        }else if(score == 100){
			System.out.println("奖励一辆BMW");
		}else if(score>80 && score<=99){
			System.out.println("奖励一台iphone7plus");
		}else if(score>=60 && score<=80){
			System.out.println("奖励一个 iPad");
		}else{
			System.out.println("继续努力，什么奖励也没有");
        }
	}
}
// 第二种方法
public class TestExer2{
	public static void main(String[] args){
		java.util.Scanner input = new java.util.Scanner(System.in);
		System.out.print("请输入岳小鹏的成绩：");
		int score = input.nextInt();
		
        if(score<0 || score>100){
            System.out.println("你输入的成绩有误！");
        }else if(score == 100){
			System.out.println("奖励一辆BMW");
		}else if(score>80){
			System.out.println("奖励一台iphone7plus");
		}else if(score>=60){
			System.out.println("奖励一个 iPad");
		}else{
			System.out.println("继续努力，什么奖励也没有");
        }
	}
}

第3题：三个数排序

编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else),并且从小到大输出
答案

// 第一种方法
public class TestExer3{
	public static void main(String[] args){
		//1、键盘输入三个整数
		java.util.Scanner input = new java.util.Scanner(System.in);
		
		System.out.print("请输入num1：");
		int num1 = input.nextInt();
		
		System.out.print("请输入num2：");
		int num2 = input.nextInt();
		
		System.out.print("请输入num3：");
		int num3 = input.nextInt();
		
		//2、判断
		/*
		三个数排序，6种情况
		num1 <= num2 <= num3
		num1 <= num3 <= num2
		
		num2 <= num1 <= num3
		num2 <= num3 <= num1
		
		num3 <= num2 <= num1
		num3 <= num1 <= num2
		*/
		if(num1<=num2 && num2<=num3){
			System.out.println(num1 + "<=" +  num2 + "<=" +  num3);
		}else if(num1<=num3 && num3<=num2){
			System.out.println(num1 + "<=" +  num3 + "<=" +  num2);
		}else if(num2<=num1 && num1<=num3){
			System.out.println(num2 + "<=" +  num1 + "<=" +  num3);
		}else if(num2<=num3 && num3<=num1){
			System.out.println(num2 + "<=" +  num3 + "<=" +  num1);
		}else if(num3<=num2 && num2<=num1){
			System.out.println(num3 + "<=" +  num2 + "<=" +  num1);
		}else{
			System.out.println(num3 + "<=" +  num1 + "<=" +  num2);
		}
		
	}
}
// 第二种方法
public class TestExer3{
	public static void main(String[] args){
		//1、键盘输入三个整数
		java.util.Scanner input = new java.util.Scanner(System.in);
		
		System.out.print("请输入num1：");
		int num1 = input.nextInt();
		
		System.out.print("请输入num2：");
		int num2 = input.nextInt();
		
		System.out.print("请输入num3：");
		int num3 = input.nextInt();
        
        //嵌套
		if(num1 <= num2){
			if(num2 <= num3){ //num1 <= num2 && num2 <= num3
				System.out.println(num1 + "<=" + num2 + "<=" + num3);
			}else{
				if(num1 <= num3){ //num1<=num2 && num3<num2 && num1<=num3
					System.out.println(num1 + "<=" + num3 + "<=" + num2);
				}else{
					//num1<=num2 && num3<num2 && num3<num1
					System.out.println(num3 + "<=" + num1 + "<=" + num2);
				}
			}
		}else{
			if(num3 >= num1){//num1 > num2 && num3 >= num1  //num3 >= num1 > num2
				System.out.println(num2 + "<=" + num1 + "<=" + num3);
			}else{
				if(num2 <= num3){//num1 > num2  && num1 > num3 && num2 <= num3
					System.out.println(num2 + "<=" + num3 + "<=" + num1);
				}else{
					//num1 > num2  && num1 > num3 && num3<num2
					System.out.println(num3 + "<=" + num2 + "<=" + num1);
				}
			}
		}
	}
}
// 第三种方法
/*
3、编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
对它们进行排序(使用 if-else if-else),并且从小到大输出。
*/
class Test07Exer3_2{
	public static void main(String[] args){
		//由键盘输入三个整数分别存入变量num1、num2、num3
		java.util.Scanner input = new java.util.Scanner(System.in);
		
		System.out.println("请连续输入要排序的三个整数：");
		int num1 = input.nextInt();
		int num2 = input.nextInt();
		int num3 = input.nextInt();
		
		System.out.println("三个整数原来的顺序：" + num1 + "，" + num2 + "，" + num3);
		
		//排序
		//方式二：交换法
		//最后想要输出的是num1 <= num2 <= num3
		//如果num1 > num2，交换num1和num2变量的值
		if(num1 > num2){
			int temp = num1;//将num1的值备份到temp中
			num1 = num2; //把num2的值放到num1中
			num2 = temp;//将之前备份的num1的值放到num2中			
		}
		
		//代码运行到这里   num1 <= num2
		
		//如果num2 > num3，交换num2和num3变量的值
		if(num2 > num3){
			int temp = num2;
			num2 = num3;
			num3 = temp;
		}
		//代码运行到这里   num2 <= num3
		
		/*
		num1 = 3;
		num2 = 2
		num3 = 1;
		
		经过第一个if(num1 > num2)判断   
		num1 = 2 
		num2 = 3
		num3 = 1
		
		经过第一个if(num2 > num3)判断   
		num1 = 2 
		num2 = 1
		num3 = 3		
		*/
		//因为经过第二个if(num2 > num3)判断之后，num2的值可能被改变了，重新判断num1和num2
		if(num1 > num2){
			int temp = num1;//将num1的值备份到temp中
			num1 = num2; //把num2的值放到num1中
			num2 = temp;//将之前备份的num1的值放到num2中
		}
		
		System.out.println("三个整数排序后：" + num1 + "，" + num2 + "，" + num3);
	}
}

第4题：相亲

大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：高：180cm以上；富：财富1千万以上；帅：是。
如果这三个条件同时满足，则：“我一定要嫁给他!!!”
如果三个条件中有为真的情况，则：“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则：“不嫁！”
提示：从键盘输入
Scanner input=new Scanner(System.in);
System.out.println(“身高:(cm)”);
input.nextInt();
System.out.println(“财富:(千万)”);
input.nextDouble();
System.out.println(“帅否:(true/false)”); (是/否)
input.nextBoolean(); 或者 input.next(); “是”.equals(str)
答案

// 第一种方法
public class TestExer4{
	public static void main(String[] args){
		//1、输入男方的条件
		java.util.Scanner input = new java.util.Scanner(System.in);
		
		System.out.print("请输入身高（单位：cm）：");
		int height = input.nextInt();
		
		System.out.print("请输入财富（单位：千万）：");
		double money  = input.nextDouble();
		
		System.out.print("请输入是否帅（true/false）：");
		boolean handsom = input.nextBoolean();
		
		//2、判断
		/*
		高：180cm以上；富：财富1千万以上；帅：是。
		如果这三个条件同时满足，则：“我一定要嫁给他!!!”
		如果三个条件中有为真的情况，则：“嫁吧，比上不足，比下有余。”
		如果三个条件都不满足，则：“不嫁！”
		*/
		//if(height>=180 && money>=1 && handsom==true){
		if(height>=180 && money>=1 && handsom){	
			System.out.println("我一定要嫁给他!!!");
		}else if(height>=180 || money>=1 || handsom){
			System.out.println("嫁吧，比上不足，比下有余。");
		}else{
			System.out.println("不嫁！");
		}
	}
}
// 第二种方法
public class TestExer4_2{
	public static void main(String[] args){
		//1、输入男方的条件
		java.util.Scanner input = new java.util.Scanner(System.in);
		
		System.out.print("请输入身高（单位：cm）：");
		int height = input.nextInt();
		
		System.out.print("请输入财富（单位：千万）：");
		double money  = input.nextDouble();
		
		System.out.print("请输入是否帅（是/否）：");
		char handsom = input.next().charAt(0);
		
		//2、判断
		/*
		高：180cm以上；富：财富1千万以上；帅：是。
		如果这三个条件同时满足，则：“我一定要嫁给他!!!”
		如果三个条件中有为真的情况，则：“嫁吧，比上不足，比下有余。”
		如果三个条件都不满足，则：“不嫁！”
		*/
		if(height>=180 && money>=1 && handsom=='是'){	
			System.out.println("我一定要嫁给他!!!");
		}else if(height>=180 || money>=1 || handsom=='是'){
			System.out.println("嫁吧，比上不足，比下有余。");
		}else{
			System.out.println("不嫁！");
		}
	}
}
// 第三种方法
public class TestExer4_3{
	public static void main(String[] args){
		//1、输入男方的条件
		java.util.Scanner input = new java.util.Scanner(System.in);
		
		System.out.print("请输入身高（单位：cm）：");
		int height = input.nextInt();
		
		System.out.print("请输入财富（单位：千万）：");
		double money  = input.nextDouble();
		
		System.out.print("请输入是否帅（帅/不帅）：");
		String handsom = input.next();
		
		//2、判断
		/*
		高：180cm以上；富：财富1千万以上；帅：是。
		如果这三个条件同时满足，则：“我一定要嫁给他!!!”
		如果三个条件中有为真的情况，则：“嫁吧，比上不足，比下有余。”
		如果三个条件都不满足，则：“不嫁！”
		handsom=="帅" 是不对的
		"帅".equals(handsom) 是可以的，String对象的比较
		*/
		if(height>=180 && money>=1 && "帅".equals(handsom)){	
			System.out.println("我一定要嫁给他!!!");
		}else if(height>=180 || money>=1 || "帅".equals(handsom)){
			System.out.println("嫁吧，比上不足，比下有余。");
		}else{
			System.out.println("不嫁！");
		}
	}
}

第5题：解方程

求ax2+bx+c=0方程的根。a,b,c分别为函数的参数，

如果a≠0，那么：

（1）当b2-4ac>0，则有两个解；

（2）当b2-4ac=0，则有一个解；

（3）当b2-4ac<0，则无解；

如果a=0,b≠0，那么，

提示1：Math.sqrt(num); sqrt指平方根
例如：
求x2-4x+1=0方程的根
求x2-2x+1=0方程的根
答案

public class TestExer5{
	public static void main(String[] args){
		//（1）先输入a,b,c三个函数的参数
		java.util.Scanner input = new java.util.Scanner(System.in);
		System.out.println("请输入方程：ax的平方 + bx + c = 0的三个参数：");
		System.out.print("a：");
		double a = input.nextDouble();
		
		System.out.print("b：");
		double b = input.nextDouble();
		
		System.out.print("c：");
		double c = input.nextDouble();
		
		//（2）根据参数的不同，求方程的根/解
		if(a!=0){
			double d = b*b - 4*a*c;
			if(d>0){
				double x1 = (-b + Math.sqrt(d))/(2*a);
				double x2 = (-b - Math.sqrt(d))/(2*a);
				
				System.out.println("一元二次方程有两个根：" + x1 + "," +x2);
			}else if(d==0){
				double x = -b/(2*a);
				System.out.println("一元二次方程有1个根："+ x);
			}else{//d<0
				System.out.println("一元二次方程在实数范围内无解");
			}
		}else{//a==0
			if(b!=0){
				double x = -c/b;
				System.out.println("一元一次方程的根：" + x);
			}else{
				System.out.println("输入有误，a,b,c不能构成一个方程");
			}
		}
	}
}

第6题：彩票

- 假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。
1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000美元。
3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。
4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。

提示：使用Math.random() 产生随机数

Math.random() 产生[0,1)范围的随机值

Math.random() * 90：[0,90) 

Math.random() * 90 + 10：[10,100) 即得到  [10,99]

使用(int)(Math.random() * 90  + 10)产生一个两位数的随机数

答案

//第一种方法
public class TestExer6{
	public static void main(String[] args){
		//1、随机地产生一个两位数的彩票
		int rand = (int)(Math.random() * 90  + 10);//[10,99]
		
		//2、提示用户输入一个两位数
		java.util.Scanner input = new java.util.Scanner(System.in);
		System.out.print("请输入两位数的彩票号码：");
		int num = input.nextInt();
		
		//3、处理数字
		int randShi = rand/10;
		int randGe = rand%10;
		int numShi = num/10;
		int numGe = num%10;
		
		//4、判断
		if(num == rand){
			System.out.println("奖金10 000美元");
		}else if(randShi == numGe && randGe == numShi){
			System.out.println("奖金3 000美元");
		}else if(randShi == numShi || randGe == numGe){
			System.out.println("奖金1 000美元");
		}else if(randShi == numGe || randGe == numShi){
			System.out.println("奖金500美元");
		}else{
			System.out.println("彩票作废");
		}
		
		System.out.println("本次号码：" + rand);
	}
}
// 第二种方法
class Test11Exer6_2{
	public static void main(String[] args){
		//随机地产生一个两位数:[10,99]
		//个位数的范围：[0,9]   (int)(Math.random() * 10)==》[0,10)
		//十位数的范围：[1,9]	(int)(Math.random() * 9 +1)==》[0,9)+1==>[1,10)
		int randGe = (int)(Math.random() * 10);
		int randShi = (int)(Math.random() * 9 +1);
		System.out.println("randGe = " + randGe);
		System.out.println("randShi = " + randShi);
		
		java.util.Scanner input = new java.util.Scanner(System.in);
		System.out.print("请输入一个两位数的个位数：");
		int numGe = input.nextInt();
		System.out.print("请输入一个两位数的十位数：");
		int numShi = input.nextInt();
		
		if(numGe == randGe && numShi == randShi){
			System.out.println("奖金10 000美元");
		}else if(numGe == randShi && numShi == randGe){
			System.out.println("奖金 3 000美元");
		}else if(numGe == randGe || numShi == randShi){
			System.out.println("奖金 1 000美元");
		}else if(numGe == randShi || numShi == randGe){
			System.out.println("奖金 500美元");
		}else{
			System.out.println("谢谢惠顾");
		}
	}
}

第7题：押豹子

赌数游戏：随机产生3个1-6的整数，如果三个数相等，那么称为“豹子”，如果三个数之和大于9，称为“大”，如果三个数之和小于等于9，称为“小”，用户从键盘输入押的是“豹子”、“大”、“小”，并判断是否猜对了

提示：随机数 Math.random()产生 [0,1)范围内的小数
答案

//第一种方法
public class TestExer7{
	public static void main(String[] args){
		//1、随机产生3个1-6的整数
		int a = (int)(Math.random()*6 + 1);
		int b = (int)(Math.random()*6 + 1);
		int c = (int)(Math.random()*6 + 1);
		
		//2、判断随机产生的数的结果是什么
		String result;
		if(a == b && b == c){
			result = "豹子";
		}else if(a + b + c > 9){
			result = "大";
		}else{
			result = "小";
		}
		
		//3、用户从键盘输入押的是“豹子”、“大”、“小”
		java.util.Scanner input = new java.util.Scanner(System.in);
		System.out.print("请押宝（豹子、大、小）：");
		String ya = input.next();
		
		//4、判断用户的输入是否猜对了
		//比较ya与result是否相同
		//if(result==ya){
		if(result.equals(ya)){
			System.out.println("猜对了");
		}else{
			System.out.println("猜错了");
		}
        
        System.out.println("本期号码：");
        System.out.println("a="+a);
		System.out.println("b="+b);
		System.out.println("c="+c);
	}
}
// 第二种方法
public class TestExer7_2{
	public static void main(String[] args){
		//1、随机产生3个1-6的整数
		int a = (int)(Math.random()*6 + 1);
		int b = (int)(Math.random()*6 + 1);
		int c = (int)(Math.random()*6 + 1);
		
		//2、判断随机产生的数的结果是什么
		int result;
		if(a == b && b == c){
			result = 1;//假设豹子为1
		}else if(a + b + c > 9){
			result = 2;//假设大为2
		}else{
			result = 3;//假设小为3
		}
		
		//3、用户从键盘输入押的是“豹子”、“大”、“小”
		java.util.Scanner input = new java.util.Scanner(System.in);		
		System.out.println("1、豹子");
		System.out.println("2、大");
		System.out.println("3、小");
		System.out.print("请选择：");
		int ya = input.nextInt();
		
		//4、判断用户的输入是否猜对了
		//比较ya与result是否相同
		if(result==ya){
			System.out.println("猜对了");
		}else{
			System.out.println("猜错了");
		}
		
		System.out.println("本期号码是：" + a + "，" + b + "，" + c);
	}
}

第8题：转大写数字

使用 switch 把阿拉伯数字转为“壹、贰、叁、肆、伍、陆、柒、捌、玖”；其它的都输出 “other”。
答案

public class TestExer8{
	public static void main(String[] args){
		//1、输入0-9的数字
		java.util.Scanner input = new java.util.Scanner(System.in);
		System.out.print("请输入0-9的数字：");
		int num = input.nextInt();
		
		//2、转为中文大写数字
		switch(num){
			case 0:
				System.out.println("零");
				break;
			case 1:
				System.out.println("壹");
				break;
			case 2:
				System.out.println("贰");
				break;
			case 3:
				System.out.println("叁");
				break;
			case 4:
				System.out.println("肆");
				break;
			case 5:
				System.out.println("伍");
				break;
			case 6:
				System.out.println("陆");
				break;
			case 7:
				System.out.println("柒");
				break;
			case 8:
				System.out.println("捌");
				break;
			case 9:
				System.out.println("玖");
				break;
			default:
				System.out.println("other");
		}
	}
}

第9题：月份季节

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

public class TestExer9{
	public static void main(String[] args){
		//1、输入月份
		java.util.Scanner input = new java.util.Scanner(System.in);
		System.out.print("请输入月份：");
		int month = input.nextInt();
		
		switch(month){
			case 3:
			case 4:
			case 5:
				System.out.println("春季");
				break;
			case 6:
			case 7:
			case 8:
				System.out.println("夏季");
				break;
			case 9:
			case 10:
			case 11:
				System.out.println("秋季");
				break;
			case 12:
			case 1:
			case 2:
				System.out.println("冬季");
				break;
			default:
				System.out.println("输入有误！");
		}
	}
}

第10题：星期单词

编写程序，从键盘接收整数参数.如果该数为1-7，打印对应的星期值，否则打印“非法参数”。
答案

public class TestExer10{
	public static void main(String[] args){
		/*
		请输入星期的数字，输出对应的英语单词
		*/
		java.util.Scanner input = new java.util.Scanner(System.in);
		System.out.print("请输入星期（1-7）：");
		int week = input.nextInt();
		
		switch(week){
			default:
				System.out.println("输入有误,非法参数");
				break;
			case 1:
				System.out.println("Monday");
				break;
			case 2:
				System.out.println("Tuesday");
				break;
			case 3:
				System.out.println("Wednesday");
				break;
			case 4:
				System.out.println("Thursday");
				break;
			case 5:
				System.out.println("Friday");
				break;
			case 6:
				System.out.println("Saturday");
				break;
			case 7:
				System.out.println("Sunday");
				break;
		}
	}
}

第11题：这一天是当年的第几天

从键盘分别输入年、月、日，判断这一天是当年的第几天。先不考虑非法值输入

注：判断一年是否是闰年的标准：
1）可以被4整除，但不可被100整除
2）可以被400整除
答案

public class TestExer11{
	public static void main(String[] args){
		//1、从键盘分别输入年、月、日
		java.util.Scanner input = new java.util.Scanner(System.in);
		
		System.out.print("年：");
		int year = input.nextInt();
		
		System.out.print("月：");
		int month = input.nextInt();
		
		System.out.print("日：");
		int day = input.nextInt();
		
		//判断这一天是当年的第几天==>从1月1日开始，累加到xx月xx日这一天
		//(1)[1,month-1]个月满月天数
		//(2)第month个月的day天
		//(3)单独考虑2月份是否是29天（依据是看year是否是闰年）
		
		//2、声明一个变量days，用来存储总天数，直接初始化为day，这样就不用再加day天了
		int days = day;
		
		//3、累加[1,month-1]个月满月天数
		switch(month){
			case 12:
				//累加的1-11月
				days += 30;//这个30是代表11月份的满月天数
				//这里没有break，继续往下走
			case 11:
				//累加的1-10月
				days += 31;//这个31是代表10月的满月天数
				//这里没有break，继续往下走
			case 10:
				days += 30;//9月
			case 9:
				days += 31;//8月
			case 8:
				days += 31;//7月
			case 7:
				days += 30;//6月
			case 6:
				days += 31;//5月
			case 5:
				days += 30;//4月
			case 4:
				days += 31;//3月
			case 3:
				days += 28;//2月
				//4、在这里考虑是否可能是29天
				if(year%4==0 && year%100!=0 || year%400==0){
					days++;//多加1天
				}
			case 2:
				days += 31;//1月
		}
		
		//5、输出结果
		System.out.println(year + "年" + month + "月" + day + "日是这一年的第" + days + "天");
	}
}

第12题：生肖

编写一个程序，为一个给定的年份找出其对应的中国生肖。中国的生肖基于12年一个周期，每年用一个动物代表：rat（鼠）、ox（牛）、tiger（虎）、rabbit（兔）、dragon（龙）、snake（蛇）、horse（马）、sheep（羊）、monkey（候）、rooster（鸡）、dog（狗）、pig（猪）。
提示：2017年：鸡 2017 % 12 == 1
答案

public class TestExer12{
	public static void main(String[] args){
		//从键盘输入一个年份
		java.util.Scanner input = new java.util.Scanner(System.in);
		System.out.print("请输入年份：");
		int year = input.nextInt();
		
		//判断
		switch(year%12){
			case 1:
				System.out.println(year + "是鸡年");
				break;
			case 2:
				System.out.println(year + "是狗年");
				break;
			case 3:
				System.out.println(year + "是猪年");
				break;
			case 4:
				System.out.println(year + "是鼠年");
				break;
			case 5:
				System.out.println(year + "是牛年");
				break;
			case 6:
				System.out.println(year + "是虎年");
				break;
			case 7:
				System.out.println(year + "是兔年");
				break;
			case 8:
				System.out.println(year + "是龙年");
				break;
			case 9:
				System.out.println(year + "是蛇年");
				break;
			case 10:
				System.out.println(year + "是马年");
				break;
			case 11:
				System.out.println(year + "是羊年");
				break;
			case 0:
				System.out.println(year + "是猴年");
				break;
			default:
				System.out.println(year + "输入错误");
		}
	}
}

第13题：累加和

求1-100的和
答案

// 第一种方法
public static void main(String[] args){
		int sum = 0;//别忘了初始值
		
		//求1-100的累加和
		for(int i=1; i<=100; i++){
			sum += i;
		}
		
		//显示最终结果
		System.out.println("1-100的和是：" + sum);
	}
// 第二种方法
public static void main(String[] args) {
		int i=1;
		int sum = 0;
		while(i<=100){
			sum +=i;
			i++;
		}
		System.out.println("1-100的和为："+sum);
	}

第14题：1-100偶数

打印1-100的偶数
答案

//第一种方法
public static void main(String[] args){
		System.out.println("1-100的偶数有：");
		for(int i=2; i<=100; i=i+2){
			System.out.println(i);
		}
    }
//第二种方法
public static void main(String[] args){
		System.out.println("1-100的偶数有：");
		for(int i=1; i<=100; i++){
			//如果i是偶数就打印它
			if(i % 2 == 0){//条件判断了100次，只有50次满足条件
				System.out.println(i);
			}
		}
	}

第15题：正负数个数

从键盘输入整数，输入0结束，统计输入的正数、负数的个数
答案

//第一种方法
public static void main(String[] args) {
		java.util.Scanner input = new java.util.Scanner(System.in);
		
		int positive = 0;
		int negative = 0;
		int num;
		do{
			System.out.print("请输入整数（0）结束：");
			num = input.nextInt();
			if(num>0){
				positive++;
			}else if(num<0){
				negative++;
			}
		}while(num!=0);
		System.out.println("正数：" + positive + "，负数：" + negative);
	}
//第二种方法
public static void main(String[] args) {
		java.util.Scanner input = new java.util.Scanner(System.in);
		
		int positive = 0;
		int negative = 0;
		while(true){
			System.out.print("请输入整数（0）结束：");
			int num = input.nextInt();
			if(num==0){
				break;
			}else if(num>0){
				positive++;
			}else{
				negative++;
			}
		}
		System.out.println("正数：" + positive + "，负数：" + negative);
	}

第16题：猜数

随机生成一个100以内的正整数，猜数字游戏
从键盘输入数，如果大了提示，大了，如果小了，提示小了，如果对了，就不再猜了，并统计一共猜了多少次
提示：随机数
(1）Math.random()
double num = Math.random();// [0,1)的小数
（2）java.util.Random rand = new java.util.Random();
int num= rand.nextInt(100);//[0,100)的整数
答案

//第一种方法
public static void main(String[] args){
		//随机生成一个100以内的整数,[0,100)
		int randNum = (int)(Math.random()*100);
		
		//从键盘输入数，如果大了提示，大了，如果小了，提示小了，如果对了，就不再猜了，
		java.util.Scanner input = new java.util.Scanner(System.in);
		int num;//挪到do{}上面，提升作用域
		int count = 0;//统计次数
		do{
			System.out.print("猜数（范围[0,100)：");
			num = input.nextInt();
			
			count++;//输入一次，就代表猜一次
			
			if(num > randNum){
				System.out.println("大了");
			}else if(num<randNum){
				System.out.println("小了");
			}
		}while(num!=randNum);//条件成立，重复执行循环体语句
		
		System.out.println("一共猜了：" + count + "次");
	}
// 第二种方法
public static void main(String[] args){
		//随机生成一个100以内的整数,[0,100)
        java.util.Random rand = new java.util.Random();
		int randNum = rand.nextInt(100);
		
		//从键盘输入数，如果大了提示，大了，如果小了，提示小了，如果对了，就不再猜了，
		java.util.Scanner input = new java.util.Scanner(System.in);
		int num;//挪到do{}上面，提升作用域
		int count = 0;//统计次数
		do{
			System.out.print("猜数（范围[0,100)：");
			num = input.nextInt();
			
			count++;//输入一次，就代表猜一次
			
			if(num > randNum){
				System.out.println("大了");
			}else if(num<randNum){
				System.out.println("小了");
			}
		}while(num!=randNum);//条件成立，重复执行循环体语句
		
		System.out.println("一共猜了：" + count + "次");
	}

第17题：水仙花数

输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。例如： 153 = 1*1*1 + 5*5*5 + 3*3*3
答案

//第一种方法
/*
 * 练习：打印所有的水仙花数
 * 
 * 分析：
 * 		什么是水仙花数呢?
 * 			所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
 *			举例：153就是一个水仙花数。
 *			153 = 1*1*1 + 5*5*5 + 3*3*3
 *
 *		1.三位数其实就告诉了我们水仙花数的范围
 *			100-999
 *		2.如何获取一个数据的每一个位上的数呢?
 *			举例：我有一个数据153，请问如何获取到个位，十位，百位
 *			个位：153%10 = 3;
 *			十位：153/10%10 = 5;
 *			百位：153/10/10%10 = 1;
 *			千位：...
 *			万位：...
 *		3.让每个位上的立方和相加，并和该数据进行比较，如果相等，就说明该数据是水仙花数，在控制台输出
 */
public class ForTest04 {
	public static void main(String[] args) {
		//通过循环获取到每一个三位数
		for(int x=100; x<1000; x++) {
			//获取个位，十位，百位
			int ge = x%10;
			int shi = x/10%10;
			int bai = x/10/10%10;
			
			//让每个位上的立方和相加，并和该数据进行比较，如果相等，就说明该数据是水仙花数，在控制台输出
			if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
				System.out.println(x); 
			}
		}
	}
}
//第二种方法
/*
 * 练习：打印所有的水仙花数共有多少个
 * 
 * 分析：
 * 		1.定义统计变量，初始化值是0
 * 		2.获取三位数，用for循环实现
 * 		3.获取三位数的个位，十位，百位
 * 		4.判断这个三位数是否是水仙花数，如果是，统计变量++
 * 		5.输出统计结果就可以了
 */
public class ForTest5 {
	public static void main(String[] args) {
		//定义统计变量，初始化值是0
		int count = 0;
		
		//获取三位数，用for循环实现
		for(int x=100; x<1000; x++) {
			//获取三位数的个位，十位，百位
			int ge = x%10;
			int shi = x/10%10;
			int bai = x/10/10%10;
			
			//判断这个三位数是否是水仙花数，如果是，统计变量++
			if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
				count++;
			}
		}
		
		//输出统计结果就可以了
		System.out.println("水仙花数共有："+count+"个");
	}
}

第18题：foobizbaz

从1循环到150并在每行打印一个值，
另外在每个3的倍数行上打印出“foo”,
在每个5的倍数行上打印“biz”,
在每个7的倍数行上打印输出“baz”
答案

public static void main(String[] args){
		//从1循环到150
		for(int i=1; i<=150; i++){
			//在每行打印一个i的值
			//System.out.println(i);//输出i之后，立刻换行
			System.out.print(i);//只打印i的值
			
			//每个3的倍数行上打印出“foo”
			if(i%3==0){
				//System.out.println("foo");//输出foo后立刻换行
				System.out.print("\tfoo");//这里加\t是为了好看
			}
			
			//在每个5的倍数行上打印“biz”
			if(i%5==0){
				System.out.print("\tbiz");
			}
			
			//在每个7的倍数行上打印输出“baz”
			if(i%7==0){
				System.out.print("\tbaz");
			}
			
			//最后把这一行的事全部完成后，再换行
			//System.out.print("\n");
			System.out.println();//只打印换行
		}
	}

第19题：最大公约数和最小公倍数

输入两个正整数m和n，求其最大公约数和最小公倍数
答案

public static void main(String[] args){
		//输入两个正整数m和n
		java.util.Scanner input = new java.util.Scanner(System.in);
		
		int m;
		while(true){
			System.out.print("请输入第一个正整数m的值：");
			m = input.nextInt();
			if(m<=0){
				System.out.println(m + "不是正整数，请重写输入！");
			}else{
				break;
			}
		}
		int n;
		while(true){
			System.out.print("请输入第一个正整数n的值：");
			n = input.nextInt();
			if(n<=0){
				System.out.println(n + "不是正整数，请重写输入！");
			}else{
				break;
			}
		}
		
		System.out.println("两个正整数：" + m + "," + n);
		
		//求m和n的最大公约数和最小公倍数
		/*
		1、概念
		公约数：能够把m和n都整除，就是它俩的公约数
		例如：6和9，公约数：1,3
		      9和18，公约数：1,3,9
			  5和13，公约数：1
		公倍数：能够被m和n都整除的，就是它俩的公倍数
		例如：6和9，公倍数：18,36....
			   9和18，公倍数：18,36...
			    5和13，公倍数：65,....
		
		2、如何找最大公约数
		例如：6和9
			从6开始，9%6==0?  6%6==0?
					 9%5==0?   6%5==0?
					 9%4==0?   6%4==0?
					 9%3==0?   6%3==0?    binggou找到了  结束查找
		例如：9和18
			从9开始	  9%9==0?  18%9==0?   binggou找到了  结束查找
		例如：5和13
			从5开始   5%5==?  13%5==0?
					  5%4==?  13%4==0?
					  5%3==?  13%3==0?
					  5%2==?  13%2==0?
					  5%1==?  13%1==0?   binggou找到了  结束查找
					其实只要找到5的平方根就可以了
		*/
		
		//第一步：找出m和n中最大值和最小值
		int max = m>=n ? m : n;
		int min = m<n ? m : n;
		
		//第二步：从小的开始查找
		//这里的1也可以修改为min的平方根
		int maxYue = 1;
		for(int i=min; i>=1; i--){
			//看i是否能够同时把m和n都整除
			if(m%i==0 && n%i==0){
				maxYue = i;
				break;
			}
		}
		System.out.println(maxYue +"是" + m + "和" + n + "的最大公约数");
		
		//最小公倍数 = m*n / 最大公约数
		//System.out.println(m*n/maxYue +"是" + m + "和" + n + "的最小公倍数"); 
		
		//如果不知道这个公式
		//从max开始找，一直找到m*n
		for(int i=max; i<=m*n; i++){
			if(i%m==0 && i%n==0){
				System.out.println(i +"是" + m + "和" + n + "的最小公倍数"); 
				break;
			}
		}
	}

第20题：3、5、7的倍数不打印

打印1-100之间数，其中3、5、7的倍数不打印
答案

class Test13_Exer8{
	public static void main(String[] args){
		/*
		不使用continue
		*/
		for(int i=1; i<=100; i++){
			//其中3、5、7的倍数不打印
			//如果这个数不是3，5,7的倍数就打印
			if(i%3!=0 && i%5!=0 && i%7!=0){
				System.out.println(i);
			}
		}
		System.out.println("-----------------------");
		/*
		使用continue
		*/
		for(int i=1; i<=100; i++){
			//其中3、5、7的倍数不打印
			//如果是3,5,7的倍数就跳过打印语句
			if(i%3==0 || i%5==0 || i%7==0){
				continue;
			}
			System.out.println(i);
		}
	}
}

第21题：完数

一个数如果恰好等于它的因子之和，这个数就称为"完数"。（因子：除去这个数本身的约数）
例如6=1＋2＋3.编程找出1000以内的所有完数
答案

public static void main(String[] args){
		//找出1000以内的所有完数
		for(int i=1; i<1000; i++){
			//判断i是否是完数，如果是就打印i
			/*
			完数？
				一个数如果恰好等于它的因子之和
				例如：6的因子：1,2,3
					1,2,3,6是6的约数，能够把6给整除了
					因子：除了6本身以外的约数
				例如：18的因子：1,2,3,6,9   不是完数
			如何判断i是否是完数？
			（1）先找出i的所有的因子，并且累加它的所有的因子
			（2）判断因子之和与i是否相等，如果相等就是完数
			*/
			
			//（1）先找出i的所有的因子，并且累加它的所有的因子
			int iSum = 0;
			for(int j=1; j<i; j++){
				//如果j能够把i整除了，j就是i的因子
				if(i%j==0){
					iSum += j;
				}
			}
			
			//（2）判断因子之和与i是否相等，如果相等就是完数
			if(i == iSum){
				System.out.println(i);
			}
		}
	}

第22题：九九乘法表

打印正的九九乘法表
答案

public static void main(String[] args) {
		for(int i =1;i<=9;i++){
			for(int j=1;j<=i;j++){
				System.out.print(j+"*"+i+"="+(i*j) + "\t");
			}
			System.out.println();
		}
	}

打印倒的九九乘法表
答案

public static void main(String[] args) {
		for(int i=1; i<=9; i++){
			/*
			每一行有三件事情：（1）打印n个\t（2）打印m个式子（3）换行
			*/
			//（1）打印n个\t
			/*
			当i=1，第1行，8个\t，j=1,2,3,4,5,6,7,8		j<=8	j<=9-i
			当i=2，第2行，7个\t，j=1,2,3,4,5,6,7		j<=7
			当i=3，第3行，6个\t，j=1,2,3,4,5,6
			。。。
			当i=8，第8行，1个\t，j=1,
			当i=9，第9行，0个\t，j=1,j<=0不满足一次也不执行		j<=9-i  j<=9-9									
			*/
			for(int j=1; j<=9-i; j++){
				System.out.print("\t");
			}
			
			//（2）打印m个式子
			/*
			当i=1,第1行，1个式子, k=1						k<=i
			当i=2,第2行，2个式子, k=1,2
			..
			当i=9,第9行，9个式子, k=1,2,3,4,5,6,7,8,9
			*/
			for(int k=1; k<=i; k++){
				System.out.print(i + "*" + k + "=" + i*k + "\t");
			}
			
			//换行
			System.out.println();
		}
	}

第23题：菱形

打印出如下图形
答案

//第一种方法
public static void main(String[] args){
		//上半部分：正的等腰三角形
		//5行
		for(int i=1; i<=5; i++){
			//(1)打印空格
			/*
			当i=1,打印4个空格，j=4,3,2,1	j>=i
			当i=2,打印3个空格，j=4,3,2
			当i=3,打印2个空格，j=4,3
			当i=4,打印1个空格，j=4
			当i=5,打印0个空格，j=4,让循环条件一次都不满足
			*/
			for(int j=4; j>=i; j--){
				System.out.print("  ");
			}
			//(2)打印*
			/*
			当i=1,打印1个,j=1					j<=2*i-1
			当i=2,打印3个,j=1,2,3,
			当i=3,打印5个,j=1,2,3,4,5
			当i=4,打印7个,j=1,2,3,4,5,6,7
			当i=5,打印9个,j=1,2,3,4,5,6,7,8,9
			*/
			for(int j=1; j<=2*i-1; j++){
				System.out.print("* ");
			}
			//(3)换行
			System.out.println();
		}
		
		
		//下半部分：倒立的等腰三角形
		//4行
		for(int i=1; i<=4; i++){
			//(1)打印空格
			/*
			当i=1,1个空格,j=1		j<=i
			当i=2,2个空格,j=1,2	
			当i=3,3个空格,j=1,2,3
			当i=4,4个空格,j=1,2,3,4
			*/
			for(int j=1; j<=i; j++){
				System.out.print("  ");
			}
			//(2)打印*
			/*
			当i=1,7个*，j=1,2,3,4,5,6,7  j<=9-2*i;
			当i=2,5个*，j=1,2,3,4,5
			当i=3,3个*，j=1,2,3
			当i=4,1个*，j=1
			*/
			for(int j=1; j<=9-2*i; j++){
				System.out.print("* ");
			}
			//(3)换行
			System.out.println();
		}
	}
//第二种方法
public static void main(String[] args){
		int lines = 15;//行数必须是奇数，>=3
		
		//上半部分
		int shang = lines/2+1;
		for(int i=1; i<=shang; i++){
			//每一行三件事：（1）空格（2）*（3）换行
			//（1）空格
			/*
			i=1,4个，shang-1个  j=1,2,3,..shang-1
			i=2,3个，shang-2个
			i=3,2个，shang-3个
			i=4,1个，shang-4个
			i=5,0个，shang-5个	
			...			
			第i行，j=1,2,3,..shang-i
			*/
			for(int j=1; j<=shang-i; j++){
				System.out.print(" ");
			}
			
			//（2）*号
			/*
			i=1,1个*
			i=2,3个*
			...
			第i行，2*i-1个*
			*/
			for(int j=1; j<=2*i-1; j++){
				System.out.print("*");
			}
			System.out.println();
		}
		
		
		//下半部分
		int xia = lines/2;
		for(int i=1; i<=xia; i++){
			//每一行三件事：（1）空格（2）*（3）换行
			//（1）空格
			/*
			i=1,1个空格
			i=2,2个空格
			...
			第i行，i个空格
			*/
			for(int j=1; j<=i; j++){
				System.out.print(" ");
			}
			
			//（2）*号
			/*
			本图为例
			i=1; 7个  
			i=2; 5个
			i=3; 3个
			i=4; 1个
			第i行， 9-2*i  ->lines-2*i
			*/
			for(int j=1; j<=lines-2*i; j++){
				System.out.print("*");
			}
			System.out.println();
		}
	}

第24题：素数

找出1-100之间所有的素数（质数）
答案

//第一种方法
public static void main(String[] args){
		//找出1-100之间所有的素数（质数）
		//1-100之间
		for(int i=1; i<=100; i++){
			//里面的代码会运行100遍
			//每一遍i的值是不同的，i=1,2,3,4,5...100
			//每一遍都要判断i是否是素数，如果是，就打印i
			/*
			如何判断i是否是素数
			（1）找出i的所有的约数，并累加它们的和
			例如：
				i=5，它的约数有1和5，约数和：6
				i=11，它的约数有1和11，约数和：12
				i=18，它的约数有1,2,3,6,9,18，约数和：39
			（2）如果某个i的约数和 == i+1，那么i就是素数
			*/
			//（1）找出i的所有的约数，并累加它们的和
			int iSum = 0;
			for(int j=1; j<=i; j++){
				if(i%j==0){
					//j是i的约数
					iSum += j;
				}
			}
			//（2）如果某个i的约数和 == i+1，那么i就是素数
			if(iSum == i+1){
				System.out.println(i);
			}
			
		}
	}
//第二种方法
public static void main(String[] args){
		//找出1-100之间所有的素数（质数）
		//1-100之间
		for(int i=1; i<=100; i++){
			//里面的代码会运行100遍
			//每一遍i的值是不同的，i=1,2,3,4,5...100
			//每一遍都要判断i是否是素数，如果是，就打印i
			/*
			如何判断i是否是素数
			（1）找出i在[2,i-1]之间的约数的个数
			（2）如果这个个数是0，那么i就是素数
			*/
			int iCount = 0;
			for(int j=2; j<i; j++){
				if(i%j==0){//j是i在[2,i-1]之间的约数
					iCount++;
				}
			}
			
			//（2）如果这个个数是0，那么i就是素数
			if(iCount == 0){
				System.out.println(i);
			}
		}
	}

Java数组相关题集

第1题码农找室友

升景坊单间短期出租4个月，550元/月（水电煤公摊，网费35元/月），空调、卫生间、厨房齐全。屋内均是IT行业人士，喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人，爱干净、安静。手机号码如下：
答案

public static void main(String[] args) {
		int[] arr = new int[] { 8, 2, 1, 0, 3 };
		int[] index = new int[] { 2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3 };
		String tel = "";
		for (int i = 0; i < index.length; i++) {
			tel += arr[index[i]];
		}
		System.out.println("联系方式：" + tel);
	}
// 最终,他的电话号码是:18013820100

第2题竞赛打分

（1）在编程竞赛中，有10位评委为参赛的选手打分，分数分别为：5，4，6，8，9，0，1，2，7，3
（2）求选手的最后得分（去掉一个最高分和一个最低分后其余8位评委打分的平均值）

答案

public static void main(String[] args){
		int[] scores = {5,4,6,8,9,0,1,2,7,3};
		int max = scores[0];
		int min = scores[0];
		double sum = 0;
		for (int i = 0; i < scores.length; i++) {
			if(max < scores[i]){
				max = scores[i];
			}
			if(min > scores[i]){
				min = scores[i];
			}
			sum += scores[i];
		}
		double score = (sum - max - min)/(scores.length-2);
		System.out.println("得分：" + score);
	}

第3题寻找天数

已知：一年12个月每个月的总天数是：{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,31}，从键盘输入年，月，日后，计算这一天是这一年的第几天。
提示：考虑闰年
答案

public static void main(String[] args) {
		java.util.Scanner input = new java.util.Scanner(System.in);
		
		System.out.print("年：");
		int year = input.nextInt();
		
		System.out.print("月：");
		int month = input.nextInt();
		
		System.out.print("日：");
		int day = input.nextInt();
		
		int[] daysPerMonth = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,31};
		
		int days = day;
		for (int i = 1; i < month; i++) {
			if(i==2){
				if(year%4==0 && year%100!=0 || year%400==0){
					days++;
				}
			}
			days+= daysPerMonth[i-1];
		}
		System.out.println(year+"年" + month + "月" + day + "日是这一年的第" + days + "天");
	}

第4题打鱼晒网

假设张三从1990年1月1日开始执行三天打鱼两天晒网，5天一个周期，风雨无阻，那么李四想要找张三玩，需要从键盘输入年，月，日后，判断这一天张三是在打鱼还是晒网。
已知：一年12个月每个月的总天数是：{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,31}
提示：考虑闰年
答案

public static void main(String[] args) {
		java.util.Scanner input = new java.util.Scanner(System.in);
		
		System.out.print("年：");
		int year = input.nextInt();
		
		System.out.print("月：");
		int month = input.nextInt();
		
		System.out.print("日：");
		int day = input.nextInt();
		
		int[] daysPerMonth = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,31};
		
		int days = day;
		
		for (int i = 1990; i < year; i++) {
			if(i%4==0 && i%100!=0 || i%400==0){
				days+=366;
			}else{
				days+=365;
			}
		}
		
		for (int i = 1; i < month; i++) {
			if(i==2){
				if(year%4==0 && year%100!=0 || year%400==0){
					days++;
				}
			}
			days+= daysPerMonth[i-1];
		}
		System.out.println(year+"年" + month + "月" + day + "日是在" + (days%5==1 || days%5==2 || days%5==3 ? "打鱼":"晒网"));
	}

第5题星期问题

用一个数组，保存星期一到星期天的7个英语单词，从键盘输入1-7，显示对应的单词
答案

public static void main(String[] args) {
		String[] weeks = {"monday","tuesday","wednesday","thursday","friday","saturday","sunday"};
		
		java.util.Scanner input = new java.util.Scanner(System.in);
		
		System.out.print("星期：");
		int week = input.nextInt();
		
		if(week<1 || week>7){
			System.out.println("输入有误！");
		}else{
			System.out.println(week + "：" + weeks[week-1]);
		}
	}

第6题英文字母大小写转换

用一个数组存储26个英文字母的小写形式，并遍历显示小写字母以及它对应的大写字母，例如：a->A
提示：ASCII码表
答案

public static void main(String[] args) {
		char[] letters = new char[26];
		for (int i = 0; i < letters.length; i++) {
			letters[i] = (char)('a' + i);
		}
		for (int i = 0; i < letters.length; i++) {
			System.out.println(letters[i] + "->" + (char)(letters[i]  -32));
		}
	}

第7题学生成绩排名

1、从键盘输入本组学员人数

2、声明两个数组，一个存储本组学员的姓名，一个存储本组学员的成绩

3、从键盘输入每一个人的姓名和成绩，分别存到两个数组中

4、找出最高分和最低分的学员的姓名

答案

String[] names = new String[count];
int[] scores = new int[count];

for(int i=0; i<count; i++){
	System.out.print("第" + (i+1) + "个同学的信息：");
	System.out.print(""姓名：");
	names[i] = input.next();
	
	System.out.print("成绩：");
	scores[i] = input.nextInt();
}

int index = 0;
for(int i=1; i<scores.length; i++){
	if(scores[i] > scores[index]){
		index = i;
	}
}

System.out.println(names[index]);

Java面向对象之三大特性综合练习

有关面向对象的题,我就整理一道题,但是将前面这两天讲的知识点都涉及到了,尤其是对面向对象三大特性的应用,题目如下:

1、声明一个父类Employee员工类型，
有属性，姓名（String），出生日期（MyDate类型，也是自定义的含年，月，日属性日期类型）
有方法，public double earning()
public String getInfo()：显示姓名和实发工资

2、声明一个子类SalaryEmployee正式工，继承父类Employee
增加属性，薪资，工作日天数，请假天数
重写方法，public double earning()返回实发工资，实发工资 = 薪资 - 薪资/工作日天数 * 请假天数，
重写方法，public String getInfo()：显示姓名和实发工资，月薪，工作日天数，请假天数

3、声明一个子类HourEmployee小时工，继承父类Employee
有属性，工作小时数，每小时多少钱
重写方法，public double earning()返回实发工资，实发工资 = 每小时多少钱 * 小时数
重写方法，public String getInfo()：显示姓名和实发工资，时薪，工作小时数
增加方法，public void leave()：打印查看使用工具是否损坏，需要赔偿

4、声明一个子类Manager经理，继承SalaryEmployee
增加属性：奖金，奖金比例
重写方法，public double earning()返回实发工资，实发工资 = (薪资 - 薪资/工作日天数 * 请假天数)*(1+奖金比例)
重写方法，public String getInfo()：显示姓名和实发工资，月薪，工作日天数，请假天数，奖金比例

5、声明一个员工数组，存储各种员工，
你现在是人事，从键盘输入当前的月份，需要查看每个人的详细信息。
如果他是正式工（包括SalaryEmployee和Manager），并且是本月生日的，祝福生日快乐，通知领取生日礼物。如果是HourEmployee显示小时工，就进行完工检查，即调用leave方法

注意事项:

判断生日的时候,利用构造器传入的是日期的对象
在生日月份那里判断是小时工还是正式工,小时工会遇到编译错误,所以需要上一章讲的多态的向下类型转换进行强制转换
答案:

package com.test02class;
import java.util.Scanner;
/*
5、声明一个员工数组，存储各种员工，
你现在是人事，从键盘输入当前的月份，需要查看每个人的详细信息。
如果他是正式工（包括SalaryEmployee和Manager），并且是本月生日的，祝福生日快乐，通知领取生日礼物。如果是HourEmployee显示小时工，就进行完工检查，即调用leave方法

* */
public class Test {
    public static void main(String[] args) {
        // 定义员工数组
        Employee[] emp = new Employee[5];

        // 键盘初始化
        Scanner sc = new Scanner(System.in);

        // 人事获取月份
        System.out.println("请输入月份");
        int month = sc.nextInt();
        if(month<1 && month > 13)
            System.out.println("请输入正确的月份");

        // 创建两个正式员工,并将对象存储对象数组中
        emp[0] = new SalaryEmployee("刘备",new MyDate(1994,10,2),23000,22,1);
        emp[1]  = new SalaryEmployee("吕布",new MyDate(1990,5,12),19000,22,2);
        emp[2] = new Manager("貂蝉",new MyDate(1996,3,2),25000,22,5,0.2);

        // 创建临时工
        emp[3]  = new HourEmployee("阿珂",new MyDate(1998,12,2),160,300);
        emp[4]  = new HourEmployee("李白",new MyDate(1999,8,2),145.5,300);



        // 遍历数组并显示
        for (int i = 0; i < emp.length; i++) {
            // 输入员工的工资信息
            System.out.println(emp[i].getInfo());
            if(emp[i] instanceof SalaryEmployee) {
                if (emp[i].getBirthday() == month) {
                    System.out.println(emp[i].getName() + "生日快乐,今天全公司为你组织生日patty~~~");
                }
            } else{
                HourEmployee h1 = (HourEmployee) emp[i];
                h1.leave();
                }
        }

    }
}

/*
*  1、声明一个父类Employee员工类型，
有属性，姓名（String），出生日期（MyDate类型，也是自定义的含年，月，日属性日期类型）
有方法，public  double earning()
		public String getInfo()：显示姓名和实发工资
* */
class Employee{
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // 定义员工属性
    private String name;
    private MyDate birthday;

    // 创建一个参数构造器
    public Employee(String name) {
        this.name = name;
    }

    // 创建带参构造器
    public Employee(String name, MyDate birthday) {
        this.name = name;
        this.birthday = birthday;
    }

    // 创建getter/setter方法
    // 定义计算工资方法,因为不知道工资计算方式,因此返回默认值
    public double earning(){
        return 0.0;
    }

    // 显示姓名和实发工资方法
    public String getInfo(){
        return "姓名: " + name + " ,出生日期: " + birthday.toString() + ", 实发工资: "+ earning();
    }

    // 获取生日月份
    public int getBirthday(){
        return birthday.getMonth();
    }

}

// 日期类型
class MyDate{
    private int year;
    private int month;
    private int day;

    // 定义一个带参构造器
    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public int getMonth() {
        return month;
    }

    public int getDay() {
        return day;
    }

    // 返回出生日期
    public String toString(){
        return  year + "年" + month+ "月" + day + "日";
    }
}

/*
* 2、声明一个子类SalaryEmployee正式工，继承父类Employee
增加属性，薪资，工作日天数，请假天数
重写方法，public double earning()返回实发工资， 实发工资 = 薪资 - 薪资/工作日天数 * 请假天数，
重写方法，public String getInfo()：显示姓名和实发工资，月薪，工作日天数，请假天数
* */

// 定义正式工类
class SalaryEmployee extends Employee{
    // 添加属性
    private int salary;
    private int workDays;
    private int leaveDays;

    // 创建构造器
    public SalaryEmployee(String name, MyDate birthday, int salary, int workDays, int leaveDays) {
        super(name, birthday);
        this.salary = salary;
        this.workDays = workDays;
        this.leaveDays = leaveDays;
    }



    // 重写实发工资方法
    @Override
    public  double earning(){
        return salary-salary/workDays*leaveDays;
    }

    // 重写显示信息方法
    @Override
    public String getInfo(){
        return super.getInfo() + ", 月薪: " + salary + ", 工作日天数: " + workDays + ",请假天数: " + leaveDays;
    }
}
/*
* 3、声明一个子类HourEmployee小时工，继承父类Employee
有属性，工作小时数，每小时多少钱
重写方法，public double earning()返回实发工资， 实发工资 = 每小时多少钱 * 小时数
重写方法，public String getInfo()：显示姓名和实发工资，时薪，工作小时数
增加方法，public void leave()：打印查看使用工具是否损坏，需要赔偿
* */
// 定义小时工
class HourEmployee extends Employee{
    public HourEmployee(String name, MyDate birthday, double hoursWork, int hourlyWage) {
        super(name, birthday);
        this.hoursWork = hoursWork;
        this.hourlyWage = hourlyWage;
    }

    // 工时
    private double hoursWork;
    // 时薪
    private int hourlyWage;

    // 计算实发工资
    @Override
    public double earning(){
        return hourlyWage * hoursWork;
    }

    // 检查工具是否损坏
    public void  leave(){
        System.out.println("没有损坏,你可以走了");
    }
    // 重写显示工资方法
    @Override
    public String getInfo(){
        return "姓名: " + super.getInfo() + ", 时薪: " + hourlyWage + ",工时: " + hoursWork;
    }
}

/*
* 4、声明一个子类Manager经理，继承SalaryEmployee
增加属性：奖金，奖金比例
重写方法，public double earning()返回实发工资， 实发工资 = (薪资 - 薪资/工作日天数 * 请假天数)*(1+奖金比例)
重写方法，public String getInfo()：显示姓名和实发工资，月薪，工作日天数，请假天数，奖金比例
* */
// 定义经理
class Manager extends SalaryEmployee {
    // 定义奖金比例
    private double bonus;

    // 定义构造器

    public Manager(String name, MyDate birthday, int salary, int workDays, int leaveDays, double bonus) {
        super(name, birthday, salary, workDays, leaveDays);
        this.bonus = bonus;
    }

    // 重写实发工资方法
    @Override
    public double earning() {
        return super.earning() * (1 + bonus);
    }

    // 重写获取信息方法
    @Override
    public String getInfo() {
        return super.getInfo() + "奖金比例: " + bonus;
    }
}

GaryLea

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
6
评论
打怪升级之小白的大数据之旅＜Java基础知识点巩固习题＞

我整理一下最近学习的知识点相关的练习题及答案,希望可以帮到大家对所学的知识点进行查漏补缺(尽量先不看答案)Java基础语法相关练习集Java基本程序相关题集第一题按步骤编写代码，效果如图所示：编写步骤：定义类 Test1定义 main方法控制台输出5行字符串类型常量值控制台输出5行字符类型常量值答案: class Test1{ public static void main(String[] args){ System.out.pr
复制链接

扫一扫