【Java】面向对象基础

重点回顾

数组的创建：

• 动态创建： 数据类型[] 数组变量名=new 数据类型[元素个数]
• 静态创建： 数据类型[] 数组变量名={元素1,元素2,…}
• 动态创建并赋初始值： 数据类型[] 数组变量名=new 数据类型[]{元素1,元素2,…}

数组特点：

• 只能存储相同类型的数据
• 数组中的值可以重复
• 数组的长度是固定的
• 数组是连续的内存空间

相关的算法

• 冒泡排序
• 二分法查找

系统预定义类型引入

• 基本类型及其包装类
• 字符串类型
• 日期类型基础
• 随机数

• Math.random()
• Random r=new Random()

练习题

• 第1题：用递归实现不死神兔：斐波那契在他的一部著作中提出了一个有趣的问题：假设一对刚出生的小兔一个月后就能长成大兔，再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，没有发生死亡
  问：现有一对刚出生的兔子2年后(24个月)会有多少对兔子?
• 第2题：猴子吃桃子问题，猴子第一天摘下若干个桃子，当即吃了快一半，还不过瘾，又多吃了一个。第二天又将仅剩下的桃子吃掉了一半，又多吃了一个。以后每天都吃了前一天剩下的一半多一个。到第十天，只剩下一个桃子。试求第一天共摘了多少桃子？
• 第3题：通项公式如下：f(n)=n + (n-1) + (n-2) + … + 1，其中n是大于等于5并且小于10000的整数，例如：f(5) = 5 + 4 + 3 + 2 + 1，f(10) = 10 + 9 + 8 + 7+ 6 + 5 + 4 + 3 + 2 + 1，请用递归的方式完成方法long f( int n)的方法体。
• 第4题：假设有n级台阶，一个人可以一次上1级或者2级台阶，问有多少种上法

参考答案

第1题

public class Test01 {
public static void main(String[] args) {
Count c = new Count();
int sum = c.sum(24);
System.out.println(sum);
}
}
class Count{
//从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子
/*
* 第1个月，1对 f(1) = 1
* 第2个月，1对 f(2) = 2
* 第3个月，2对 老兔子本身1对，加上生出来的一对第1个月
* f(3) = f(2) + f(1)
* 第4个月，3对 老兔子本身1对，上月出生的兔子第2个月，老兔子又生出一对新的第1个
月
* 整理： 老兔子本身1对，老兔子又生出一对新的第1个月==》等价于第3个月
的状态
上月出生的兔子第2个月，==>等价于第2个月的兔子状态
* f(4) = f(3)+f(2)
* 第5个月，5对 老兔子本身1对，老兔子又生出1对新的第1个月，第3个月初始的兔子也成
新的老兔子1对，
它也生出一对新的第1个月，第4个月出生的兔子第2个月1对
* 整理分析：
*老兔子本身1对，老兔子又生出1对新的第1个月，第4个月出生的兔子第2个月1对 ==》等价于
第4个月的状态
*第3个月初始的兔子也成新的老兔子1对，它也生出一对新的第1个月 ==》等价于第2个月的兔
子状态
* f(5) = f(4) + f(2)
* .... f(n) = f(n-1) + f(n-2)
*
*/
public int sum(int n){
if(n==1 || n==2){
return 1;
}else{
return sum(n-1) + sum(n-2);
}
}
}

第2题

public class Test02 {
public static void main(String[] args) {
Count c = new Count();
System.out.println(c.sum(1));
System.out.println(c.sum(2));
System.out.println(c.sum(3));
System.out.println(c.sum(4));
System.out.println(c.sum(5));
System.out.println(c.sum(6));
System.out.println(c.sum(7));
System.out.println(c.sum(8));
System.out.println(c.sum(9));
System.out.println(c.sum(10));
}
}
class Count{
public int sum(int n){
if(n==10){//第10天
return 1;
}else{
/*
* 第9天没吃之前是 第10天+1个的2倍
* 第8天没吃之前是 第9天+1个的2倍
* 。。。。
*/
return (sum(n+1)+1)*2;
}
}
}

第3题

public class Test3 {
public static void main(String[] args) {
Count c = new Count();
System.out.println(c.f(5));
System.out.println(c.f(10));
}
}
class Count{
public long f(int n) {
long sum = 0;
if(n==1){
sum += 1;
}else if(n>1){
sum += n + f(n-1);
}
return sum;
}
}

第4题

/*
* 1级：1
* 2级：2 1步1步 和 2步
* 3级：上到1级的总走法（因为从1级上到3级直接跨2步） + 上到2级的总走法（从2级上到3级直接
跨1步）
* 因为从1级走1步就归到上到2级的走法里面了
* 4级：上到2级的总走法 + 上到3级的总走法
* ...
* *
* 即最后一步要么跨1步，要么跨2步
*/
public class Test4 {
public static void main(String[] args) {
Count c = new Count();
System.out.println(c.f(10));
}
}
class Count{
public int f(int n) {
if (n <= 2){
return n;
}
return f(n - 1) + f(n - 2);
}
}

面向对象概论

【考试题】

面向对象的三大基本特征是：封装、继承、多态

• 封装隐藏了类的内部实现机制，从而可以在不影响使用者的前提下改变类的内部结构，同时保护了数据
• 隐藏功能或者信息的细节，使用者只关注功能的使用，而不需要关心实现细节
• 继承是为了重用父类代码，同时为实现多态性作准备
• 关键字extends，子类可以集成父类的成员变量和成员方法
• java采用的是单根集成体系
• 多态性是发送消息给某个对象，让该对象自行决定响应何种行为。通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。
• 一个事物可以有多种表现形式
• 体现形式常见的有3种
• 父类型引用子类对象
• 方法重写
• 方法重载

面向对象三大特征的优缺点

• 设计目标：高内聚低耦合
• 可维护性提高
• 重用性提高
• 扩展性增强
• 执行效率

概述

面向过程是一种自上而下的程序设计方法，主要思路专注于算法的实现

自上而下的设计方法，设计者用一个main函数概括出整个应用需要做的事情，然后把main方法拆解成
不同的步骤，对应不同的函数

过程式的特征是以函数为中心，用函数作为划分程序的基本单位；数据在过程式设计中处于从属的位置

过程式设计的优点是易于理解和掌握，这种逐步细化问题的设计方法与大多数人的思维方式比较接近

过程式设计是自上而下，这就要求设计者在开始时要对需要解决的问题有一定的理解，然而在问题比较
复杂时，要做到这一点比较困难；当开发需求变化时，以前对问题的理解会变得不再适用

软件代码的重用性很差，即使重用，也是简单的复制和拷贝，代码数量急剧增加。而不能直接继承和应
用
面向过程的方法将数据和过程分离，使得数据的改变很可能带来代码的变化

面向对象是一种自下而上的程序设计方法，以数据为中心，类是表现数据的单位，是划分程序的基本单
位

面向对象设计是自下而上的特性，允许开发者从问题的局部开始，在开发过程中逐步加深对系统的理
解。需求变化会作用到系统开发本身，形成一种螺旋式的开发方式

面向对象设计中，类封装了数据，而类的成员函数作为其对外的接口，抽象地描述类，用类将数据和操
作这些数据的函数放在一起，这就是面向对象设计方法的本质

面向对象的概念

OO面向对象Object Oriented是软件开发方法

• 面向对象是一种新兴的程序设计方法,或者是一种新的程序设计规范paradigm，其基本思想是使用
  对象、类、继承、封装、消息等基本概念来进行程序设计
• 从现实世界中客观存在的事物（即对象）出发来构造软件系统，并且在系统构造中尽可能运用人类
  的自然思维方式
• 开发一个软件是为了解决某些问题，这些问题所涉及的业务范围称作该软件的问题域。其应用领域
  不仅仅是软件，还有计算机体系结构和人工智能等
• 面向对象的思想已经涉及到软件开发的各个方面。如面向对象的分析（OOA，Object Oriented
  Analysis），面向对象的设计（OOD，Object Oriented Design）、以及经常说的面向对象的编程
  实现（OOP，Object Oriented Programming）
• OOP使得现实世界中的概念在计算机程序中编程模块，它包括构造程序的特征以及组织数据和算法
  的机制

面向对象是一种对现实世界理解和抽象的方法

• 传统的程序设计主张将程序看作一系列函数的集合，或者直接就是一系列对电脑下达的指令。面向
  对象程序设计中的每一个对象都应该能够接受数据、处理数据并将数据传达给其它对象，因此它们
  都可以被看作一个小型的“机器”，即对象
• OOP语言有3大特征：封装、继承及多态，所有这些特征与类的概念是息息相关的
  面向对象是指一种程序设计范型，同时也是一种程序开发的方法。对象指的是类的集合。它将对象
  作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性
• 对象、类、实体之间的关系和面向对象的问题求解思维方式

对象

对象是要进行研究的任何事物，从最简单的整数到复杂的飞机等均可看作对象，它不仅能表示具体的事
物，还能表示抽象的规则、计划或事件。对象是一个客观存在的、唯一的实体，是一个类的动态实例，
拥有自己的标识、数据与行为

• 在现实世界中：是客观世界中的一个实体
• 在计算机世界中：是一个可标识的存储区域
• 现实世界中所有的事物都是对象

• 对象都具有某些特征，并展现某些行为
  对象的状态和行为

• 对象具有状态，一个对象用数据值来描述它的状态
• 对象还有操作，用于改变对象的状态，对象及其操作就是对象的行为
• 对象实现了数据和操作的结合，使数据和操作封装于对象的统一体中
  对象的两个要素
• 属性：用于描述对象静态特性（结构特性）的一个数据项，描述一个人可用姓名、性别、身份证号等属性
• 方法（也称服务）：用于描述对象动态特性（行为特性）的一个操作系列

• 每个人都具有工作、学习等行为特性

• 对象将数据和施加于数据上的操作打包成一个不可分割的最基本的模块，使得仅有该类的有限个方法才可以操纵、改变这些数据

类

用Java语言对现实生活中的事物进行描述，通过类的形式来体现

• 类是具有共同属性和行为的对象的抽象，具有相同特性（数据元素）和行为（功能）的对象的抽象就是类
• 对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象
• 类实际上就是一种数据类型
• 类是用于组合各个对象所共有操作和属性的一种机制
• 类是具有相同属性和行为的一组对象的集合
• 类具有属性，它是对象的状态的抽象，用数据结构来描述类的属性
• 类具有操作，它是对象的行为的抽象，用操作名和实现该操作的方法来描述
• 类可以定义为数据和方法的集合，类也称为模板，因为它们提供了对象的基本框架
• 一旦定义类后，就可以用这种新类来创建该类型的对象
• 类就是对象的模板（template ）
• 而对象就是类的一个实例（instance）

消息和方法

• 对象之间进行通信的结构叫做消息。发送一条消息至少要包括说明接受消息的对象名、发送给该对象的消息名（即对象名、方法名）
• 类中操作的实现过程叫做方法，一个方法有方法名、返回值、参数、方法体

类和对象之间的关系

类是事物的描述

• 类是Java程序的核心，它定义了对象的形状和本质，可以用类来创建对象。当使用一个类创建了一
  个对象时，通常说给出了这个类的一个实例
• 类由类声明和类体构成，一般命名方法为：首字母大写，大写字母分词，例如XueSheng

class className {
类体；
}

• 类包含数据成员(数据、属性)和成员方法（函数）。一般建议数据成员应该是通过函数(方法)访问的
  对象是类的实例，就是应用中定义的某个类的变量，例如Person p=new Person(); p就是对象
  类是和问题域相关的具有相同属性和行为的对象的抽象；对象是该类事物的实例，在Java中通过new来创建的

基本规则

1 、了解业务需求，查找具体的研究目标：对象
2 、使用抽象的方法将具体的研究目标转换为新的数据类型定义：类

//一个文件中可以定义无数个类，但是只能有一个public class，而且公共类的名称必须和文件名称
一致
public class Student {
//数据成员
private Long id;  //学生编号
private String name;//姓名
private double high;
//成员方法
public void 吃饭(){
high+=0.1;
}
}
class Teach{} //非公共类
public class Test1{
public static void main(String[] args){
Student s1=new Student();
s1.吃饭();
}
}

封装

在面向对象程式设计方法中，封装Encapsulation是指一种将抽象性函式接口的实现细节部分包装、隐藏
起来的方法。

• 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问

• 反射机制

• 要访问该类的代码和数据，必须通过严格的接口控制。
• 封装最主要的功能在于能修改自己的实现代码，而不用修改那些调用代码的程序片段

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

//第一步是确定研究的目标对象---可以区分的独立个体
// 需要方法和属性
class Student {
//成员属性---静态特征的描述
private boolean sex; //一般使用私有属性，共有的get/set方法
//成员方法---提供的功能描述
public boolean getSex(){
return this.sex;
}
//不允许修改sex，所以不提供set方法
protected void setSex(Boolean sex){  //如果在特殊情况下允许修改,可以使用范围限
定词进行表示
this.sex=sex;
}
}
//构建对象
Student s1=new Student();
s1.setSex(true);
s1.setSex(false); //是否允许取绝于限制

封装有三大好处

• 良好的封装能够减少耦合
• 类内部的结构可以自由修改
• 可以对成员进行更精确的控制
• 隐藏信息，实现细节

4 个关键字

用于进行访问控制
记忆的方法

//一个文件种可以定义无数个类，但是只能有一个public class公共类
public class Student { //类的范围限定词分为 2 种情况。外部类的范围限定词可以使用无范围
限定词和public两种；而内部类上可以使用 4 种范围限定
//成员属性,类种包含哪些静态特征取决于问题本身
private Long id;  //private只能在当前类中直接访问
protected String name; //protected可以在同包或者子类中直接访问
int age;//没有范围限定词，默认或者package限定词，只能在同包中直接访问
public double salary;//public到处可见
//一般规则是私有属性，共有的get/set方法
}

• 类定义规则：要求类内高内聚，类间弱耦合
• 封装确实可以使容易地修改类的内部实现，而无需修改使用了该类的客户代码
  例子：计算装修费用
  查找名词：房间(多个墙) 墙(长、高) 窗户(长、宽) …

练习题

第 1 题

案例：
声明员工类Employee，包含属性：编号、姓名、年龄、薪资，
声明Test01测试类，并在main方法中，创建 2 个员工对象，并为属性赋值，并打印两个员工的信息。

public class Employee {

	private int bianHao;
	private String xingMing;
	private int nianLing;
	private int xinZi;
	
	//读取器，用于获取对象的私有属性值
	public int getBianHao() {
		return bianHao;
	}
	//设置器，用于向对象传入特定的属性值
	public void setBianHao(int bianHao) {
		this.bianHao = bianHao;
	}
	public String getXingMing() {
		return xingMing;
	}
	public void setXingMing(String xingMing) {
		this.xingMing = xingMing;
	}
	public int getNianLing() {
		return nianLing;
	}
	public void setNianLing(int nianLing) {
		this.nianLing = nianLing;
	}
	public int getXinZi() {
		return xinZi;
	}
	public void setXinZi(int xinZi) {
		this.xinZi = xinZi;
	}
	
	public void show() {
		 System.out.println("员工"+bianHao+"的编号:"+bianHao+",姓名:"+xingMing+",年龄:"+nianLing+",薪资:"+xinZi);
	  }
	}

  public static void main(String[] args) {
    Employee e1=new Employee();
    e1.setBianHao(1);
    e1.setXingMing("张三");
    e1.setNianLing(23);
    e1.setXinZi(10000.f);
    e1.show();
    
    Employee e2=new Employee();
    e2.setBianHao(2);
    e2.setXingMing("李四");
    e2.setNianLing(22);
    e2.setXinZi(11000);
    e2.show();
  }

第 2 题

案例：
声明一个日期类MyDate，包含属性：年、月、日
声明一个Test02测试类，并在main方法中，创建 3 个日期对象，一个是你的出生日期，一个是我们开班
的日期，一个是今年过年的日期，并打印显示

public class MyDate {

	private int year, month, date;

	// 读取器，用于获取对象种的私有属性值
	public int getYear() {
		return year;
	}

	// 设置器，用于向对象种传入特定的属性值
	public void setYear(int year) {
		this.year = year;
	}

	public int getMonth() {
		return month;
	}

	public void setMonth(int month) {
		if (month > 0) {
			if (month > 12) {
				int y = month / 12;

				if (y > 0)
					year += y;
				month %= 12;
			} else {
				int y = month / 12 - 1;
				year += y;
				month = (-1 * y) * 12 + month;
			}
			this.month = month;
		}
	}

	public int getDate() {
		return date;
	}

	private int getMaxDate() {
		int res = 0;
		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 ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
				res = 29;
			} else
				res = 28;
			break;
		default:
			res = 0;
			break;
		}
		return res;
	}

	public void setDate(int date) {
		if (date > 0) {
			while (true) {
				if (date > getMaxDate()) {
					date = date - getMaxDate();
					month++;
				}
				if (getMaxDate() >= date)
					break;
			}
		}
		this.date = date;
	}

	public String show() {
		return year + "年" + month + "月" + date + "日";
	}
}

第 3 题

案例：
声明公民类Citizen，包含属性：姓名，生日，身份证号，其中姓名是String类型，生日是MyDate类型，
身份证号也是String类型。
声明Test03测试类，在main方法中创建你们家庭成员的几个对象，并打印信息。

public class Citizen {
//姓名，生日，身份证号
	private String name;
	private MyDate birth;
	private String cardNo;

	public void show() {
		System.out.println("姓名：" + name + ",出生日期：" + birth.show() + ",身份证号码:" + cardNo);
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public MyDate getBirth() {
		return birth;
	}

	public void setBirth(MyDate birth) {
		this.birth = birth;
	}

	public String getCardNo() {
		return cardNo;
	}

	public void setCardNo(String cardNo) {
		this.cardNo = cardNo;
	}

}

public static void main(String[] args) {
    Citizen[] cs = new Citizen[3];
    cs[0] = new Citizen();
    cs[0].setName("小黑");
    MyDate md1 = new MyDate();
    md1.setYear(2020);
    md1.setMonth(3);
    md1.setDate(20);
    cs[0].setBirth(md1);
    cs[0].setCardNo("610103999999");

    cs[1] = new Citizen();
    cs[1].setName("小白");
    MyDate md2 = new MyDate();
    md2.setYear(2021);
    md2.setMonth(6);
    md2.setDate(30);
    cs[1].setBirth(md2);
    cs[1].setCardNo("610103999999");

    for (int i = 0; i < cs.length; i++)
      if (cs[i] != null)
        cs[i].show();
  }

第 4 题

案例：
声明一个日期类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方法中创建对象，并调用测试

import java.time.LocalDate;
import java.util.Date;

public class MyDate {
  private int year, month, date;

  // 读取器，用于获取对象种的私有属性值
  public int getYear() {
    return year;
  }

  // 设置器，用于向对象种传入特定的属性值
  public void setYear(int year) {
    this.year = year;
  }

  public int getMonth() {
    return month;
  }

  public void setMonth(int month) {
    if (month > 0) {
      int y = month / 12;
      if (y > 0)
        year += y;
      month %= 12;
    } else {
      int y = month / 12 - 1;
      year += y;
      month = (-1 * y) * 12 + month;
    }
    this.month = month;
  }

  public int getDate() {
    return date;
  }

  private int getMaxDate() {
    int res = 0;
    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 ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
        res = 29;
      } else
        res = 28;
      break;
    default:
      res = 0;
      break;
    }
    return res;
  }

  public void setDate(int date) {
    if (date > 0) {
      while (true) {
        if (date > getMaxDate()) {
          date = date - getMaxDate();
          month++;
        }
        if (getMaxDate() >= date)
          break;
      }
    }
    this.date = date;
  }

  public String show() {
    return year + "年" + month + "月" + date + "日";
  }
}

第 5 题

案例：
声明一个三角形类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, b, c;

//判断是否是一个直角三角形
  boolean isRightTriangle() {
    if (isTriangle()) {
      return a * a + b * b == c * c || a * a + c * c == b * b || b * b + c * c == a * a;
    }
    return false;
  }

  private boolean isTriangle() {
    return a + b > c && a + c > b && b + c > a;
  }

  public static void main(String[] args) {
    Triangle t=new Triangle();
    t.setA(3);
    t.setB(4);
    t.setC(6);
    System.out.println(t.isRightTriangle()?"直角三角形":"不是直角三角形");
  }

  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 Triangle {
  private int a, b, c;

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

  double getLength() {
    return a + b + c;
  }

  boolean isEquilateralTriangle() {
    if (isTriangle())
      return a == b && b == c;
    return false;
  }

  boolean isIsoscelesTriangle() {
    if (isTriangle())
      return a == b || a == c || b == c;
    return false;
  }

//判断是否是一个直角三角形
  boolean isRightTriangle() {
    if (isTriangle()) {
      return a * a + b * b == c * c || a * a + c * c == b * b || b * b + c * c == a * a;
    }
    return false;
  }

  private boolean isTriangle() {
    // 规则：任意两边之和大于第三边
    return a + b > c && a + c > b && b + c > a;
  }

  public static void main(String[] args) {
    Triangle t = new Triangle();
    t.setA(3);
    t.setB(4);
    t.setC(6);
    System.out.println(t.isRightTriangle() ? "直角三角形" : "不是直角三角形");
  }

//==============
  public int getA() {
    return a;
  }

  public void setA(int a) {
    this.a = a;
  }

  public int getB() {
    return b;
  }

  public void setB(int b) {
    this.b = b;
  }

  public int getC() {
    return c;
  }

  public void setC(int c) {
    this.c = c;
  }

}

第 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 {
	/*
	 * 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的四舍五入后的整数值
	 */
	int add(int a, int b) {
		return a + b;
	}

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

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

	int divide(int a, int b) {
		if (b != 0)
			return a / b;
		return 0;
//		return Integer.MIN_VALUE;
	}

	int remainder(int a, int b) {
		if (b != 0)
			return a % b;
		return Integer.MIN_VALUE;
	}

	int max(int a, int b) {
		if (a > b)
			return a;
		return b;
//		Math.max(a,b);
	}

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

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

	boolean doubleEquals(double a, double b) {
		return Math.abs(a - b) < 1e-6;
	}

	boolean isEven(int a) {
		return a % 2 == 0;
	}

	boolean isOdd(int a) {
		return !isEven(a);
	}

	boolean isPrimeNumer(int a) {
		boolean res = true;
		for (int i = 2; i < a; i++) {
			if (a % i == 0) {
				res = false;
				break;
//				return false;
			}
		}
		return res;
	}

	int round(double d) {
		if (d < Integer.MAX_VALUE && d > Integer.MIN_VALUE)
			return (int) Math.round(d);
		return -1;
	}
}

第 7 题

案例：
声明一个数组管理工具类MyArrays，包含如下方法：
1 、void sort(int[] arr)：可以为任意一维整型数组arr实现从小到大排序
2 、int indexOf(int[] arr, int value)：可以在任意一维整型数组arr中使用折半查找法查找value值的下
标，如果不存在返回-
3 、int[] copy(int[] arr, int len)：可以实现从任意一维数组arr中复制一个新数组返回，新数组的长度为
len，从arr[0]开始复制
声明一个Test07测试类，并在main方法中调用测试

public class MyArrays {
	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 tmp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = tmp;
				}
			}
		}
	}

	int indexOf(int[] arr, int value) {
		sort(arr);
		int index = -1;
		int min = 0;
		int max = arr.length - 1;
		while (min <= max) {
			int pos = (min + max) / 2;
			if (arr[pos] < value)
				min = pos + 1;
			else if (arr[pos] > value)
				max = pos - 1;
			else {
				index = pos;
				break;
			}
		}
		return index;
	}

	int[] copy(int[] arr, int len) {
		int[] res = new int[len];
		int cc = 0;
		for (int i = 0; i < res.length; i++) {
			res[i] = arr[cc++];
			cc = cc % arr.length;
		}
		return res;
	}

	public static void main(String[] args) {
		int[] arr = { 2, 3, 7, 5, 6, 1 };
		MyArrays ma = new MyArrays();
//		ma.sort(arr);
//		for (int tmp : arr)
//			System.out.print(tmp + "\t");
//		int pos=ma.indexOf(arr, 7);
//		System.out.println(pos);

		int[] brr = ma.copy(arr, 20);
		for (int tmp : brr)
			System.out.print(tmp + "\t");
	}
}

第 8 题

案例：
声明一个常识工具类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)：判断某年是否是闰年
声明一个Test08测试类，并在main方法中调用测试

public class DateCommonTools {
	String getWeekName(int week) {
		String[] str = new String[] { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
		if (week > 0)
			return str[week % str.length];
		return "未知";
	}

	String getMonthName(int month) {
		String[] str = new String[] { "January", "february", "March", "April", "May", "June", "July", "August",
				"September", "October", "November", "December" };
		if (month > 0)
			return str[month % str.length];
		return "未知";
	}

	int getTotalDaysOfMonth(int year, int month) {
		int res = -1;
		if (month > 0) {
			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 = 29;
				res = 28;
				break;
			default:
				res = 0;
				break;
			}
		}
		return res;
	}

	int getTotalDaysOfYear(int year) {
		if (isLeapYear(year))
			return 366;
		return 365;
	}

	boolean isLeapYear(int year) {
		return ((year % 4 == 0 && year % 100 != 0) || (year % 400) == 0);
	}
}