java入门基础学习（三）

(一)有返回值的方法

格式:public static 返回值数据类型 方法名(参数){
		方法体
		return 数据;
	}
注意:1.返回值数据类型非void,必须使用return
	 2.有返回值的方法,方法调用时,可以直接进行输出
	 3.return的数据要和返回值数据类型保持一致(包含自动类型转换)
	 4.return必须方法在最后
	 5.返回值数据类型是void,可以使用return(不能给上数据),通常情况下return;省略不写
	 6.有返回值的方法中可以使用多个return,但是只能有一个结果

(二）方法重载

相同功能性的方法,可以有不同的实现
条件:1.同一个类中
        2.方法名相同
        3.参数列表不同(数据类型/个数不同)
        4.和返回值无关

习题

一、填空题
1.Java中有两种类型的选择结构的控制语句，分别是if语句和 switch语句 。
2.在Java JDK1.7之前，switch只能支持byte、short、char、int或者其对应的封装类以及Enum类型。在JDK1.7中又加入了 String 类型。
3.for循环的语法格式是for (表达式1;表达式2;表达式3) {循环体}，其中在整个循环过程中只执行一次的部分是 表达式1 。
4.在循环结构中，如果想跳出循环体，结束整个循环结构可以使用 break； 语句。
5.____continue__语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。即只结束本次循环，而不是终止整个循环的执行。
使用Math.random( )返回带正号的 double值，该值大于等于0.0且小于1.0。使用该函数生成[30,60]之间的随机整数的语句是 30*Math.random()+30; 。
二、选择题

1. 以下代码的执行结果是（ B ）。（选择一项）

	boolean m = false;
if(m = false){
	System.out.println("false");
}else{
	System.out.println("true");
}

A.	false
B.	true
C.	编译错误
D.	无结果

2. 分析如下Java代码，编译运行的输出结果是（ A ）。（选择一项）

	public static void main(String[ ] args) {
		boolean a=true;
		boolean b=false;
		if (!(a&&b)) {
			System.out.print("!(a&&b)");
		}else if (!(a||b)) {
			System.out.println("!(a||b)");
		}else {
			System.out.println("ab");
		}
}

A !(a&&b)
B. !(a||b)
C. ab
D. !(a||b)ab
3. 下列选项中关于变量x的定义，（ bD ）可使以下switch语句编译通过。（选择二项）

	switch(x) {
    case 100 :
        System.out.println("One hundred");
        break;
    case 200 :              
        System.out.println("Two hundred");                 
        break;
    case 300 :
        System.out.println( "Three hundred");
        break;
    default :
        System.out.println( "default");    
}

A	double x = 100;
B.	char x = 100;
C.	String x = "100";
D.	int x = 100;

4. 阅读下列文件定入的Java代码，其执行结果是（ D ）。（选择一项）

public class Test {
	public static void main(String[] args) {
		char ch = 'c';
		switch (ch) {
		    case 'a':
			    System.out.print("a");		break;
		    case 'b':
			    System.out.print("ab");
		    case 'c':
			    System.out.print("c");
		    default:
			    System.out.print("d");
		}
	}
}

A	a
B.	b
C.	c
D.	cd

5. 以下Java程序编译运行后的输出结果是（ B ）。（选择一项）

	public class Test {
	public static void main(String[] args) {
		int i = 0, sum = 0;
		while (i <= 10) {
			sum += i;
			i++;
			if (i % 2 == 0)
				continue;
		}
		System.out.println(sum);
	}
}

A	0
B.	55
C.	50
D.	36

6. 以下四个选项中和下面代码功能相同的是（ b ）。（选择一项）

	int i = 1;
int sum = 0;
while (i <= 100) {
	if (i % 2 == 0) 
		sum = sum + i;
	i++;
}

A	for (int x =1; x<=100;x++){ sum=sum+x;}
B.	for (int x =0; x<=100;x+=2){ sum=sum+x;}
C.	for (int x =1; x<=100;x+=2){ sum=sum+x;}
D.	上述全对

7. 以下do-while循环代码的执行结果是（ A ）。（选择一项）

int a=0;
int c=0;
do{
	--c;
	a=a-1;
}while(a>0);
System.out.println(a+"  "+c);

A. -1 -1
B. 死循环
C. -1 -2
D. -1 0
8. while循环和do-while循环的区别是（ D ）。（选择一项）

A.	没有区别，这两个结构在任何情况下效果一样 
B.	while循环比do-while循环执行效率高
C.	while循环是先循环后判断，所以循环体至少被执行一次
D.	do-while循环是先循环后判断，所以循环体至少被执行一次

9. 在Java中有如下代码，则编译运行该类的输出结果是（ d ）。（选择一项）

public static void main(String[ ] args) {
		for(int i=0;i<10;i++){
			if (i%2!=0) {
                break;
}
			System.out.print(i);
		}
}

A	13578
B.	02468
C.	0123456789
D.	0

10. 下面程序执行的结果是在屏幕上打印（ b ）次Java基础班。（选择一项）

	for(int  i=1;i<=10;i++){
	if (i<5)
		continue;
	System.out.println("Java基础班");
}

A	5
B.	6
C.	7
D.	8

11. 分析下面的Java多重循环代码片段，编译运行后的输出结果是（ D ）。（选择一项）

	for (int i = 0; i < 6; i++) {
	int k = ++i;
	while (k < 5) {
		System.out.print(i);
		break;
	}
}

A.	024
B.	02
C.	123
D.	13

12. 给定如下Java代码，编译运行的结果是（ A ）。（选择一项）

	public class Test {	
	public static void main(String[] args) {
		int sum=0;
		for(int i=1;i<10;i++){
			do{
				i++;
				if(i%2!=0)
					sum+=i;
			}while(i<6);
		}
		System.out.println(sum);
	}
}
	

A	8
B.	15
C.	24
D.	什么也不输出

13. Java中main方法的返回值是（ D ）。（选择一项）

    A String
    B. int
    C. char
    D. void

14. 在Java的程序类中如下方法定义正确的是（ AD ）。（选择两项）

    A public int ufTest(int num){
    int sum=num+100;
    return sum;
    }
    B. public String ufTest(int num){
    int sum=num+100;
    return sum;
    }
    C. public void ufTest(int num){
    int sum=num+100;
    return sum;
    }
    D. public float ufTest(int num){
    int sum=num+100;
    return sum;
    }

15. 以下关于方法调用的代码的执行结果是（ B ）。（选择一项）

	public class Test {
	public static void main(String args[]) {
		int i = 99;
		mb_operate(i);
		System.out.print(i + 100);
	}
	static void mb_operate(int i) {
		i += 100;
	}
}

A.	99 
B.	199
C.	299
D.	99100

16. 下面（ BD ）方法是public void example(){…}的重载方法。（选择二项）

    A private String example(){…}
    B. public int example(String str){…}
    C. public void example2(){…}
    D. public int example(int m,float f){…}

17. 以下选项中添加到代码中横线处会出现错误的是（ BD ）。（选择二项）

	public class Test {
	public float aMethod(float a, float b) {
		return 0;	
	}
                                       
}

A public float aMethod(float a, float b, float c) {
return 0;
}
B. public float aMethod(float c, float d) {
return 0;
}
C. public int aMethod(int a, int b) {
return 0;
}
D. private int aMethod(float a, float b) {
return 0;
}
三、判断题
1.if语句的条件表达式的结果都必须是boolean值。( t )
2.switch选择语句是多分支选择语句，只能处理等值条件判断的情况，表达式可以是int类型、char类型，但不能是double,float类型。( t )
3.while循环结构的特点是先循环再判断，循环体至少执行一次。（ x ）
4.for循环的语法格式是for (表达式1;表达式2;表达式3) {循环体}，其中三个表达式都可以省略。( t )
5.break语句可以出现在switch语句和循环语句中。（ t ）
continue语句可以出现在switch语句和循环语句中。（ x ）
6.多重循环是指一个循环体内又包含另一个完整的循环结构。外层循环变量变化一次，内层循环变量要从头到尾变化一遍。（ T ）
7.定义方法时的参数称为实在参数，调用方法时的参数称为形式参数。（ X ）
程序说明中的参数称为形式参数，调用语句中的参数称为实在参数。
8.调用方法时，要求实参和形参的个数相同，类型匹配。（ T ）
9.判断方法重载的依据是方法名相同，参数不同。（ T ）
10.程序调用自身的编程技巧称为递归。递归的特点是编程简单并且节省内存。( X)
11.任何可用递归解决的问题也能使用循环解决，递归既花时间又耗内存，在要求高性能的情况下尽量避免使用递归。（ T ）
四、简答题
1.if多分支语句和switch语句的异同之处
答：相同点：他们都是用来处理多分支条件的结构。不同点：switch语句只能处理等值条件判断的情况，而且条件只能是整型变量或字符型变量。 多重if选择结构的限制，特别适合某个变量处于某个连续区间时的情况。
2.while和do-while语句的异同之处
答：do-.while循环先执行一次再去判断条件，也就是说不管满不满足条件，都会先执行一次，执行次数最少1次；while循环必须先判断条件，满足了才执行，最少执行次数0次
3.break和continue语句的作用
答：break语句作用：1、可以用来从循环体内跳出循环体，即提前结束循环，接着执行循环下面的语句2、使流程跳出switch结构；continue语句作用：结束本次循环，即忽略循环体中continue语句下面尚未执行的语句，接着进行下一次是否执行循环的判定。
4.在多重循环中，如何在内层循环中使用break跳出外层循环。
答：在内层循环中标记break跳出操作，即：break flag;再用flag标记外层循环。
5.方法重载的定义、作用和判断依据
答：当我们要实现的功能一样，只是参数不同的时候（类型，顺序，个数），我们将方法的名字可以起成一样的名字，这种现象叫做方法的重载。 重载作用：就是实现功能一样；判断方法的重载依据：方法名相同，参数不同。
6.递归的定义和优缺点
答：定义：直接或间接调用自己本身的函数；优点：结构清晰、可读性强；缺点：运行效率低，耗费计算时间与存储空间。
五、编码题
1.打印九九乘法表

public class MultiTable {
	public static void main(String[] args) {
		for (int i = 1; i <= 9; i++) {
			for (int j = 1; j <= i; j++) {
				// 不换行打印数据
				System.out.print(i + " * " + j + " = " + i * j + "\t"); 
			}
			// 打印完一行进行换行
			System.out.println(); 
		}
	}
}

2.判断1-100之间有多少个素数并输出所有素数。（将判断一个数是否是素数的功能提取成方法，在循环中直接调用即可）

public class PrimeNum {
	public static void main(String[] args) {
		int count = 0;
		for (int j = 1; j <= 100; j++) {
			if (isPrime(j)) {
				System.out.print(j + " ");
				count++;
				if (count % 8 == 0) {
					System.out.println();
				}
			}
		}
	}
	private static boolean isPrime(int n) {
		boolean flag = true; // flag:返回值默认true,表示是素数
		if (n == 1)
			flag = false;
		else {
			for (int i = 2; i <= Math.sqrt(n); i++) {
				if (n % i== 0) {
					flag = false;
					break;
				}
			}
		}
		return flag;
	}
}

3.输入三个班，每班10个学生的成绩，求和并求平均分

import java.util.Scanner;
public class StuScoreCalc {
	public static void main(String[] args) {		
		Scanner sc = new Scanner(System.in);		
		for(int i = 1;i<=3;i++){
			//输入每个班成绩并求和
			System.out.println("请输入第"+i+"个班的成绩");
			double sum = 0;
			for(int j=0;j<10;j++){
				System.out.println("   请输入第"+(j+1)+"个学生成绩：");
				double score  = sc.nextDouble();
				System.out.println(score);
				sum += score; 
			}
			//求平均分
			double avg = sum / 10;
			//输出结果
			System.out.println("第"+i+"个班学生总分："+sum+" 平均分："+avg);		}
	}	 
}

4.编写递归算法程序：一列数的规则如下: 1、1、2、3、5、8、13、21、34… 求数列的第40位数是多少。

public class TestSum{
	public static void main(String[] args) {
		System.out.println(sum(40));
	}
	public static long sum(int n) {
		if (n <= 0) {
			return 0;
		} else if (n == 1 || n == 2) {
			return 1;
		} else {
			return sum(n - 1) + sum(n - 2);
		}
	}
}

5.打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。

public class Prog3{
	public static void main(String[] args){
		for(int i=100;i<1000;i++){
			if(isLotus(i))
			   System.out.print(i+" ");
		}
		System.out.println();
	}
	//判断水仙花数
	private static boolean isLotus(int lotus){
		boolean flag=false;
		int a = lotus % 10;
		int b = lotus / 10 % 10;
		int c = lotus / 100 % 10;
		if (Math.pow(a, 3) + Math.pow(b, 3) + Math.pow(c, 3) == lotus) {
			flag = true;
		}
		return flag;
	}
}

6.定义方法：打印指定行和列的矩形

public class TestRect {
	public static void main(String[] args) {
		// 调用printStr方法
		printStr(5, 4, "*");
	}
	public static void printStr(int rows, int columns, String str) {
		for (int i = 0; i < rows; i++) {
			for (int j = 0; j < columns; j++) {
				System.out.print(str);
			}
			System.out.println();
		}
	}
}

7.编写Java程序，实现接收用户输入的正整数，输出该数的阶乘。要求：限制输入的数据在1-10之间，无效数据进行提示，结束程序。要求使用递归和循环分别实现。输出结果如：4！=123*4=24

public class Test01 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		//输入一个数
		System.out.println("请输入你要判断的数据：");
		int n = input.nextInt();
		if(n>10 || n<1){
			System.out.println("限制输入的数据在1-10之间");
			System.exit(0);
		}
		String str = testString(n);
		long sum = factRec(n);//递归
		System.out.println(n+"!="+str+"="+sum);
		long sum2 = factfor(n);//for循环
		System.out.println(n+"!="+str+"="+sum2);
		
	}	
	//实现字符串的输出
	public static String testString(int n){
		String result = "";
		for (int i=1;i<=n;i++){
			result +=(i+"*");
		}
		return result.substring(0, result.length()-1);
	}	
	//递归实现
	public static long factRec(int n){
		if(n==1){
			return 1;
		}else{
			return n*factRec(n-1);
		}
	}	
	//for循环实现
	public static long factfor(int n){
		int sum = 1;
		for (int i = 1; i < n; i++) {
			sum += sum * i;
		}
		return sum;
	}
}

8.输入一个数，判断是奇数还是偶数

public class TestNum {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		//输入一个数
		System.out.println("请输入你要判断的数据：");
		int x = input.nextInt();
		//判断一个数据是奇数还是偶数
		if(x%2 == 0) {
			System.out.println(x+"这个数据是偶数");
		}else {
			System.out.println(x+"这个数据是奇数");
		}
	}
}

9.根据成绩输出对应的等级，使用if多分支和switch语句分别实现。
a)A级 [90,100]
b)B级 [80,90)
c)C级 [70,80)
d)D级 [60,70)
e)E级 [0,60)

public class TestGrade1 {
	public static void main(String[] args) {
		// 给出分数
		Scanner  input  = new Scanner(System.in);
		System.out.println("请输入一个分数");
		double score = input.nextDouble();
		// 根据分数，给出等级
		String grade;
		if (score >= 90) {
			grade = "A";
		} else if (score >= 80) {
			grade = "B";
		} else if (score >= 70) {
			grade = "C";
		} else if (score >= 60) {
			grade = "D";
		} else {
			grade = "E";
		}
		// 输出等级
		System.out.println("score=" + score + ",grade=" + grade);
	}
}

public class TestGrade2 {
	public static void main(String[] args) {
		// 给出分数
		Scanner  input  = new Scanner(System.in);
		System.out.println("请输入一个分数");
		int score = input.nextInt();			
		//根据分数，给出等级
		String grade="E";
		switch(score/10){
			case 10:
			case 9:grade="A";break;
			case 8:grade="B";break;
			case 7:grade="C";break;
			case 6:grade="D";break;
			default :grade="E";				
		}
		//输出等级
		System.out.println("score="+score+",grade="+grade);
	}
}

10.判断一个数是否是素数。

public class TestPrime {
	public static void main(String[] args) {
		// 输入一个数
		Scanner input = new Scanner(System.in);
		System.out.println("请输入一个数：");
		int n = input.nextInt();
		// 判断是否是素数
		boolean flag = true;
		if (n == 1)
			flag = false;
		else {
			for (int i = 2; i < n; i++) {
				if (n % i== 0) {
					flag = false;
					break;
				}
			}
		}
		// 输出结果
		if (flag) {
			System.out.println(n + "是素数");
		} else {
			System.out.println(n + "不是素数");
		}
	}
}

11.从键盘输入一个班5个学生的分数，求和并输出。

public class TestSum {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		//输入总分并求和
		double sum = 0;
		for (int i = 0; i < 5; i++) {
			System.out.println("请输入第"+(i+1)+"个学生的成绩");			
			double  d = input.nextDouble();
			sum += d;
		}
		//输出总分
		System.out.println("总分是"+sum);
	}
}

12.从键盘输入某个十进制整数数，转换成对应的二进制整数并输出。

public class Test10to2_1 {
	public static void main(String [] args){
		//给出一个十进制数
		int num2 =6;
		//转换
		int num = num2;
		String str="";
		do{
			//除以2得到商
			int div = num/2;
			//得到余数作为二进制位
			int mod = num%2;
			str = mod + str;			
			//商作为被除数
			num = div;
		}while(num!=0);//被除数不是零		
		//输出二进制数
		System.out.println(num2+"------>"+str);		
	}
}

13.根据考试成绩输出对应的礼物，90分以上爸爸给买电脑，80分以上爸爸给买手机， 60分以上爸爸请吃一顿大餐，60分以下爸爸给买学习资料。
要求：该题使用多重if完成

public class Test 1{
	public static void main(String[] args) {
		int score = 80;
		if (score >= 90) {
			System.out.println("电脑");
		} else if (score >= 80) {
			System.out.println("手机");
		} else if (score >= 60) {
			System.out.println("大餐");
		} else {
			System.out.println("学习资料");
		}
	}
}	

14.请根据英文单词的第一个字母判断星期几，如果第一个字母是一样的，则继续判断第二个字母。例如如果第一个字母是S,则继续判断第二个字母，如果第二个字母是a,则输出“星期六”。星期的英文单词如下表所示。

public class Test2{
	public static void main(String[] args) {
		char i, j;
		System.out.println("please enter the first letter:");
		Scanner input = new Scanner(System.in);
		String str = "";
		str = input.next().toLowerCase();
		// 转换成字符串
		i = str.charAt(0);
		switch (i) {
			case 'm':
				System.out.println("Monday\n");	break;
			case 'w':
				System.out.println("Wednesday\n");break;
			case 'f':
				System.out.println("Friday\n");	break;
			case 't':
				System.out.println("please enter the next letter:");
				str = input.next().toLowerCase();
				j = str.charAt(0);
				if (j == 'u')
					System.out.println("Tuesday\n");
				else if (j == 'h')
					System.out.println("Thursday\n");
				else 
					System.out.println("error\n");
				break;
			case 's':
				System.out.println("please enter the next letter:");
				// 转换成字符串
				str = input.next().toLowerCase();
				j = str.charAt(0);
				if (j == 'a')
					System.out.println("Saturday\n");
				else if (j == 'u')
					System.out.println("Sunday\n");
				else 
					System.out.println("error\n");
				break;
			default:
				System.out.println("error\n");
				break;
		}
	}
}

15.输入一批整数，使用循环求出最大值与最小值，输入0时结束。

public class Test 3{
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int max = 0, min = 0;
		int nums = 1;
		//输入第一个数，指定它是最大值和最小值
		System.out.println("请输入1个数：");
		nums = input.nextInt();
		max = nums;
		min = nums;
		//依次输入其他数字，并判断是否是最大值和最小值
		for (int i = 2; nums != 0; i++) {
			System.out.println("请输入" +i + "个数：");
			nums = input.nextInt();
			if (nums != 0) {
				if (nums > max) {
					max = nums;
				}
				if (nums < min) {
					min = nums;
				}
			}
		}
		//输出最大值和最小值
		System.out.println("最大值为：" + max);
		System.out.println("最小值为：" + min);
	}
}

16.给20块钱买可乐，每瓶可乐3块钱，喝完之后退瓶子可以换回1块钱，问最多可以喝到多少瓶可乐。

public class Test4 {
	public static void main(String[] args) {
		int money = 20, price = 3;  
		// temp表示每一次购买的可乐瓶数
		int temp = 0;
		// change表示每次购买完可乐剩下的钱
		int change = 0;
		// sum表示总的可乐瓶数
		int sum = 0;   
		// 如果钱数大于可乐价格
		while (money >= price) {
			// 购买可乐
			temp = money / price; 
			// 总可乐瓶数增加
			sum += temp; 
			// 计算买可乐剩下的钱
			change = money % price; 
			// 兑换可乐瓶子，计算剩余的总钱数
			money = temp + change; 
		}
		// 输出结果
		System.out.println(sum); 
	}
}

java入门基础学习（一）
java入门基础学习（二）
java入门基础学习（三）
java入门基础学习（四）
java入门基础学习（五）
java入门基础学习（六）
java入门基础学习（七）
java入门基础学习（八）
java入门基础学习（九）
java入门基础学习（十）
java进阶之常见对象（一）
java进阶之常见对象（二）
java进阶之冒泡排序
java进阶之选择排序
java进阶之面向对象（封装）
java进阶之面向对象（代码块、继承）
java进阶之面向对象（多态、抽象、接口）
java进阶之匿名内部类、访问修饰符、包