方法的练习题
目录
1、定义一个几何图形工具类，在类中定义如下方法：
定义一个静态方法，实现返回正方形周长
定义一个静态方法，实现返回正方形面积
定义一个静态方法，实现返回长方形周长
定义一个静态方法，实现返回长方形面积
定义一个静态方法，实现返回圆形周长
定义一个静态方法，实现返回圆形面积
定义一个静态方法，实现返回正方体面积
定义一个静态方法，实现返回正方体体积
定义一个静态方法，实现返回长方体面积
定义一个静态方法，实现返回长方体体积
定义一个静态方法，实现返回圆柱体面积
定义一个静态方法，实现返回圆柱体体积
2、定义一个数组工具类，在类中定义如下方法：
1)定义一个静态方法，实现求int类型数组最大值
2)定义一个静态方法，实现求int类型数组最小值
3)定义一个静态方法，实现求int类型数组所有元素之和
4)定义一个静态方法，实现求int类型数组升序排序
5)定义一个静态方法，实现求int类型数组降序排序
6)定义一个静态方法，实现求int类型数组元素逆序输出
7)定义一个静态方法，实现查找指定int类型数组中是否包含指定值
3、定义一个日期工具类，在类中定义如下方法：
1)定义一个静态方法，实现判断指定年份是闰年还是平年的方法
2)定义一个静态方法，实现求一个指定日期是这一年的第几天
3)定义一个静态方法，实现求指定日期处于哪一个季节
1、定义一个几何图形工具类，在类中定义如下方法：
定义一个静态方法，实现返回正方形周长
定义一个静态方法，实现返回正方形面积
定义一个静态方法，实现返回长方形周长
定义一个静态方法，实现返回长方形面积
定义一个静态方法，实现返回圆形周长
定义一个静态方法，实现返回圆形面积
定义一个静态方法，实现返回正方体面积
定义一个静态方法，实现返回正方体体积
定义一个静态方法，实现返回长方体面积
定义一个静态方法，实现返回长方体体积
定义一个静态方法，实现返回圆柱体面积
定义一个静态方法，实现返回圆柱体体积
package com.nanchu.classpractice.tool;
public class GeometricGraphicsToolClass {
//1）定义一个静态方法，实现返回正方形周长
public static double squarePerimeter(double length){
return 4*length;
}
//2）定义一个静态方法，实现返回正方形面积
public static double squareArea(double length){
return length*length;
}
//3）定义一个静态方法，实现返回长方形周长
public static double rectanglePerimeter(double length,double width){
return (length+width)*2;
}
//4）定义一个静态方法，实现返回长方形面积
public static double rectangleArea(double length,double width){
return length*width;
}
//5）定义一个静态方法，实现返回圆形周长
public static double circlePerimeter(double radius){
return 3.14*2*radius;
}
//6）定义一个静态方法，实现返回圆形面积
public static double circleArea(double radius){
return 3.14*Math.pow(radius,2);
}
//7）定义一个静态方法，实现返回正方体面积
public static double cubeArea(double lenght){
return Math.pow(lenght,2)*6;
}
//8）定义一个静态方法，实现返回正方体体积
public static double cubeVolume(double lenght){
return Math.pow(lenght,3);
}
//9）定义一个静态方法，实现返回长方体面积
public static double cuboidArea(double lenght,double width,double high){
return lenght*width*2+lenght*high*2+lenght*high*2;
}
//10）定义一个静态方法，实现返回长方体体积
public static double cuboidVolume(double lenght,double width,double high){
return lenght*width*high;
}
//11）定义一个静态方法，实现返回圆柱体面积
public static double cylinderArea(double radius,double high){
return 2*3.14*Math.pow(radius,2)+2*3.14*radius*high;
}
//12）定义一个静态方法，实现返回圆柱体体积
public static double cylinderVolume(double radius,double high){
return 3.14*radius*radius*high;
}
}
package com.nanchu.classpractice;
import com.nanchu.classpractice.tool.GeometricGraphicsToolClass;
/**
* @Author 南初
* @Create 2024/1/16 14:01
* @Version 1.0
*/
public class ToolOne {
public static void main(String[] args) {
GeometricGraphicsToolClass tooltest= new GeometricGraphicsToolClass();
System.out.println("正方形周长："+tooltest.squarePerimeter(3));
System.out.println("正方形面积："+tooltest.squareArea(3));
System.out.println("长方形周长："+tooltest.rectanglePerimeter(3,4));
System.out.println("长方形面积："+tooltest.rectangleArea(3,4));
System.out.println("圆形周长："+tooltest.circlePerimeter(3));
System.out.println("圆形面积："+tooltest.circleArea(3));
System.out.println("正方体面积："+tooltest.cubeArea(3));
System.out.println("正方体体积："+tooltest.cubeVolume(3));
System.out.println("长方体面积："+tooltest.cuboidArea(3,4,5));
System.out.println("长方体体积："+tooltest.cuboidVolume(3,4,5));
System.out.println("圆柱体面积："+tooltest.cylinderArea(3,4));
System.out.println("圆柱体体积："+tooltest.cylinderVolume(3,4));
}
}
因为是静态方法，这里的方法调用也可以使用类名.方法名，例如(GeometricGraphicsToolClass.circleArea(3))直接调用，读者可以自行尝试。
2、定义一个数组工具类，在类中定义如下方法：
1)定义一个静态方法，实现求int类型数组最大值
2)定义一个静态方法，实现求int类型数组最小值
3)定义一个静态方法，实现求int类型数组所有元素之和
4)定义一个静态方法，实现求int类型数组升序排序
5)定义一个静态方法，实现求int类型数组降序排序
6)定义一个静态方法，实现求int类型数组元素逆序输出
7)定义一个静态方法，实现查找指定int类型数组中是否包含指定值
package com.nanchu.classpractice.tool;
/**
* @Author 南初
* @Create 2024/1/16 14:14
* @Version 1.0
*/
public class ArrayTool {
//1）定义一个静态方法，实现求int类型数组最大值
public static void arrayMax(int[] arr){
int max=arr[0];
for(int i =0;iarr[i])
min = arr[i];
}
System.out.println("该数组中最小值为："+min);
}
// 3）定义一个静态方法，实现求int类型数组所有元素之和
public static void arraySum(int[] arr){
int sum=0;
for(int i=0;iarr[j+1]){
int temp= arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.print("升序排序后数组为：");
for(int i:arr){
System.out.print(i+"\t");
}
System.out.print("\n");
}
// 5）定义一个静态方法，实现求int类型数组降序排序
public static void arrayHighLow(int[] arr){
//这里使用的是冒泡排序
for(int i=1;i=0;i--){
System.out.print(arr[i]+"\t");
}
System.out.print("\n");
}
// 7）定义一个静态方法，实现查找指定int类型数组中是否包含指定值
public static void findNum(int[] arr,int num){
for(int i=0;i<=arr.length;i++){
if(arr[i]==num){
System.out.print("数组为：");
for(int x:arr)
System.out.print(x);
System.out.println();
System.out.println(num+"在该数组中的下标为："+i);
break;
}else if(i == arr.length){
System.out.println("该数组中不包括该数字！");
}
}
}
}
package com.nanchu.classpractice;
import com.nanchu.classpractice.tool.ArrayTool;
public class ToolTwo {
public static void main(String[] args) {
ArrayTool arrtool = new ArrayTool();
int[] arr ={4,1,2,3,5,6,8,9,7};
arrtool.arrayMax(arr);
System.out.println("----------------------");
arrtool.arrayMin(arr);
System.out.println("----------------------");
arrtool.arraySum(arr);
System.out.println("----------------------");
arrtool.arrayLowHigh(arr);
System.out.println("----------------------");
arrtool.arrayHighLow(arr);
System.out.println("----------------------");
arrtool.reversedOrder(arr);
System.out.println("----------------------");
arrtool.findNum(arr,3);
}
} 因为是静态方法，这里的方法调用也可以使用类名.方法名直接调用，读者可以自行尝试。
3、定义一个日期工具类，在类中定义如下方法：
1)定义一个静态方法，实现判断指定年份是闰年还是平年的方法
2)定义一个静态方法，实现求一个指定日期是这一年的第几天
3)定义一个静态方法，实现求指定日期处于哪一个季节
package com.nanchu.classpractice.tool;
/**
* @Author 南初
* @Create 2024/1/16 14:50
* @Version 1.0
*/
public class DateThree {
//1）定义一个静态方法，实现判断指定年份是闰年还是平年的方法
public static void Year(int year){
if((year%4==0&&year%100!=0)||year%400==0){
System.out.println(year+"是闰年");
}else{
System.out.println(year+"是平年");
}
}
//2）定义一个静态方法，实现求一个指定日期是这一年的第几天
public static void Days(int year,int month,int day){
//总天数sum, date 标记每个月有几天
int sum=0,date=0;
//标记是否是闰年
int x=0;
if((year%4==0 && year%100!=0) || year%400==0)
x=1;
for(int i=1;i<=month-1;i++){
switch(i)
{
case 1 : date = 31;break;
case 2 :
{
if(x == 1){
date = 29;break;
} else
date = 28;break;
}
case 3 :date = 31;break;
case 4 :date = 30;break;
case 5 :date = 31;break;
case 6 :date = 30;break;
case 7 :date = 31;break;
case 8 :date = 31;break;
case 9 :date = 30;break;
case 10 :date = 31;break;
case 11 :date = 30;break;
case 12 :date = 31;break;
}
sum+=date;
}
sum+=day;
System.out.println(year+"年"+month+"月"+day+"日是这一年的第"+sum+"天");
}
//3）定义一个静态方法，实现求指定日期处于哪一个季节
public static void season(int month){
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;
}
}
}
package com.nanchu.classpractice;
import com.nanchu.classpractice.tool.DateThree;
public class ToolThree {
public static void main(String[] args) {
DateThree date = new DateThree();
date.Year(2024);
date.Days(2024,3,1);
date.season(1);
}
}
因为是静态方法，这里的方法调用也可以使用类名.方法名直接调用，读者可以自行尝试。