java 基础练习 （3）
48.输出大于200的最小的质数
package week2day03;
/**
* @author TaoTianye
题目：输出大于200的最小的质数
*/
public class caogao {
public static void main(String[] args) {
int n = 200;
for (;;) {
boolean flag = true;//判断素数的标志,true表示是素数，false表示不是素数
for (int i = 2; i <= n / 2; i++) {
if (n % i == 0) {
flag = false;
}
}
if (flag) {
System.out.println(n);
break;
}
n++;
}
}
}
结果：211
49.数组翻转
数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1
package weekday02;
/**
* @author TaoTianye
题目：数组翻转
数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1
*/
public class lianxi01 {
public static void main(String[] args) {
int[] a= {1,2,3,4,5};
for(int i=0,j=a.length-1;i<j;i++,j--) {
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}
for(int i=0;i<a.length;i++) {
System.out.print(a[i]);
}
}
}
50.方法的书写与调用
package weekday02;
/**
* @author TaoTianye
方法的书写与调用
*/
public class lianxi04 {
public static void main(String[] args) {
//调用方法
a();
double a=aa();
System.out.println(a);
aaa(10);
aaaa(2);
}
// 无参数，无返回的方法
public static void a() {
System.out.println("123");
}
//无参数，有返回 的方法
public static double aa() {
double x =2.0;
return x;
}
//有参数，无返回 的方法
//aaa()方法是为了求平方值
public static void aaa(int x) {
x=x*x;
System.out.println(x);
}
//有参数，有返回 的方法
//aaaa()方法是为了*100；
public static int aaaa(int x) {
int y = 100;
int z=x*y;
System.out.println(z);
return z;
}
}
输出：
123
2.0
100
200
51.定义一个无返回值,名为getMma的方法，传入一个int类型数组，求出该数组中的最大值、最小值和平均值并输出
package weekday02;
import java.util.Scanner;
/**
* @author TaoTianye
题目：定义一个无返回值,名为getMma的方法，传入一个int类型数组，求出该数组中的最大值、最小值和平均值并输出
*/
public class lianxi05 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int[] a=new int[10];
for(int i=0;i<a.length;i++) {
a[i] = s.nextInt();
}
getMma(a);
}
public static void getMma(int[] a) {
double av = 0;//平均值
int sum =0;//求和
// 冒泡法排倒序，a[0]为最大值，a[a.length-1]为最小值
for (int i = 0; i < a.length; i++) {
for (int j = a.length - 1; j > i; j--) {
if (a[j] > a[j - 1]) {
int temp = a[j];
a[j] = a[j - 1];
a[j - 1] = temp;
}
}
}
for(int i=0;i<a.length;i++) {
sum += a[i];
}
av = sum/(a.length*1.0);
System.out.println("最大值为：" + a[0]);
System.out.println("最小值为：" + a[a.length - 1]);
System.out.println("平均值为："+av);
}
}
输入：2 3 4 6 5 3 4 2 5 6 2 7
输出：
最大值为：6
最小值为：2
平均值为：4.0
52.获取数组平均值并统计数组中高于平均数的值个数（复杂版嵌套调用)
思路：
1、编写一个av方法来获取数组平均值（有参数，有返回值）
2、编写另一个gaoAv方法来统计数组中高于平均数的值个数（有参数，有返回值）
3、调用这两个方法来实现
package weekday02;
import java.util.Scanner;
/**
* @author TaoTianye
题目：.获取数组平均值并统计数组中高于平均数的值个数（复杂版嵌套调用)
思路：
1、编写一个av方法来获取数组平均值（有参数，有返回值）
2、编写另一个gaoAv方法来统计数组中高于平均数的值个数（有参数，有返回值）
3、调用这两个方法来实现
*/
public class lianxi06 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int[] a= new int[5];
for(int i=0;i<a.length;i++) {
a[i] = s.nextInt();
}
System.out.println("平均值为："+av(a));
gaoAv(a,av(a));
}
//1、编写一个av方法来获取数组平均值（有参数，有返回值）
public static double av (int[] a) {
int sum=0;
double average=0.0;
for(int i=0;i<a.length;i++) {
sum += a[i];
}
average = sum/(a.length*1.0);
return average;
}
// 2、编写另一个gaoAv方法来统计数组中高于平均数的值个数（有参数，有返回值）
public static int gaoAv(int[] a,double average) {
int count = 0;
for(int i=0;i<a.length;i++) {
if((a[i]*1.0)>average) {
count++;
System.out.println("高于平均数的值有："+a[i]+" ");
}
}
System.out.println("高于平均数的值个数是："+count+"个");
return count;
}
}
输入：23 22 12 54 34
输出：
平均值为：29.0
高于平均数的值有：54
高于平均数的值有：34
高于平均数的值个数是：2个
53.编写一个fac方法，求整数n的阶乘，例如5的阶乘是12345。
package weekday02;
import java.util.Scanner;
/**
* @author TaoTianye
题目：编写一个fac方法，求整数n的阶乘，例如5的阶乘是1*2*3*4*5。
分析：编写的fac方法 有参数、无返回值
*/
public class lianxi07 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n =s.nextInt();
fac(n);
}
public static void fac(int n) {
int x=n;
int sum=1;
for(int i=0;i<x;i++) {
sum *=n;
n--;
}
System.out.println(x+"的阶乘为"+sum);
}
}
输入：4
输出：4的阶乘为24
54编写一个方法，判断该年份是否是闰年。
闰年是公历中的名词。闰年分为普通闰年和世纪闰年。
普通闰年:公历年份是4的倍数的，且不是100的倍数，为闰年。（如2004年就是闰年）；
世纪闰年:公历年份是整百数的，
必须是400的倍数才是闰年（如1900年不是世纪闰年，2000年是世纪闰年）；
package weekday02;
import java.util.Scanner;
/**
* @author TaoTianye
题目： 编写一个方法，判断该年份是否是闰年。
闰年是公历中的名词。闰年分为普通闰年和世纪闰年。
普通闰年:公历年份是4的倍数的，且不是100的倍数，为闰年。（如2004年就是闰年）；
世纪闰年:公历年份是整百数的，
必须是400的倍数才是闰年（如1900年不是世纪闰年，2000年是世纪闰年）；
分析：方法名： leapYear 有参数 有返回值
*/
public class lianxi08 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
for (;;) {
int a = s.nextInt();
String ss = leapYear(a);
if (a == 0) {
break;
}
System.out.println(ss);
}
}
public static String leapYear(int a) {
String s = "";
if (a % 4 == 0 && a % 100 != 0) {
s = a + "是一个普通闰年";
} else if (a % 400 == 0) {
s = a + "是一个世纪闰年";
} else {
s = a + "不是闰年";
}
return s;
}
}
55.编写一个方法，输出大于n的最小的质数。
思路：
1、大于n的以后的数，每一个拿去判断是否是质数，
2、求质数的方法名 primeNumber 有参数 有返回值
package weekday02;
import java.util.Scanner;
/**
* @author TaoTianye
题目：编写一个方法，输出大于n的最小的质数。
思路：
1、大于n的以后的数，每一个拿去判断是否是质数，
2、求质数的方法名 primeNumber 有参数 有返回值
*/
public class lianxi09 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
int ss = primeNumber(n);
System.out.println("大于" + n + "的最小的质数为：" + ss);
}
public static int primeNumber(int n) {
for (;;) {
boolean flag = true;
for (int i = 2; i <= n / 2; i++) {
if (n % i == 0) {
flag = false;
}
}
if (flag) {
return n;
}
n++;
}
}
}
输入：100
输出：大于100的最小的质数为：101
56.输入一位十进制的数，输出其二进制
package weekday02;
import java.util.Scanner;
/**
* @author TaoTianye
题目：输入一位十进制的数，输出其二进制。
分析：十进制 a=20 20/2=10 20%2=0
10/2=5 10%2=0
5/2=2 5%2=1
2/2=1 2%2=0
1/2=0 1%2=1
20的二进制是：10100
a%2=x a被重复定义
*/
public class lianxi10 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int a = s.nextInt();
er(a);
}
//er方法是为了计算二进制数
public static void er(int a) {
int y=a;
String x="";
for(int i=0;a/2>0;i++) {
x =a%2+x;
a=a/2;
}
x =a%2+x;
System.out.println(y+" 转为二进制数为：0B"+x);
}
}
输入：20
输出：20 转为二进制数为：0B10100
57.创建方法getMax求两个数的最大值，再写一个方法getMax求3个数的最大值(方法重载overload)
package week2day03;
/**
* @author TaoTianye
题目：创建方法getMax求两个数的最大值，再写一个方法getMax求3个数的最大值(方法重载overload)
*/
public class lianxi01 {
public static void main(String[] args) {
int a=getMax(2,3);
System.out.println("两个数的最大值:"+a);
int b = getMax(2,2,5);
System.out.println("三个数的最大值:"+b);
}
public static int getMax(int a,int b) {
return a>b?a:b;
}
public static int getMax(int a,int b,int c) {
return a>b?(a>c?a:c):(b>c?b:c);
}
}
输出：
2个数的最大值:3
3个数的最大值:5
58.随机点名器，即在全班同学中随机的打印出一名同学名字。String[]
要做的随机点名器，它具备以下3个内容：
1、存储所有同学姓名
2、总览全班同学姓名
3、随机点名其中一人，打印到控制台
package week2day03;
import java.util.Random;
import java.util.Scanner;
/**
* @author TaoTianye
题目：随机点名器，即在全班同学中随机的打印出一名同学名字。String[]
要做的随机点名器，它具备以下3个内容：
1、存储所有同学姓名
2、总览全班同学姓名
3、随机点名其中一人，打印到控制台
*/
public class lianxi02 {
public static void main(String[] args) {
String[] name = new String[5];
Scanner s = new Scanner(System.in);
//输入姓名
for(int i=0;i<5;i++) {
name[i] = s.next();
}
//输出姓名
System.out.println("以下为全班同学名字：");
for(int i=0;i<5;i++) {
System.out.print(name[i]+" ");
}
System.out.println();
//随机点名
Random num = new Random();
int call = num.nextInt(5);
System.out.println("随机点的人是："+name[call]);
}
}
输入：同学1 同学2 同学3 同学4 同学5
输出：
以下为全班同学名字：
同学1 同学2 同学3 同学4 同学5
随机点的人是：同学3
59.二维数组的定义与初始化
package week2day03;
//二维数组的定义与初始化
public class lianxi03 {
public static void main(String[] args) {
//二位数组的定义
int[][] a;
int aa[][];
int[] aaa[];
//二位数组的初始化
int[][] a1 = new int[2][];
int[][] a2 = new int[2][5];
int aa1[][]=new int[2][3];
int[] a3[] = new int[6][3];
int[] b1 = new int[8];
int[] b2 = new int[4];
int[][] b = {b1,b2};
char[][]c = {{'2','4','5','6'},{'1','3'}};
System.out.println(c[0]);
}
}
输出：2456
60.求n x n 的二位数组的对角线之和（重复的值多加一遍）
package week2day03;
import java.util.Scanner;
/**
* @author TaoTianye
题目：求n x n 的二位数组的对角线之和（重复的值多加一遍）
*/
public class lianxi04 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入n");
int n = s.nextInt();
int[][] a = new int[n][n];
//输入n x n的二位数组
System.out.println("请输入二维数组的各个元素：");
for(int i=0;i<a.length;i++) {
for(int j=0;j<a[i].length;j++) {
a[i][j] = s.nextInt();
}
}
int sum = 0;// 用于两条对角线之和的存储
// 全览
System.out.println("全览：");
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j]+" ");
//求对角线之和
if (i == j || i + j == (a.length-1)) {
sum += a[i][j];
}
}
System.out.println();
}
if(a.length%2==1) {
int x=a.length/2;
sum +=a[x][x];
}
System.out.println("对角线之和为：" + sum);
}
}
**输出：**请输入n
***输入：***4
输出：请输入二维数组的各个元素：
输入：
1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1
输出：
全览：
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
对角线之和为：8
61.打印杨辉三角形(行数可以键盘录入)
方案一：
package week2day03;
import java.util.Scanner;
/**
* @author TaoTianye
题目：打印杨辉三角形(行数可以键盘录入)
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
*/
public class lianxi05 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入行数：");
int n = s.nextInt();
int[][] a = new int[n][n];
for (int i = 0; i < n; i++) {
a[i][0] = 1;
for (int j = 0; j <= i; j++) {
if (i >= 1 && j >= 1) {
a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
}
System.out.print(a[i][j] + " ");
}
System.out.println();
}
}
}
方案二：
package week2day03;
import java.util.Scanner;
/**
* @author TaoTianye
题目：打印杨辉三角形(行数可以键盘录入)
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
方案二：
*/
public class lianxi06 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入行数：");
int n = s.nextInt();
int[][] a = new int[n][n];
for(int i=0;i<n;i++) {
a[i][0]=1;
for(int j=0;j<=i;j++) {
for(int k=0;k<i;k++) {
if(j>=1) {
a[i][j] +=a[k][j-1];
}
}
System.out.print(a[i][j]+" ");
}
System.out.println();
}
}
}
请输入行数：
输入：9
输出：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
62.用递归算法求1+2+3+…+n
package week2day04;
import java.util.Scanner;
/**
* @author TaoTianye
* 题目:用递归算法求1+2+3+...+n
*/
public class lianxi01 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入一个数字n:");
int n = s.nextInt();
System.out.println("1+2+3+...+n的和为："+add(n));
}
public static int add(int n) {
if(n==1) {
return 1;
}
return add(n-1)+n;
}
}
请输入一个数字n:
输入：5
输出：
1+2+3+…+n的和为：15
63。数列1,1,2,4,7,13,24,44,…求数列的第 n项.
package week2day04;
import java.util.Scanner;
/**
* @author TaoTianye
*题目：数列1,1,2,4,7,13,24,44,...求数列的第 n项.
*
*/
public class lianxi02 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in );
int n = s.nextInt();
int ss = fun(n);
System.out.println(ss);
}
public static int fun(int n) {
if(n<3) {
return 1;
}
if(n==3) {
return 2;
}
return fun(n-3)+fun(n-1)+fun(n-2);
}
}
输入：8
输出：44
64.有N阶台阶，上楼可以一次上一阶，也可以一次上二阶。 编一个程序，计算共有多少种不同的走法。
package week2day04;
import java.util.Scanner;
/**
* @author TaoTianye
* 题目：4.有N阶台阶，上楼可以一次上一阶，也可以一次上二阶。
编一个程序，计算共有多少种不同的走法。
解释：一共n阶台阶 上楼的时候 要不就是一阶一阶的走
要不就是二阶二阶的走
要不就是一阶二阶的走
*/
public class lianxi03 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n=s.nextInt();
int count=taijie(n);
System.out.println("走"+n+"阶台阶,有"+count+"种方法");
}
public static int taijie (int n) {
if(n==1 || n==2) {
return n;
}else {
return taijie(n-1)+taijie(n-2);
//比如n=3;走3阶台阶的方法就可以看做是分别计算n=2与n=1
}
}
}
输入：7
输出：走7阶台阶,有21种方法
65.递归求数组的最大数
package week2day04;
/**
* @author TaoTianye
题目：递归求数组的最大数
思路：1、定义一个方法，比较当前索引位置的元素和最大值比哪个大,把大的数放在索引大的位置。
2、比较完之后，如果已经是数组中的最后一个元素，就返回求得的最大值，
否则继续判断当前得到的最大值和索引后一位的值哪个大。
*/
public class lianxi04 {
static int[] a = { 3,1,2,3,12,4,5,9,1};
public static void main(String[] args) {
int n = 0;
int max = getMax(n);
System.out.println(max);
}
public static int getMax(int n) {
//比较到最后的时候，最大的数已经放在了最后一个位置，n最大取到倒数第二个索引
if(n==a.length-2) {
return a[n] ;
}
//两个数比较，大的数放在靠后的位置，
if (a[n] > a[n+ 1]) {
int temp = a[n];
a[n] = a[n + 1];
a[n + 1] = temp;
}
return getMax(n+1);//递归的作用就是使索引位置向后步进
}
}
66.找到目标值在排序后的数组中的索引值（使用二分查找）
package week2day04;
import java.util.Scanner;
/**
* @author TaoTianye
* 题目：找到目标值在排序后的数组中的索引值
* 使用二分查找
*/
public final class lianxi05 {
static int[] a = {9,8,7,6,5,4,3,2,1};
static int aim ;
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
aim = s.nextInt();
int r= find(0,a.length-1);
System.out.println(r);
}
/**
* @param left 从这个元素开始查找
* @param right 到这个元素结束
* @return 返回找到的目标元素对应的索引
*/
public static int find(int left, int right) {
if (left <= right) {
int middle = (left + right) / 2;
if (a[middle] == aim) {
return middle;
}
else if(a[middle] > aim) {
return find(middle + 1, right);
}
else {
return find(left,middle-1);
}
}else {
return -1;
}
}
}
67.查找数组中第二大的数
package week2day04;
/**
* @author TaoTianye 题目：查找数组中第二大的数
* 思路：1、写一个方法，比较三个数进行排正序， 有返回值 有参数
* 2、比较完之后，如果已经是数组中的最后一个元素，就返回求得的第二大的数
*/
public class lianxi06 {
static int[] a = { 1, 3, 5, 2, 2, 7, 5, 8, 13, 34, 1, 1 };
public static void main(String[] args) {
int r = findNo2(0);
System.out.println("第二大的数为："+r);
}
public static int findNo2(int n) {// n表示索引
// 比较三个数大小并排正序
for (int i = n; i < n + 2; i++) {
if (a[i] > a[i + 1]) {
int temp = a[i];
a[i] = a[i + 1];
a[i + 1] = temp;
}
}
if (n == a.length - 3) {
return a[n - 1];
}
return findNo2(n + 1);
// 重复比较三个数的大小,n最大就是倒数第三个索引
}
}
输出：第二大的数为：13
68.一个人赶着鸭子去每个村庄卖，每经过一个村子卖去所赶鸭子的一半又一只。这样他经过了七个村子后还剩两只鸭子，问他出发时共赶多少只鸭子？经过每个村子卖出多少只鸭子？
package week2day04;
/**
* @author TaoTianye
* 题目：一个人赶着鸭子去每个村庄卖，每经过一个村子卖去所赶鸭子的一半又一只。
* 这样他经过了七个村子后还剩两只鸭子，问他出发时共赶多少只鸭子？
* 经过每个村子卖出多少只鸭子？
* 分析： duckNum = 2 七个村子后 villagenum = 8
* duckNum =(2+1)*2=6 villagenum = 7
* duckNum = (6+1)*2=14 villagenum = 6
duckNum =(14+1)*2 villagenum = 5
* ....... ........
*/
public class lianxi07 {
public static void main(String[] args) {
int num = sellDuck(2,1);
System.out.println(num);
}
/**
* @param duckNum 经过村庄剩下的鸭子
* @param villageNum 经过村庄的个数=1，2，3，4，5，6，7
* @return
*/
public static int sellDuck(int duckNum,int villageNum) {
if (villageNum <0) {//鸭子总和
return duckNum;
}else if(villageNum==7) {
return (duckNum+1)*2;//在第七个村庄卖的鸭子数
}else {
duckNum = 2*(duckNum +1);//鸭子的数量在每一轮都被重复赋值
}
return sellDuck(duckNum,villageNum+1);
}
}
输出：510
69.根据如下需求，按照标准格式完成代码
1. 手机类Phone
属性:品牌brand,价格price
行为:打电话call,发短信sendMessage,玩游戏,playGame
2. 把属性都作为私有，并提供get/set 方法以及适当的构造方法。
3. 编写测试类PhoneTest进行测试：为Phone对象的属性赋予初始值，
并调用Phone对象的各个方法，看看输出是否正确
类：phone
package bean;
/**
* @author TaoTianye
根据如下需求，按照标准格式完成代码
1. 手机类Phone
属性:品牌brand,价格price
行为:打电话call,发短信sendMessage,玩游戏,playGame
2. 把属性都作为私有，并提供get/set 方法以及适当的构造方法。
*/
public class Phone {
//属性 属性都作为私有
private String brand;//品牌
private int price;//价格
//无参构造 快捷键 Alt+shift+s 再按o 取消勾选所有属性
public Phone() {
super();
}
//有参构造 快捷键 Alt+shift+s 再按o 勾选所有属性
public Phone(String brand, int price) {
super();
this.brand = brand;
this.price = price;
}
//生成 get/set 方法 快捷键Alt+shift+s 选择Generate Getters and Setters
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
}
测试phone这个类：
package week2day05;
import bean.Phone;
/**
* @author TaoTianye
3. 编写测试类PhoneTest进行测试：为Phone对象的属性赋予初始值，
并调用Phone对象的各个方法，看看输出是否正确
*/
public class PhoneTest {
public static void main(String[] args) {
Phone one = new Phone();//无参数
Phone two = new Phone("华为",5000);//有参数
//无参数赋值
one.setBrand("苹果");
one.setPrice(80000);
//无参数打印
System.out.println(one.getBrand());
System.out.println(one.getPrice());
//有参数打印
System.out.println(two.getBrand());
System.out.println(two.getPrice());
}
}
结果：
苹果
80000
华为
5000
70.根据如下需求，按照标准格式完成代码
- 学生类Student2
属性:语文成绩chinese，数学成绩math，英语成绩english
行为:求总成绩的方法getSum()。 - 把属性都作为私有，并提供get/set 方法以及适当的构造方法。
- 编写测试类StudentTest进行测试：为Student对象的属性赋予初始值，
并调用Student对象的getSum方法，看看输出是否正确
学生类Student2:
package bean;
/**
* @author TaoTianye
需求二：
1. 学生类Student2
属性:语文成绩chinese，数学成绩math，英语成绩english
行为:求总成绩的方法getSum()。
2. 把属性都作为私有，并提供get/set 方法以及适当的构造方法。
*/
public class Student2 {
// 属性 都作为私有
private int chinese;
private int math;
private int english;
// 无参构造
public Student2() {
super();
}
// 有参构造
public Student2(int chinese, int math, int english) {
super();
this.chinese = chinese;
this.math = math;
this.english = english;
}
// 属性赋值
public int getChinese() {
return chinese;
}
public void setChinese(int chinese) {
if (chinese > 100 || chinese < 0) {
System.out.println("分数不在合理范围");
this.chinese = chinese;
} else {
this.chinese = chinese;
}
}
public int getMath() {
return math;
}
public void setMath(int math) {
if (math > 100 || math < 0) {
System.out.println("成绩不在合理范围");
this.math = math;
} else {
this.math = math;
}
}
public int getEnglish() {
return english;
}
public void setEnglish(int english) {
if (english < 0 || english > 100) {
System.out.println("成绩不在合理范围");
this.english = english;
} else {
this.english = english;
}
}
// 求和方法getSum
public int getSum(int chinese, int math, int english) {
return chinese + math + english;
}
}
测试类student2：
package week2day05;
import bean.Student2;
/**
* @author TaoTianye
3. 编写测试类StudentTest进行测试：为Student对象的属性赋予初始值，
并调用Student对象的getSum方法，看看输出是否正确
*/
public class Student2Test {
public static void main(String[] args) {
Student2 stu1 = new Student2(89,45,99);//有参数
Student2 stu2 = new Student2();//无参数
Student2 stu3 = new Student2(89,75,99);//有参数
//无参构造的属性赋值
stu2.setChinese(56);
stu2.setEnglish(56);
stu2.setMath(87);
//打印属性
System.out.println("学生1的成绩如下：");
System.out.println("语文成绩为："+stu1.getChinese());
System.out.println("数学成绩为："+stu1.getMath());
System.out.println("英语成绩为："+stu1.getEnglish());
System.out.println();
System.out.println("学生2的成绩如下：");
System.out.println("语文成绩为："+stu2.getChinese());
System.out.println("数学成绩为："+stu2.getMath());
System.out.println("英语成绩为："+stu2.getEnglish());
System.out.println();
System.out.println("学生3的成绩如下：");
System.out.println("语文成绩为："+stu3.getChinese());
System.out.println("数学成绩为："+stu3.getMath());
System.out.println("英语成绩为："+stu3.getEnglish());
System.out.println();
//调用getSum方法
int sum1 = stu1.getSum(stu1.getChinese(), stu1.getMath(), stu1.getEnglish());
System.out.println("学生1的总成绩为："+sum1);
int sum2 = stu2.getSum(stu2.getChinese(),stu2.getEnglish(),stu2.getMath());
System.out.println("学生2的总成绩为："+sum2);
int sum3 = stu3.getSum(stu3.getChinese(),stu3.getEnglish(),stu3.getMath());
System.out.println("学生3的总成绩为："+sum3);
}
}
结果输出：学生1的成绩如下：
语文成绩为：89
数学成绩为：45
英语成绩为：99
学生2的成绩如下：
语文成绩为：56
数学成绩为：87
英语成绩为：56
学生3的成绩如下：
语文成绩为：89
数学成绩为：75
英语成绩为：99
学生1的总成绩为：233
学生2的总成绩为：199
学生3的总成绩为：263
71。根据如下需求，按照标准格式完成代码
- 编写一个类Book:
属性：名称（title）、页数（pageNum），其中页数不能少于200页，否则输出错误信息，并赋予默认值200。
方法: detail，用来在控制台输出每本教材的名称和页数 - 把属性都作为私有，并提供get/set 方法以及适当的构造方法。
- 编写测试类BookTest进行测试：为Book对象的属性赋予初始值，
并调用Book对象的detail方法，看看输出是否正确
类Book：
package bean;
/**
* @author TaoTianye
需求三：
1. 编写一个类Book:
属性：名称（title）、页数（pageNum），其中页数不能少于200页，否则输出错误信息，并赋予默认值200。
方法: detail，用来在控制台输出每本教材的名称和页数
2. 把属性都作为私有，并提供get/set 方法以及适当的构造方法。
*/
public class Book {
//属性都作为私有
private String title;
private int pageNum;
//有参构造
public Book(String title, int pageNum) {
super();
this.title = title;
if(pageNum >200) {
System.out.println("页数大于200，默认赋值200");
this.pageNum = 200;
}else {
this.pageNum = pageNum;
}
}
//无参构造
public Book() {
super();
}
//提供get/set 方法以及适当的构造方法
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public int getPageNum() {
return pageNum;
}
//其中页数不能少于200页，否则输出错误信息，并赋予默认值200
public void setPageNum(int pageNum) {
if(pageNum >200) {
System.out.println("页数大于200，默认赋值200");
this.pageNum = 200;
}else {
this.pageNum = pageNum;
}
}
//方法: detail，用来在控制台输出每本教材的名称和页数
public void detail(String title,int pageNum) {
System.out.println("教材名称为："+title);
System.out.println("教材页数为："+pageNum);
}
}
测试类Book：
package bean;
/**
* @author TaoTianye
需求三：
1. 编写一个类Book:
属性：名称（title）、页数（pageNum），其中页数不能少于200页，否则输出错误信息，并赋予默认值200。
方法: detail，用来在控制台输出每本教材的名称和页数
2. 把属性都作为私有，并提供get/set 方法以及适当的构造方法。
*/
public class Book {
//属性都作为私有
static int num = 1;
private String title;
private int pageNum;
//有参构造
public Book(String title, int pageNum) {
super();
this.title = title;
if(pageNum <200) {
System.out.println("图书"+(num ++)+"页数小于200，默认赋值200");
this.pageNum = 200;
}else {
this.pageNum = pageNum;
}
}
//无参构造
public Book() {
super();
}
//提供get/set 方法以及适当的构造方法
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public int getPageNum() {
return pageNum;
}
//其中页数不能少于200页，否则输出错误信息，并赋予默认值200
public void setPageNum(int pageNum) {
if(pageNum < 200) {
System.out.println("图书"+(num++)+"页数小于200，默认赋值200");
this.pageNum = 200;
}else {
this.pageNum = pageNum;
}
}
//方法: detail，用来在控制台输出每本教材的名称和页数
public void detail(String title,int pageNum) {
System.out.println("教材名称为："+title);
System.out.println("教材页数为："+pageNum);
}
}
测试类Book：
package week2day05;
import bean.Book;
/**
* @author TaoTianye
3. 编写测试类BookTest进行测试：为Book对象的属性赋予初始值，
并调用Book对象的detail方法，看看输出是否正确
*/
public class BookText {
public static void main(String[] args) {
//创建对象
Book book1 = new Book();
Book book2 = new Book("语文教材",234);
Book book3 = new Book("英语教材",23);
//属性赋值
book1.setTitle("数学教材");
book1.setPageNum(198);
//打印属性 调用Book对象的detail方法
book1.detail(book1.getTitle(), book1.getPageNum());
book2.detail(book2.getTitle(), book2.getPageNum());
book3.detail(book3.getTitle(), book3.getPageNum());
}
}
输出：
图书1页数小于200，默认赋值200
图书2页数小于200，默认赋值200
教材名称为：数学教材
教材页数为：200
教材名称为：语文教材
教材页数为：234
教材名称为：英语教材
教材页数为：200
4760
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
