第06章_面向对象编程（基础）拓展练习(求三角形面积,猴子吃桃,圆类,学生类,矩形类)

文章目录

第06章_面向对象编程（基础）拓展练习
- - 1、圆类
  - 2、学生类
  - 3、MyInt类
  - 4、MyDate日期类-1
  - 5、MyDate日期类-2
  - 6、数学计算工具类
  - 7、常识工具类
  - 8、学生对象数组
  - 9、员工管理类-1
  - 10、员工管理类-2
  - 11、比较大小
  - 12、数组排序和遍历
  - 13、求三角形面积
  - 14、图形工具类
  - 15、Count类
  - 16、PassParamDemo类
  - 17、矩形类
  - 18、矩形类
  - 19、三角形类
  - 20、猴子吃桃

第06章_面向对象编程（基础）拓展练习

1、圆类

（1）声明一个圆的图形类，包含实例变量/属性：半径

（2）在测试类的main中，创建2个圆类的对象，并给两个圆对象的半径属性赋值，最后显示两个圆的半径值、周长和面积值

提示：圆周率可以使用Math.PI

public class Circle {
    double radius;
}

public class Exercise1 {
    public static void main(String[] args) {
        //创建两个Circle圆对象
        Circle c1 = new Circle();
        Circle c2 = new Circle();

        //为两个圆对象的半径属性赋值
        c1.radius = 1.2;
        c2.radius = 2.5;

        //显示
        System.out.println("c1的半径：" + c1.radius + "，周长：" + 2 * Math.PI * c1.radius + "，面积：" + Math.PI * c1.radius * c1.radius);
        System.out.println("c2的半径：" + c2.radius + "，周长：" + 2 * Math.PI * c2.radius  + "，面积：" + Math.PI * c2.radius * c2.radius);
    }
}

2、学生类

（1）声明一个学生类，包含实例变量/属性：姓名和成绩

（2）在测试类的main中，创建2个学生类的对象，并给两个学生对象的姓名和成绩赋值，最后输出显示

public class Student {
    String name;
    int score;
}

public class Exercise2 {
    public static void main(String[] args) {
        //创建2个学生类的对象
        Student s1 = new Student();
        Student s2 = new Student();

        //给两个学生对象的姓名和成绩赋值
        s1.name = "张三";
        s1.score = 89;

        s2.name = "李四";
        s2.score = 74;

        //显示
        System.out.println("s1学生对象的姓名：" + s1.name + "，成绩：" + s1.score);
        System.out.println("s2学生对象的姓名：" + s2.name + "，成绩：" + s2.score);
    }
}

3、MyInt类

（1）声明一个MyInt类，

包含一个int类型的value属性
包含一个方法boolean isNatural()方法，用于判断value属性值是否是自然数。自然数是大于等于0的整数。
包含一个方法int approximateNumberCount()方法，用于返回value属性值的约数个数。在[1, value]之间可以把value整除的整数都是value的约数。
包含一个方法boolean isPrimeNumber()方法，用于判断value属性值是否是素数。如果value值在[1, value]之间只有1和value本身两个约数，并且value是大于1的自然数，那么value就是素数。
包含一个方法int[] getAllPrimeNumber()方法，用于返回value属性值的所有约数。返回[1, value]之间可以把value整除的所有整数。

（2）测试类的main中调用测试

public class MyInt {
    int value;

    public boolean isNatural(){
        return value >= 0;
    }

    public int approximateNumberCount(){
        int count = 0;
        for(int i=1; i<=value; i++){
            if(value%i==0){
                count++;
            }
        }
        return count;
    }

    public boolean isPrimeNumber(){
        return value > 1 && approximateNumberCount()==2;
    }

    public int[] getAllApproximateNumber(){
        int[] all = new int[approximateNumberCount()];
        for(int i=1,j=0; i<=value; i++){
            if(value%i==0){
                all[j++] = i;
            }
        }
        return all;
    }

}

public class Exercise3 {
    public static void main(String[] args) {
        MyInt myInt1 = new MyInt();
        myInt1.value = 8;
        System.out.println("myInt1是" + myInt1.value);
        System.out.println("myInt1是自然数吗：" + myInt1.isNatural());
        System.out.println("myInt1的约数个数：" + myInt1.approximateNumberCount());
        System.out.println("myInt1是素数吗：" + myInt1.isPrimeNumber());
        int[] allPrimeNumber = myInt1.getAllApproximateNumber();
        System.out.println("myInt1的所有约数有：");
        for (int i = 0; i < allPrimeNumber.length; i++) {
            System.out.println(allPrimeNumber[i]);
        }

        System.out.println("------------------------------------------");
        MyInt myInt2 = new MyInt();
        myInt2.value = 11;
        System.out.println("myInt2是" + myInt2.value);
        System.out.println("myInt2是自然数吗：" + myInt2.isNatural());
        System.out.println("myInt2的约数个数：" + myInt2.approximateNumberCount());
        System.out.println("myInt2是素数吗：" + myInt2.isPrimeNumber());
        allPrimeNumber = myInt2.getAllApproximateNumber();
        System.out.println("myInt2的所有约数有：");
        for (int i = 0; i < allPrimeNumber.length; i++) {
            System.out.println(allPrimeNumber[i]);
        }
    }
}

4、MyDate日期类-1

案例：

声明一个日期类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天后的日期

并在测试类Exercise4的main方法中创建对象，并调用测试

public class MyDate {
	int year;
	int month;
	int day;
	
	public boolean isLeapYear(){
		return year%4==0 && year%100!=0 || year%400==0;
	}
	
	public void set(int y, int m, int d){
		year = y;
		month = m;
		day = d;
	}
	
	public void puls(int years, int months,int days){
		day += days;
		month += months;
		year += years;
		while(month>12){
			month-=12;
			year++;
		}
		while(true){
			if(month==1 || month==3 || month==5 || month==7 || month==8 || month==10){
				if(day>31){
					day -= 31;
					month++;
				}else{
					break;
				}
			}else if(month==4 || month==6 || month==9 || month==11){
				if(day>30){
					day -= 30;
					month++;
				}else{
					break;
				}
			}else if(month==2){
				if(year%4==0 && year%100!=0 || year%400==0){
					if(day>29){
						day -= 29;
						month++;
					}else{
						break;
					}
				}else{
					if(day>28){
						day-=28;
						month++;
					}else{
						break;
					}
				}
			}else if(month == 12){
				if(day>31){
					day-=31;
					month=1;
					year++;
				}else{
					break;
				}
			}
		}
	}
}

public class Exercise4 {
	public static void main(String[] args) {
		MyDate my = new MyDate();
		my.set(2019, 5, 13);
		
		System.out.println(my.year + "年" + my.month + "月" + my.day + "日");
		System.out.println("是闰年吗？" + my.isLeapYear());
		
		my.puls(1, 70, 70);
		System.out.println("再加1年70个月70天之后的日期是：");
		System.out.println(my.year + "年" + my.month + "月" + my.day + "日");
	}
}

5、MyDate日期类-2

声明一个日期类MyDate，

包含属性：年、月、日
boolean isLeapYear()：判断是否是闰年
String monthName()：根据月份值，返回对应的英语单词
int totalDaysOfMonth()：返回这个月的总天数
int totalDaysOfYear()：返回这一年的总天数
int daysOfTheYear()：返回这一天是当年的第几数

在测试类的main方法中，创建MyDate对象，赋值为当天日期值，调用方法测试。

public class MyDate {
    int year;
    int month;
    int day;

    boolean isLeapYear(){
        return year%4==0 && year%100!=0 || year%400==0;
    }
    
    int totalDaysOfYear(){
        return isLeapYear() ? 366 : 365;
    }

    int totalDaysOfMonth(){
        if(month == 4 || month == 6 || month == 9 || month == 11){
            return 30;
        }
        if(month == 2){
            return isLeapYear() ? 29 : 28;
        }
        return 31;
    }

    int daysOfTheYear(){
        int days = day;
        for(int i=1; i<month; i++){
            if(i==2){
                days += isLeapYear() ? 29 : 28;
            }else if(i==4 || i==6 || i==9 || i==11){
                days += 30;
            }else{
                days += 31;
            }
        }
        return days;
    }

    String monthName(){
        String[] monthNames = {"January","February","March","April","May","June","July","August","September","October","November","December"};
        return monthNames[month-1];
    }
}

public class Exercise5 {
    public static void main(String[] args) {
        MyDate my = new MyDate();
        my.year = 2021;
        my.month = 12;
        my.day = 29;

        System.out.println("今年是闰年吗？" + my.isLeapYear());
        System.out.println("月份名是" + my.monthName());
        System.out.println("这个月总天数：" + my.totalDaysOfMonth());
        System.out.println("这一年总天数：" + my.totalDaysOfYear());
        System.out.println("这一天是这一年的几天？" + my.daysOfTheYear());
    }
}

6、数学计算工具类

案例：

声明一个数学计算工具类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的四舍五入后的整数值

声明一个Test06测试类，并在main方法中调用测试

public class MathTools {
	public int add(int a, int b) {
		return a + b;
	}

	public int subtract(int a, int b) {
		return a - b;
	}

	public int mutiply(int a, int b) {
		return a * b;
	}

	public int divide(int a, int b) {
		return a / b;
	}

	public int remainder(int a, int b) {
		return a % b;
	}

	public int max(int a, int b) {
		return a > b ? a : b;
	}

	public int min(int a, int b) {
		return a < b ? a : b;
	}

	public boolean equals(int a, int b) {
		return a == b;
	}

	public boolean isEven(int a) {
		return a % 2 == 0;
	}
	
	public boolean isPrimeNumber(int a){
		for (int i = 2; i < a; i++) {
			if(a%i == 0){
				return false;
			}
		}
		return true;
	}
	
	public int round(double d){
		return (int)(d + 0.5);
	}
}

public class Exercise6 {
	public static void main(String[] args) {
		MathTools tools = new MathTools();
		
		int a = 5;
		int b = 3;
		System.out.println(a + "+" + b  + "=" + tools.add(a,b));
		System.out.println(a + "-" + b  + "=" + tools.subtract(a,b));
		System.out.println(a + "*" + b  + "=" + tools.mutiply(a,b));
		System.out.println(a + "/" + b  + "=" + tools.divide(a,b));
		System.out.println(a + "%" + b  + "=" + tools.remainder(a,b));
		System.out.println(a + "," + b + "的最大值：" + tools.max(a, b));
		System.out.println(a + "," + b + "的最小值：" + tools.min(a, b));
		System.out.println(a + "==" + b + "？" + tools.equals(a,b));
		System.out.println(a + "是偶数？" + tools.isEven(a));
		System.out.println(a + "是素数？" + tools.isPrimeNumber(a));
		System.out.println("5.4四舍五入的结果：" + tools.round(5.4));
		System.out.println("5.6四舍五入的结果：" + tools.round(5.6));
	}
}

7、常识工具类

案例：

声明一个常识工具类CommonsTools，包含如下方法：

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)：判断某年是否是闰年

声明一个Test08测试类，并在main方法中调用测试

public class CommonsTools {
	public String getWeekName(int week){
		switch(week){
		case 1:
			return "Monday";
		case 2:
			return "Tuesday";
		case 3:
			return "Wednesday";
		case 4:
			return "Thursday";
		case 5:
			return "Friday";
		case 6:
			return "Saturday";
		case 7:
			return "Sunday";
		}
		return "";
	}
	
	public String getMonthName(int month){
		String[] all = {"January","February","March","April","May","June","July","August","September","October","November","December"};
		if(month >= 1 && month <= 12){
			return all[month-1];
		}
		return "";
	}
	
	public int getTotalDaysOfMonth(int year, int month){
		int[] days = {31,28,31,30,31,30,31,31,30,31,30,31};
		if(isLeapYear(year)){
			days[1]++;//闰年2月29天
		}
		if(month >= 1 && month <= 12){
			return days[month-1];
		}
		return 0;
	}
	
	public int getTotalDaysOfYear(int year){
		if(isLeapYear(year)){
			return 366;
		}
		return 365;
	}
	
	public boolean isLeapYear(int year){
		return year%4==0 && year%100!=0 || year%400==0;
	}
}

public class Exercise7 {
	public static void main(String[] args) {
		CommonsTools tools = new CommonsTools();
		System.out.println("3月：" + tools.getMonthName(3));
		System.out.println("周三：" + tools.getWeekName(3));
		System.out.println("2019-2的总天数：" + tools.getTotalDaysOfMonth(2019, 2));
		System.out.println("2019年是否是闰年？" + tools.isLeapYear(2019) );
		System.out.println("2019年的总天数：" + tools.getTotalDaysOfYear(2019));
	}
}

8、学生对象数组

（1）定义学生类Student

声明姓名和成绩实例变量
String getInfo()方法：用于返回学生对象的信息

（2）测试类的main中创建一个可以装3个学生对象的数组，从键盘输入3个学生对象的信息，并且按照学生成绩排序，显示学生信息

public class Student {
    String name;
    int score;

    public String getInfo() {
        return "姓名：" + name + ",成绩：" + score;
    }
}

import java.util.Scanner;

public class Exercise8 {
    public static void main(String[] args) {
        //创建一个可以装3个学生对象的数组
        Student[] arr = new Student[3];//只是申明这个数组，可以用来装3个学生，此时里面没有学生对象

        //从键盘输入
        Scanner input = new Scanner(System.in);

        for(int i=0;i<arr.length; i++){
            System.out.println("请输入第" + (i+1) + "个学生信息：");
            arr[i] = new Student();

            System.out.print("姓名：");
            arr[i].name = input.next();

            System.out.print("成绩：");
            arr[i].score = input.nextInt();
        }

        input.close();

        //先显示一下目前的顺序
        System.out.println("排序之前，学生对象信息：");
        for(int i=0; i<arr.length; i++){
            System.out.println(arr[i].getInfo());
        }

        System.out.println("------------------------------------------");
        //冒泡排序
        for(int i=1; i<arr.length; i++){
            for(int j=0; j<arr.length-i; j++){
                //arr[j] > arr[j+1]//错误的
                if(arr[j].score > arr[j+1].score){
                    //交换两个元素，这里是两个学生对象，所以temp也得是Student类型
                    Student temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

        System.out.println("排序之后，学生对象信息：");
        //再显示一下目前的顺序
        for(int i=0; i<arr.length; i++){
            System.out.println(arr[i].getInfo());
        }
    }
}

9、员工管理类-1

案例：

1、声明一个Employee员工类，

包含属性：编号(id)、姓名(name)、薪资(salary)、年龄(age)，此时属性不私有化

包含方法：

（1）void printInfo()：可以打印员工的详细信息

（2）void setInfo(int i, String n, double s, int a)：可以同时给id,name,salary,age赋值

2、声明一个EmployeeManager类，包含如下方法：

（1）public void print(Emplyee[] all)：遍历打印员工数组中的每个员工的详细信息

（2）public void sort(Employee[] all)：将all员工数组按照年龄从高到低排序

（3）public void addSalary(Employee[] all, double increament)：将all员工数组的每一个员工的工资，增加increament

3、声明Test05测试类

（1）public static void main(String[] args)：在main方法中，创建Employee[]数组，并创建5个员工对象放到数组中，并为员工对象的属性赋值

（2）创建EmployeeManager对象，

（3）调用print方法，显示员工信息

（4）调用sort方法对员工数组进行按照年龄排序，并调用print方法，显示员工信息

（5）调用addSalary方法给每一个员工加薪1000元，并调用print方法，显示员工信息

public class Employee {
	int id;
	String name;
	double salary;
	int age;
	
	void printInfo(){
		System.out.println("编号：" + id + "，姓名：" + name + "，薪资：" + salary + "，年龄：" +age);
	}
	void setInfo(int  i, String n, double s, int a){
		id = i;
		name = n;
		salary = s;
		age = a;
	}
}

public class EmployeeManager {
	public void print(Employee[] all){
		for(int i=0; i<all.length; i++){
			all[i].printInfo();
		}
	}
	
	public void sort(Employee[] all){
		for(int i=1; i<all.length; i++){
			for(int j=0; j<all.length-i; j++){
				//从高到低
				if(all[j].age < all[j+1].age){
					Employee temp = all[j];
					all[j] = all[j+1];
					all[j+1] = temp;
				}
			}
		}
	}
	
	public void addSalary(Employee[] all, double increament){
		for(int i=0; i<all.length; i++){
			all[i].salary += increament;
		}
	}
}

public class Exercise9 {
	public static void main(String[] args){
		Employee[] all = new Employee[5];
		all[0] = new Employee();
		all[0].setInfo(1,"张三",10000,23);
		
		all[1] = new Employee();
		all[1].setInfo(2,"李四",12000,23);
		
		all[2] = new Employee();
		all[2].setInfo(3,"王五",8000,18);
		
		all[3] = new Employee();
		all[3].setInfo(4,"赵六",6000,20);
		
		all[4] = new Employee();
		all[4].setInfo(5,"钱七",15000,21);
		
		EmployeeManager em = new EmployeeManager();
		
		em.print(all);
		System.out.println("------------------------------------------");
		
		em.sort(all);
		em.print(all);
		System.out.println("------------------------------------------");
		
		em.addSalary(all, 200);
		em.print(all);
	}
}

10、员工管理类-2

声明一个Employee员工类，包含属性：编号(id)、姓名(name)、薪资(salary)、年龄(age)，包含如下方法：

String getInfo()：返回员工的详细信息，每一个
void setInfo(int i, String n, double s, int a)：可以同时给id,name,salary,age赋值

声明一个EmployeeManager员工管理类，包含：

Employee[]类型的allEmployees，长度指定为5
int类型的实例变量total，记录allEmployees数组实际存储的员工数量
boolean addEmployee(Employee emp)：添加一个员工对象到allEmployees数组中，如果数组已满，则不添加并提示数组已满
Employee[] getEmployees()：返回total个员工对象

在测试类的main中添加6个员工对象，并且遍历输出。

public class Employee {
    int id;
    String name;
    double salary;
    int age;

    String getInfo(){
        return "编号：" + id + "，姓名：" + name + "，薪资：" + salary + "，年龄：" +age;
    }
    void setInfo(int  i, String n, double s, int a){
        id = i;
        name = n;
        salary = s;
        age = a;
    }
}

public class EmployeeManager {
    Employee[] allEmployees = new Employee[5];
    int total;

    boolean addEmployee(Employee emp){
        if(total >= allEmployees.length){
            System.out.println("数组已满");
            return false;
        }
        allEmployees[total++] = emp;
        return true;
    }

    Employee[] getEmployees(){
        Employee[] results = new Employee[total];
        for (int i = 0; i < results.length; i++) {
            results[i] = allEmployees[i];
        }
        return results;
    }
}

public class Exercise10 {
    public static void main(String[] args) {
        EmployeeManager em = new EmployeeManager();

        Employee e1 = new Employee();
        e1.setInfo(1,"刘一",11000,21);
        Employee e2 = new Employee();
        e2.setInfo(2,"陈二",12000,22);
        Employee e3 = new Employee();
        e3.setInfo(3,"张三",13000,23);
        Employee e4 = new Employee();
        e4.setInfo(4,"李四",14000,24);
        Employee e5 = new Employee();
        e5.setInfo(5,"王五",15000,25);
        Employee e6 = new Employee();
        e6.setInfo(6,"赵六",16000,26);

        System.out.println("添加e1" + (em.addEmployee(e1)?"成功":"失败"));
        System.out.println("添加e2" + (em.addEmployee(e2)?"成功":"失败"));
        System.out.println("添加e3" + (em.addEmployee(e3)?"成功":"失败"));
        System.out.println("添加e4" + (em.addEmployee(e4)?"成功":"失败"));
        System.out.println("添加e5" + (em.addEmployee(e5)?"成功":"失败"));
        System.out.println("添加e6" + (em.addEmployee(e6)?"成功":"失败"));

        Employee[] employees = em.getEmployees();
        for (int i = 0; i < employees.length; i++) {
            System.out.println(employees[i].getInfo());
        }
    }
}

11、比较大小

（1）声明MathTools工具类，包含：

public int compare(int a, int b)：比较两个整数大小关系，如果第一个整数比第二个整数大，则返回正整数，如果第一个整数比第二个整数小，则返回负整数，如果两个整数相等则返回0；
public int compare(double a, double b)：比较两个小数大小关系，如果第一个小数比第二个小数大，则返回正整数，如果第一个小数比第二个小数小，则返回负整数，如果两个小数相等则返回0；
public int compare(char a, char b)：比较两个字符大小关系，如果第一个字符比第二个字符编码值大，则返回正整数，如果第一个字符比第二个字符编码值小，则返回负整数，如果两个字符相等则返回0；

（2）在测试类的main方法中调用

public class MathTools {
    public int compare(int a, int b){
        return a - b;
    }

    public int compare(double a, double b){
        if(a > b){
            return 1;
        }else if(a < b){
            return -1;
        }
        return 0;
    }

    public int compare(char a, char b){
        return a - b;
    }
}

public class Exercise11 {
    public static void main(String[] args) {
        MathTools tools = new MathTools();

        System.out.println(tools.compare(4,7));
        System.out.println(tools.compare(4.5, 7.3));
        System.out.println(tools.compare('a', 'b'));
        System.out.println(tools.compare(4.3, 7));
    }
}

12、数组排序和遍历

（1）声明一个数组工具类ArraysTools，包含几个重载方法

重载方法系列1：可以为int[]，double[]，char[]数组实现从小到大排序
- public void sort(int[] arr)
- public void sort(double[] arr)
- public void sort(char[] arr)
重载方法系列2：toString方法，可以遍历int[]，double[]，char[]数组，遍历结果形式：[元素1，元素2，。。。]
- public String toString(int[] arr)
- public String toString(double[] arr)
- public String toString(char[] arr)

（2）在测试类的main方法中调用

public class ArraysTools {
    public void sort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr.length- i ; j++) {
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

    public void sort(double[] arr){
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr.length- i ; j++) {
                if(arr[j] > arr[j+1]){
                    double temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

    public void sort(char[] arr){
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr.length- i ; j++) {
                if(arr[j] > arr[j+1]){
                    char temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

    public String toString(int[] arr){
        String result = "[";
        for (int i = 0; i < arr.length; i++) {
            if(i<arr.length-1){
                result += arr[i] + ",";
            }else{
                result += arr[i] + "]";
            }
        }
        return result;
    }

    public String toString(double[] arr){
        String result = "[";
        for (int i = 0; i < arr.length; i++) {
            if(i<arr.length-1){
                result += arr[i] + ",";
            }else{
                result += arr[i] + "]";
            }
        }
        return result;
    }

    public String toString(char[] arr){
        String result = "[";
        for (int i = 0; i < arr.length; i++) {
            if(i<arr.length-1){
                result += arr[i] + ",";
            }else{
                result += arr[i] + "]";
            }
        }
        return result;
    }
}

public class Exercise12 {
    public static void main(String[] args) {
        ArraysTools tools = new ArraysTools();

        int[] arr1 = {5,4,2,17,3};
        tools.sort(arr1);
        System.out.println(tools.toString(arr1));

        double[] arr2 = {5.0 ,4.0, 2.0,17.0,3.0};
        tools.sort(arr2);
        System.out.println(tools.toString(arr2));


        char[] arr3 = {'h','a','o','b','t'};
        tools.sort(arr3);
        System.out.println(tools.toString(arr3));
    }
}

13、求三角形面积

（1）声明一个图形工具类GraphicTools，包含两个重载方法

方法1：public double triangleArea(double base, double height),根据底边和高，求三角形面积，
方法2：public double triangleArea(double a, double b, double c),根据三条边，求三角形面积，根据三角形三边求面积的海伦公式：

在这里插入图片描述

（2）在测试类的main方法中调用

public class GraphicTools {
    public double triangleArea(double base, double height){
        if(base > 0 && height > 0) {
            return base * height / 2;
        }
        return 0;
    }

    public double triangleArea(double a, double b, double c){
        if(a > 0 && b > 0 && c > 0 && a + b > c && b + c > a && a + c > b){
            double p = (a + b + c)/2;
            return Math.sqrt(p * (p-a) * (p-b) * (p-c));
        }
        return 0;
    }
}

public class Exercise13 {
    public static void main(String[] args) {
        GraphicTools tools = new GraphicTools();

        System.out.println(tools.triangleArea(3, 4));
        System.out.println(tools.triangleArea(3,4,5));
    }
}

14、图形工具类

案例：

声明一个图形工具类GraphicTools，包含如下方法：

1、void printRectangle()：该方法打印5行5列*矩形

2、void printRectangle(int line, int column, String sign)：该方法打印line行colomn列由sign组成的矩形

3、double getTriangleArea(double base, double height)：根据底边和底边对应的高求三角形面积

4、double getTriangleArea(double a, double b, double c)：根据三角形的三条边求三角形面积，如果a,b,c不能组成三角形，打印不能组成三角形，并返回0.0

声明Test02测试类，并在main方法中调用测试

public class GraphicTools {
	void printRectangle() {
		for (int i = 1; i <= 5; i++) {
			for (int j = 1; j <= 5; j++) {
				System.out.print("*");
			}
			System.out.println();
		}
	}

	void printRectangle(int line, int column, String sign) {
		for (int i = 1; i <= line; i++) {
			for (int j = 1; j <= column; j++) {
				System.out.print(sign);
			}
			System.out.println();
		}
	}

	double getTriangleArea(double base, double height) {
		return base * height / 2;
	}

	double getTriangleArea(double a, double b, double c) {
		if(a>0 && b>0 && c>0 && a+b>c && a+c>b && b+c >a){
			double p = (a + b + c) / 2;
			return Math.sqrt(p * (p - a) * (p - b) * (p - c));
		}else{
			System.out.println(a +"," + b +"," + c + "不能构成三角形");
			return 0;
		}
	}
}

public class Exercise14 {
	public static void main(String[] args) {
		GraphicTools tools = new GraphicTools();

		tools.printRectangle();
		System.out.println("--------------------------");

		tools.printRectangle(5, 10, "#");
		System.out.println("--------------------------");

		System.out.println("底边为3，高为4的三角形面积：" + tools.getTriangleArea(3, 4));
		System.out.println("边为3，4，5的三角形面积：" + tools.getTriangleArea(3, 4, 5));
	}
}

15、Count类

在Count类中，声明如下方法：

1、public long sum(int… nums)：求0~n个整数的累加和，如果没有传参，就返回0

2、public int max(int a, int… others)：求1~n个整数中的最大值

3、public String concat(String… strings)：求0~n个字符串的拼接结果

4、public boolean isEven(int… nums)：判断0~n个整数是否都是偶数，如果都是偶数，返回true，否则返回false

声明一个Test01测试类，并在main方法中调用测试

public class Count{
	public long sum(int...  nums){
		long sum = 0;
		for (int i = 0; i < nums.length; i++) {
			sum += nums[i];
		}
		return sum;
	}
	
	public int max(int a, int... others){
		int max = a;
		for (int i = 0; i < others.length; i++) {
			if(others[i] > max){
				max = others[i];
			}
		}
		return max;
	}
	
	public String concat(String...  strings){
		String result = "";
		for (int i = 0; i < strings.length; i++) {
			result += strings[i];
		}
		return result;
	}
	
	public boolean isEven(int... nums){
		for (int i = 0; i < nums.length; i++) {
			if(nums[i]%2 !=0){
				return false;
			}
		}
		return true;
	}
}

public class Exercise15 {
	public static void main(String[] args) {
		Count c = new Count();
		System.out.println("1,2,3,4,5的总和：" + c.sum(1,2,3,4,5));
		System.out.println("3,4,2,1的最大值是：" + c.max(3,4,2,1));
		System.out.println("尚，硅，谷，好拼接的结果：" + c.concat("尚","硅","谷","好"));
		System.out.println("2,4,6,8是否都是偶数：" + c.isEven(2,4,6,8));
	}
}

16、PassParamDemo类

在PassParamDemo类中，声明如下方法，并体会方法的参数传递机制，并尝试画图分析

void doubleNumber(int num)：将num变为原来的2倍大
void toUpperCase(char letter)：将letter的小写字母转为大写字母
void expandCircle(Circle c，double times)：将Circle的c对象的半径扩大为原来的times倍。圆Circle类，包含radius属性。
void doubleElement(int[] arr)：把arr数组的元素扩大2倍
void grow(int[] arr)：将arr数组的长度变为原来的1.5倍

public class PassParamDemo {
    void  doubleNumber(int num){
        num *= 2;
    }

    void toUpperCase(char letter){
        letter -= 32;
    }

    void expandCircle(Circle c, double times){
        c.radius *= times;
    }

    void doubleElement(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            arr[i] *= 2;
        }
    }

    void grow(int[] arr){
        arr = new int[arr.length*2];
    }
}

在main方法中调用上面的方法后，请分析运行结果。

public class Exercise16 {
    public static void main(String[] args) {
        PassParamDemo demo = new PassParamDemo();
        
        int x = 1;
        demo.doubleNumber(x);
        System.out.println("x = " + x);
        
        char c = 'a';
        demo.toUpperCase(c);
        System.out.println("c = " + c); 
        
        Circle circle = new Circle();
        circle.radius = 1;
        demo.expandCircle(circle, 5);
        System.out.println("circle.radius = " + circle.radius);

        int[] arr = {1,2,3,4,5};
        demo.doubleElement(arr);
        System.out.println("调用doubleElement方法之后：");
        System.out.println("arr数组的元素：" );
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        demo.grow(arr);
        System.out.println("调用grow方法之后：arr的数组长度："  + arr.length);
        System.out.println("arr数组的元素：" );
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

17、矩形类

案例：

1、声明矩形类Rectangle

（1）包含属性：长和宽，要求属性私有化

（2）给每一个属性提供get/set方法

（3）public double getArea()

（4）public double getPerimeter()

（5）提供getInfo()返回矩形对象的信息

例如：长：4，宽：2，面积：8，周长：12

2、测试类Exercise17，

（1）在main()方法中创建Rectangle对象，并用set方法为属性赋值

（2）调用get方法打印属性的值，调用getArea打印面积，调用getPerimeter打印周长

（3）再次调用set方法修改属性的值为原来属性值的两倍

（4）调用getInfo方法打印矩形信息

public class Rectangle {
	private double length;
	private double width;
	
	public void setLength(double chang){
		length = chang;
	}
	public double getLength(){
		return length;
	}
	public void setWidth(double kuan){
		width = kuan;
	}
	public double getWidth(){
		return width;
	}
	
	public double getArea(){
		return length * width;
	}
	public double getPerimeter(){
		return 2 * (length + width);
	}
	public String getInfo(){
		return "长：" + length + "，宽：" + width + "，面积：" + getArea() + "，周长：" + getPerimeter(); 
	}
}

public class Exercise17 {

	public static void main(String[] args) {
		Rectangle r = new Rectangle();
		r.setLength(2);
		r.setWidth(1);
		System.out.println("长：" + r.getLength());
		System.out.println("宽：" + r.getWidth());
		System.out.println("面积：" + r.getArea());
		System.out.println("周长：" + r.getPerimeter());
		
		r.setLength(r.getLength()*2);
		r.setWidth(r.getWidth()*2);
		System.out.println(r.getInfo());
	}

}

18、矩形类

（1）定义矩形类Rectangle

声明实例变量长和宽，全部私有化private，
提供相应的get/set方法，如果set方法的参数值<=0，则提示矩形的长和宽必须是正数
声明public double area()，返回矩形面积
声明public double perimeter()：返回矩形的周长
声明public String getInfo()：返回矩形的长、宽、面积、周长信息

（2）测试类的main中创建一个可以装3个矩形对象的数组，并调用set方法为对象的属性赋值，依次长是8,7,6，宽是2,3,4

遍历输出矩形对象数组
按照矩形对象的length属性值从小到大排序后，遍历输出矩形对象数组
按照矩形对象的面积从小到大排序后，遍历输出矩形对象数组

public class Rectangle {
    private double length;
    private double width;

    public double getLength() {
        return length;
    }

    public void setLength(double l) {
        if(l <= 0){
            System.out.println("矩形的长必须是正数");
            return;
        }
        length = l;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double w) {
        if(w <= 0){
            System.out.println("矩形的宽必须是正数");
            return;
        }
        width = w;
    }

    public double area(){
        return length * width;
    }

    public double perimeter(){
        return 2 * (length + width);
    }

    public String getInfo(){
        return "长：" + length + "，宽：" + width + "，面积：" + area() +"，周长：" + perimeter();
    }
}

public class Exercise18 {
    public static void main(String[] args) {
        Rectangle[] arr = new Rectangle[3];
        arr[0] = new Rectangle();
        arr[0].setLength(8);
        arr[0].setWidth(2);

        arr[1] = new Rectangle();
        arr[1].setLength(7);
        arr[1].setWidth(3);

        arr[2] = new Rectangle();
        arr[2].setLength(6);
        arr[2].setWidth(4);

        System.out.println("原始数据：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i].getInfo());
        }

        System.out.println("按照length从小到大排序：");
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr.length-i; j++) {
                if(arr[j].getLength() > arr[j+1].getLength()){
                    Rectangle temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i].getInfo());
        }

        System.out.println("按照面积从小到大排序：");
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr.length-i; j++) {
                if(arr[j].area() > arr[j+1].area()){
                    Rectangle temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i].getInfo());
        }
    }
}

19、三角形类

（1）定义三角形类Triangle，

声明实例变量a,b,c，代表三角形三条边，全部私有化private，
提供每条边的get方法，
提供public void setBases(double a, double b, double c)：要求参数a,b,c的值必须大于等于0，且满足三角形三边关系要求（即任意两边之后大于第三边），否则提示错误信息
声明public double area()，返回三角形面积
声明public double perimeter()：返回三角形周长
声明public String getInfo()：返回三角形的三条边，面积和周长

（2）测试类的main中创建一个三角形对象，并调用相应方法

public class Triangle {
    private double a;
    private double b;
    private double c;

    public double getA() {
        return a;
    }

    public double getB() {
        return b;
    }

    public double getC() {
        return c;
    }
    public void setBases(double a, double b,double c){
        if(a<=0 || b<=0 || c<=0){
            System.out.println("三角形的边长必须是正数");
        }else if(a+b<=c || a+c<=b || b+c<=a){
            System.out.println("三角形任意两边之后必须大于第三边");
        }else{
            this.a = a;
            this.b = b;
            this.c = c;
        }
    }

    public double area(){
        double p = (a+b+c)/2;
        return Math.sqrt(p*(p-a)*(p-b)*(p-c));
    }

    public double perimeter(){
        return a+b+c;
    }

    public String getInfo(){
        return "边长：" + a + "," + b + "," + c +"，面积：" + area() +"，周长：" + perimeter();
    }
}

public class Exercise19 {
    public static void main(String[] args) {
        Triangle t = new Triangle();
        t.setBases(1,2,3);
        System.out.println(t.getInfo());

        t.setBases(3,4,5);
        System.out.println(t.getInfo());
    }
}

20、猴子吃桃

猴子吃桃子问题，猴子第一天摘下若干个桃子，当即吃了所有桃子的一半，还不过瘾，又多吃了一个。
第二天又将仅剩下的桃子吃掉了一半，又多吃了一个。以后每天都吃了前一天剩下的一半多一个。
到第十天，只剩下一个桃子。试求第一天共摘了多少桃子？

提示：
getPeachNum(n) - (getPeachNum(n)/2 + 1) = getPeachNum(n + 1)

--> getPeachNum(n) = 2 * ( getPeachNum(n + 1) + 1)

public class PeachNumberTest {
    public static void main(String[] args) {

        PeachNumberTest test =  new PeachNumberTest();

        for(int i = 1;i <= 10;i++){
            System.out.println("第" + i + "天，有" + test.getPeachNum(i) + "个桃");
        }


    }

    public int getPeachNum(int n){
        if(n == 10){
            return 1;
        }else{
            return 2 * getPeachNum(n + 1)  + 2;
        }
    }
}