Java面向对象基础练习题（含答案超详细）
第1题
案例：
声明一个日期类MyDate，包含属性：年、月、日
声明一个Test02测试类，并在main方法中，创建3个日期对象，一个是你的出生日期，一个是随机定义的日期，一个是今年过年的日期，并打印显示
系统预定义的日期类型。jdk1.8+提供了2套日期类型
java.util.Date
public class Date implements java.io.Serializable,Cloneable,
Comparable{
private transient long fastTime; //具体的日期是采用从1970-1-1 0：0：0 到指定日期的毫秒值进行存储。 年-1900 月-1
} 自定义类
public class MyDate{ //默认继承于java.lang.Object类，不需要import语句导入。
int year; //成员属性 范围限定词默认为package，只是同包可见
int month;
int date;
public void setYear(int year){ //方法名称命名的规则为小写字母开头，大写字母分词
this.year = year;
}
public String toString(){
return year + "年" + month + "月" + date + "日";
}
}测试类
public class Test02{
public static void main(String[] args){
MyDate d1 = new MyDate();
d1.year = 1972;
d1.month = 4;
d1.date = 30;
System.out.println(d1.toString());
}
}第2题
案例：
声明公民类Citizen，包含属性：姓名，生日，身份证号，其中姓名是String类型，生日是MyDate类型，身份证号也是String类型。
声明Test03测试类，在main方法中创建你们家庭成员的几个对象，并打印信息。
public class Citizen{
protected String name;
public MyDate birth;
private String ID;
//私有属性添加get/set方法访问
public String getID() {
return ID;
}
public void setID(String iD) {
ID = iD;
}
public String toString() {
return "家庭成员 " + "姓名：" + name + " 出生日期：" + birth + " 身份证号：" + this.ID;
}
}测试类
public class Test03 {
public static void main(String[] args) {
Citizen citizen = new Citizen();
citizen.name = "张三";
MyDate mydate = new MyDate();
mydate .setYear(2021);
mydate .setMonth(03);
mydate .setDate(06);
citizen.birth = d1;
citizen.setID("123456789");
System.out.println(citizen.toString());
}
}第3题
案例：
声明一个日期类MyDate，包含属性：年、月、日，并在MyDate类中声明几个方法：
1、boolean isLeapYear()：判断当前日期的是闰年吗？
2、void set(int y, int m, int d)：修改年，月，日为新日期
3、void puls(int years, int months, int days)：加上years年，months月，days天后的日期
并在测试类Test04的main方法中创建对象，并调用测试
public class MyDate{
private int year;
private int month;
private int date;
//判断当前日期是否是闰年
public boolean isLeapYear(){
if(year % 4 == 0 && year / 100 !=0)
return ture;
else if(year % 400 == 0)
return true;
else
return false;
}
//修改年，月，日为新日期
public void set(int y,int m, int d){
year = y;
month = m;
date = d;
}
//加上years年，months月，days天后的日期
public void puls(int years, int months, int days){
this.year += years;
this.date += days;
this.month += months;
if (this.month > 12) {
this.year++;
this.month -= 12;
}
//这里得判断加完的月份值是否超过12，天数是否超过本月的天数
//如果超过则月份和天数做出相应的变化
//2月有闰年的存在 所以需要单独进行判断
//特殊12月 如果超出则需要对年进行修稿
while (true) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10) {
if (date > 31) {
date -= 31;
month++;
} else
break;
} else if (month == 4 || month == 6 || month == 9 || month == 11) {
if (date > 30) {
date -= 30;
month++;
} else
break;
} else if (month == 2) {
//调用当前类中的方法 判断是否是闰年
if (isLeapYear()) {
if (date > 28) {
date -= 28;
month++;
} else
break;
} else if (date > 29) {
date -= 29;
month++;
} else
break;
} else if (month == 12) {
if (date > 31) {
date -= 31;
month = 1;
year++;
}
}
}
}
}测试类
public class Test04 {
public static void main(String[] args) {
MyDate date = new MyDate();
//调用方法 修改年，月，日为新日期
date.set(2001, 3, 6);
System.out.println(date);
// 判断是否为闰年
System.out.println(date.isLeapYear());
//加上years年，months月，days天后的日期
date.puls(20, 9, 3);
System.out.println(date);
}
}第4题
案例：
声明一个三角形类Triangle，包含属性：a,b,c，表示三条边，包含几个方法：
1、boolean isRightTriangle()：判断是否是一个直角三角形
2、boolean isIsoscelesTriangle()：判断是否是一个等腰三角形
3、boolean isEquilateralTriangle()：判断是否是一个等边三角形
4、double getArea()：根据三条边，用海伦公式求面积
5、double getLength()：求周长
并在测试类Test05的main方法中调用测试
public class Triangle {
private double a;
private double b;
private double c;
// 判断是否为直角三角形
public boolean isRightTriangle() {
// 首先判断值的合法性
if (a > 0 && b > 0 && c > 0) {
// 判断是否构成三角形
if (a + b > c && a + c > b && b + c > a) {
// 判断是否为直角三角形
if (a * a == b * b + c * c || b * b == a * a + c * c || c * c == a * a + b * b) {
return true;
}
}
}
return false;
}
// 判断是否为等腰三角形
public boolean islsoscelesTriangle() {
// 判断值的合法性
if (a > 0 && b > 0 && c > 0) {
// 判断是否能构成三角形
if (a + b > c && a + c > b && b + c > a) {
// 判断是否为等腰三角形
if (a == b || b == c || a == c) {
return true;
}
}
}
return false;
}
//判断是否为等边三角形
public boolean isEquilateralTriangle() {
// 判断值的合法性
if (a > 0 && b > 0 && c > 0) {
// 判断是否能构成三角形
if (a + b > c && a + c > b && b + c > a) {
// 判断是否为等边三角形
if (a == b && b == c) {
return true;
}
}
}
return false;
}
//计算三角形的周长
public double getLength() {
// 判断值的合法性
if (a > 0 && b > 0 && c > 0) {
// 判断是否能构成三角形
if (a + b > c && a + c > b && b + c > a) {
return (a + b + c);
}
}
return -1;
}
//计算三角形的面积（利用海伦公式）
public double getArea() {
// 判断值的合法性
if (a > 0 && b > 0 && c > 0) {
// 判断是否能构成三角形
if (a + b > c && a + c > b && b + c > a) {
double p = (a + b + c) / 2;
double q = (p * (p - a) * (p - b) * (p - c));
return Math.sqrt(q);
}
}
return -1;
}
//私有类外访问 添加get/set方法
public double getA() {
return a;
}
public void setA(double a) {
this.a = a;
}
public double getB() {
return b;
}
public void setB(double b) {
this.b = b;
}
public double getC() {
return c;
}
public void setC(double c) {
this.c = c;
}
}测试类
public class Test05 {
public static void main(String[] args) {
Triangle triangle = new Triangle(); //调用无参构造器
// 私有属性通过set方法修改值 get方法获取
triangle.setA(3.);
triangle.setB(4.);
triangle.setC(5.);
//通过对象名.方法名调用方法
System.out.println("是否为等边三角形："+triangle.isEquilateralTriangle());
System.out.println("是否为等腰三角形："+triangle.islsoscelesTriangle());
System.out.println("是否为直角三角形："+triangle.isRightTriangle());
System.out.println("面积为："+triangle.getArea());
System.out.println("周长为："+triangle.getLength());
}
}第5题
工具类的概念和static方法
定义对象的目标是为了封装数据和数据相关操作，同一个类属的对象相互堵路
public class A{ public void pp(){} } /* 在测试类中 * 正常调用方法pp: new A().pp(); * 不能 A.pp(); * 在类A内部可以直接调用 */ public class A{ public void pp() {} public void cc() { pp(); //允许方法之间相互调用 } } 工具类中只有操作，没有数据的封装，则可以定义访问为static静态的。静态方法不需要创建对象在进行调用
public class A{ public static void pp(){} } /* * 在测试类中 * 通过 A.pp()进行调用 也可以使用new A().pp(); 但是不建议 */
案例：
声明一个数学计算工具类MathTools，包含如下方法：
1、int add(int a, int b)：求a+b
2、int subtract(int a,int b)：求a-b
3、int mutiply(int a, int b)：求a*b
4、int divide(int a, int b)：求a/b
5、int remainder(int a, int b)：求a%b
6、int max(int a, int b)：求a和b中的最大值
7、int min(int a, int b)：求a和b中的最小值
8、boolean equals(int a, int b)：判断a和b是否相等
9、boolean isEven(int a)：判断a是否是偶数
10、boolean isPrimeNumer(int a)：判断a是否是素数
11、int round(double d)：返回d的四舍五入后的整数值
public class MathTools {
// 如果没有定义构造器 系统默认提供无参构造器
// 如果自定义构造器 那么应该提供无参构造器（建议做法）
public MathTools() {
}
// a+b
public static int add(int a, int b) {
int c = a + b;
return c;
}
// a-b
public static int subtract(int a, int b) {
int c = a - b;
return c;
}
// a*b
public static int mutiply(int a, int b) {
int c = a * b;
return c;
}
// a%b
public static int remainder(int a, int b) {
int c = a % b;
return c;
}
// a和b中的最大值
public static int Max(int a, int b) {
int c = Math.max(a, b);
return c;
}
// a和b中的最小值
public static int Min(int a, int b) {
int c = Math.min(a, b);
return c;
}
// 判断a和b是否相等
public static boolean equals(int a, int b) {
if (a == b) {
return true;
}
return false;
}
// 判断a是否是偶数
public static boolean isEven(int a) {
if (a % 2 == 0) {
return true;
}
return false;
}
// 返回四舍五入后的整数值
public static int round(double a) {
// 传入的参数为double类型 所以需要进行窄化操作
int c = (int) Math.round(a);
return c;
}
// a/b
public static int Divide(int a, int b) {
int c = a / b;
return c;
}
// 判断a是否是素数
public boolean isPrimeNumber(int a) {
int count = 0;
for (int i = 2; i < a; i++) {
if (a % i == 0) {
count++;
break;
}
}
if (count == 0)
return true;
else
return false;
}
}声明一个Test06测试类，并在main方法中调用测试
public class Test06 {
public static void main(String[] args) {
new MathTools();
// 调用方法 判断是否为素数
boolean res = MathTools.isPrimeNumber(13);
System.out.println(res);
// 两数和
int sum = MathTools.add(2, 3);
System.out.println(sum);
// 四舍五入
int digital = MathTools.round(18.2);
System.out.println(digital);
}
}第6题
案例：练习排序算法和折半查找法以及System.arrayCopy方法
声明一个数组管理工具类MyArrays，包含如下方法：
1、void sort(int[] arr)：可以为任意一维整型数组arr实现从小到大排序
2、int indexOf(int[] arr, int value)：可以在任意一维整型数组arr中查找value值的下标，如果不存在返回-1
3、int[] copy(int[] arr, int len)：可以实现从任意一维数组arr中复制一个新数组返回，新数组的长度为len，从arr[0]开始复制
import java.util.Arrays;
public class MyArrays {
// 定义方法 利用冒泡排序对数组进行排序(自然排序)
public static void sort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int k = 0; k < arr.length - i; k++) {
if (arr[k] > arr[k + 1]) {
int temp = arr[k + 1];
arr[k + 1] = arr[k];
arr[k] = temp;
}
}
}
}
// 在任意一维整型数组arr中查找value值的下标，如果不存在返回-1
public static int indexOf(int[] arr, int value) {
sort(arr); // 折半查找的前提是有序的 所以调用冒泡排序对数组进行排序
return binarySearch(arr, value, 0, arr.length - 1);//利用折半查找的方法寻找value值的下标
}
// 折半查找
public static int binarySearch(int[] arr, int target, int begin, int end) {
if (begin > end)
return -1;
int mid = (begin + end) / 2;
if (arr[mid] < target) {
begin = mid + 1;
} else if (arr[mid] > target) {
end = mid - 1;
} else
return mid;
return binarySearch(arr, target, begin, end); // 调用自身
}
// 实现从任意一维数组arr中复制一个新数组返回，新数组的长度为len，从arr[0]开始复制
public static int[] copy(int[] arr, int len) {
int[] res = new int[len];
int newLen = Math.min(len, arr.length);
System.arraycopy(arr, 0, res, 0, newLen);
return res;
}
// 输出数组
public static void showArray(int[] arr) {
System.out.println(Arrays.toString(arr));
}
}声明一个Test07测试类，并在main方法中调用测试
import java.util.Arrays;
import java.util.Random;
public class Test07 {
public static void main(String[] args) {
Random random = new Random();
// 生成[10,20)以内的随机数(int类型)
int[] arr = new int[random.nextInt(10) + 10];
// 生成随机数组
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) (Math.random() * 100);
}
new MyArrays();
// 调用静态方法 冒泡排序
MyArrays.sort(arr);
// 调用方法输出数组
MyArrays.showArray(arr);
int[] arr1 = new int[] { 6, 2, 1, 3, 8, 4, 56, 7, 9 };
// 调用方法 寻找value=56的下标
int temp = MyArrays.indexOf(arr1, 56);
System.out.println("数组中56的下标为：" + temp);
// 实现数组的复制
int[] res = MyArrays.copy(arr, 10);
System.out.println("复制后的数组为：" + Arrays.toString(res));
}
}
第7题
案例：
声明一个常识工具类DateCommonsTools，包含如下方法：
1、String getWeekName(int week)：根据星期值，返回对应的英语单词
2、String getMonthName(int month)：根据月份值，返回对应的英语单词
3、int getTotalDaysOfMonth(int year, int month)：返回某月的总天数
4、int getTotalDaysOfYear(int year)：获取某年的总天数
5、boolean isLeapYear(int year)：判断某年是否是闰年
public class DateCommonsTools {
//根据星期值，返回对应的英语单词
public String getWeekName(int week) {
String[] arr = new String[] { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Staurday", "Sunday" };
if (week < 7 && week > 0)
return arr[week];
else
return "输入有误！";
}
//根据月份值，返回对应的英语单词
public String getMonthName(int month) {
String[] arr = new String[] { "January", "February", "March", "April", "May", "June", "July", "Auguet",
"September", "October", "November", "December" };
if (month > 0 && month < 13)
return arr[month];
else
return "";
}
//返回某年某月的总天数
public int getTotalDaysOfMonth(int year, int month) {
int res = 0;
if (month > 0 && month < 32) {
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
res = 31;
break;
case 4:
case 6:
case 9:
case 11:
res = 30;
break;
case 2:
if (isLeapYear(year))
res = 28;
else
res = 29;
break;
default:
System.out.println("输入有误！");
}
}
return res;
}
//获取某年的总天数
public int getTotalDaysOfYear(int year) {
if (isLeapYear(year))
return 366;
else
return 356;
}
//判断是否为闰年
private static boolean isLeapYear(int year) {
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
return true;
else
return false;
}
}声明一个Test08测试类，并在main方法中调用测试
public class Test08 {
public static void main(String[] args) {
new DateCommonsTools();
String WeekName = DateCommonsTools.getWeekName(2);
System.out.println(WeekName);
String MonthName = DateCommonsTools.getMonthName(10);
System.out.println(MonthName);
int MonthNum = DateCommonsTools.getTotalDaysOfMonth(2020, 2);
System.out.println(MonthNum);
int YearNum = DateCommonsTools.getTotalDaysOfYear(2020);
System.out.println(YearNum);
}
}