面向对象编程：基础与实践-优快云博客

本文链接：https://blog.youkuaiyun.com/rucoding/article/details/120848174

文章目录

- - 面向对象编程（上）

面向对象编程（上）

1、面向过程与面向对象

请问，何为 “面向对象” 的编程思想？估计一时半会也琢磨不透，也许得达到一定的代码量，亦或某一瞬间渐悟、顿悟了。（道路且长，慢慢求索…）

一、概念解释
面向过程: Procedure Oriented Programming POP
面向对象: Object Oriented Programming  OOP

举个例子:
假如我们现在给一远方的朋友寄送东西。
按照面向对象的思维，首先，我们会找一家快递公司，把东西、朋友地址信息给快递公司，快递公司确认后，就会寄送给朋友。（快递公司可以看成是对象）;
按照面向过程的思维，我们会自己想办法拿东西到朋友家那里。

二、学习内容
①、java的面向对象是核心之处，后续也是围绕这个javacore基础展开，所以，务必多理解多练习，反复巩固，慢慢体会面向对象的编程思想。
②、学习java面向对象的三条主线内容:
 1)、Java类和类的成员: 属性、方法、构造器、代码块、内部类
 2)、面向对象的三大特征: 封装、继承、多态性、(抽象性)
 3)、其它关键: this、super、static、final、abstract、interface、package、import 等
 
③、人把大象放进冰箱
a.面向过程: 强调的是功能行为，以函数为最小单位，考虑的是怎么做。
	①.打开冰箱
	②.把大象装进冰箱
	③.把冰箱门关闭
b.面向对象: 强调的是功能的对象，以类/对象为最小单位，考虑谁来做

 *人{ //人看成一个对象
 * 		打开(冰箱){  //打开冰箱功能
 * 			冰箱.开门();
 * 		}操作(大象){
 * 			大象.进入(冰箱);
 * 		}关闭(冰箱){
 * 			 冰箱.关门();     
 * 		}
 * }
 
 
 * 冰箱{
 * 		开(){
 * 		}  
 * 		关(){
 * 		}
 * }
 
 * 大象{
 * 		进入(冰箱){
 * 		}
 * }



三、面向对象的思想概述
1)、程序员从面向过程的执行者转化成了面向对象的指挥者
2)、面向对象分析方法分析问题的思路和步骤：
	根据问题需要，选择问题所针对的现实世界中的实体。
	从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
	把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
	将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

2、类和对象

面向对象的两个要素:
①.类: 对一类事物的描述，是抽象的、概念上的定义;
②.对象: 是实际存在的该类事物的每个个体，因而也称为实例(instance)
可以理解为: 类==>抽象概念的人; 对象==> 实实在在的某个人
面向对象程序设计的重点: 类的设计
设计类，其实本质上就是设计类的成员 (属性 + 方法)。

2.1、Java类和类的成员

①.Java类可以看成是对象的模板。

例如：下图的Dog为类（class），而具体的每个品种Dog1、Dog2、Dog3为该Dog类的对象（Object），对象包含了Dog的品种、大小、颜色、年龄。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zQtYyz15-1634630207429)(object_images/image-20211014164542284.png)]

②.类的成员：

包含属性（对应类的成员变量）和方法（对应类的成员方法），例如上述图示的属性（breed/size/color/age) 和方法【eat()/run()/sleep()/name()】。

2.2、类与对象的创建及使用

一、面向对象程序设计的重点就是类的设计
	设计类，其实本质上就是设计类的成员
	Field = 属性 = 成员变量 = 域、字段
	Method = 成员方法 = 函数

二、类和对象的使用（面向对象编程思想落地的实现）
	1)、创建类、设计类的成员
	2)、创建类的对象
	3)、通过“对象.属性” 或者 “对象.方法” 调用对象的结构。

三、如果创建一个类的多个对象，则每个对象都独立拥有一套类的属性。
	意味着: 如果我们修改一个对象的属性a, 则不影响另一个对象的属性a的值。

代码演示：

package com.rucoding.d8;

/**
 * @author LiuYiXin
 *
 */
public class PersonTest {
	/**
	 * 	1)、创建类、设计类的成员
	 *	2)、创建类的对象
	 *	3)、通过“对象.属性” 或者 “对象.方法” 调用对象的结构。
	 */
	public static void main(String[] args) {
		/*
		 * 2、创建类的对象
		 * 语法形式： 类名 对象名 = new 类名();
		 */
		Person p1 = new Person();
		
		/*
		 * 3、通过“对象.属性” 或者 “对象.方法” 调用对象的结构。
		 */
		
		//对象.属性
		p1.name = "Tom";
		p1.age = 25;
		p1.isMale = true;
		System.out.println(p1.name);
		
		//对象.方法
		p1.eat();
		p1.sleep();
		p1.talk("中文"); //传参
		
		
		//=========================
		Person p2 = new Person(); //每个新开辟的对象都是独立的个体
		System.out.println(p2.name); //null 默认初始化值
		System.out.println(p2.isMale); //false 
		
		//=========================
		//这里跟之前数组arry2 = array1 ，赋值操作，还是同一个地址值
		//p1保存的地址值， 赋值给了p3,导致p1和p3实际上指向的还是堆空间的同一个实体对象。
		Person p3 = p1;
		System.out.println(p3.name);
		
		p3.age = 10;
		System.out.println(p1.age);
		
	
	}
	
}

/*
 * 类的语法格式：
 * 修饰符 class 类名{
 * 	属性声明;
 * 	方法声明;
 * }
 */

//1、创建类、设计类的成员
class Person{
	
	//类的成员
	String name;
	int age;
	boolean isMale;
	
	//类的方法
	public void eat(){
		System.out.println("恰饭....");
	}
	
	public void sleep(){
		System.out.println("睡觉...");
	}
	
	public void talk(String language){ //形参的定义
		System.out.println("我们说的都是：" + language);
	}
	
	
}

2.3、对象的创建和使用: 内存解析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eK1RUDPf-1634630207430)(object_images/image-20211014173044352.png)]

1)、堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在 Java 虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。
2)、通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference 类型，它不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。
3)、方法区（MethodArea），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

图解案例1：

Person p1= new Person();
p1.name = "Tom";
p1.isMale = true;
Person p2 = new Person();
sysout(p2.name);//null
Person p3 = p1;
p3.age = 10;

内存结构图解析：

在这里插入图片描述

图解案例2：

Person p1= newPerson();
p1.name = "胡利民";
p1.age = 23;
Person p2 = new Person();
p2.age = 10;

内存结构图解析：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D1dNwsSi-1634630207434)(object_images/image-20211015101148579.png)]

3、类的成员之一：属性

类中的属性使用

属性(成员变量) vs 局部变量
1)、相同点
	a.定义变量的格式: 数据类型 变量名 = 变量值;
	b.先声明，后使用
	c.都有对应的作用域范围
2)、不同点
	①.声明的位置不同
	成员变量: 在类中{}内
	局部变量: 声明在类的方法内
	②.关于权限修饰符不同
	成员变量: 声明时可以使用权限修饰符，成员变量的权限修饰符可以是 public、private、缺省、protected
	局部变量: 不可以使用权限修饰符
	③.默认的初始值不同
	成员变量:类的属性，根据其类型，都有默认初始化值。
  			整型(byte、short、int、long):0
  			浮点型(float、double):0.0
  			字符型(char):0(或‘\u0000’)
  			布尔型(boolean):false
 			引用数据类型(类、数组、接口):null
  
 	局部变量:没有默认初始化值
  			意味着:在调用局部变量之前，一定要显式赋值。
  			特别地:形参在调用时,赋值即可。
  	④.在内存中加载的位置，亦各不相同。
  	成员变量: 加载到堆空间heap (这里指的的非static静态)
  	局部变量: 加载到栈stack空间

代码演示：

package com.rucoding.d8;

/**
 * @author LiuYiXin
 *
 */
public class UserTest {
	/*
	 * 类中属性的使用
	 * 
	 * 属性(成员变量)	vs	局部变量
	 * 1.相同点:
	 * 		1.1 定义变量的格式:数据类型 变量名 = 变量值
	 * 		1.2 先声明，后使用
	 * 		1.3 变量都有其对应的作用域
	 * 				
	 * 2.不同点:
	 * 		2.1 在类中声明的位置不同
	 * 		属性:直接定义在类的一对{}内
	 * 		局部变量:声明在方法内、方法形参、构造器形参、构造器内部的变量
	 * 
	 * 		2.2 关于权限修饰符的不同
	 * 		属性:可以在声明属性时，指明其权限，使用权限修饰符。
	 * 			常用的权限修饰符:private、public、缺省、protected
	 * 			目前声明属性时，都使用缺省即可。
	 * 		局部变量:不可以使用权限修饰符。
	 * 
	 * 		2.3 默认初始化值的情况:
	 * 		属性:类的属性，根据其类型，都有默认初始化值。
	 * 			整型(byte、short、int、long):0
	 * 			浮点型(float、double):0.0
	 * 			字符型(char):0(或‘\u0000’)
	 * 			布尔型(boolean):false
	 * 
	 * 			引用数据类型(类、数组、接口):null
	 * 
	 * 		局部变量:没有默认初始化值
	 * 			意味着:在调用局部变量之前，一定要显式赋值。
	 * 			特别地:形参在调用时,赋值即可。例，45 行
	 * 
	 * 		2.4 在内存中加载的位置，亦各不相同。
	 * 		属性:加载到堆空间中(非 static)
	 * 		局部变量:加载到栈空间
	 */
	
	public static void main(String[] args) {
		//第二步：创建类的对象
		User user = new User();
		
		//第三步，通过 对象.属性 或者 对象.方法， 调用对象的结构
		System.out.println(user.name);
		System.out.println(user.age);
		System.out.println(user.isMale);
		
		user.talk("中文");
		user.eat();
	}
	
}

//第一步：创建类， 设计类的成员
class User{
	
	//类的成员变量 属性
	String name;
	public int age; //不加public，即为缺省
	boolean isMale;
	
	//类的成员方法
	public void talk(String language){//language 为形参，也是局部变量
		System.out.println("我们使用" + language + "进行交流。");
	}
	
	public void eat(){
		String food = "烙饼";//局部变量
		System.out.println("北方人喜欢吃:" + food);
	}
	
	
}

练习1：

package com.rucoding.d8;

/**
 * @author LiuYiXin
 *
 */
public class SchoolTest {
	/*
	编写教师类和学生类，并通过测试类创建对象进行测试
	Student类
	属性:
	name:String age:int major:String interests:String
	方法:say() 返回学生的个人信息
	Teacher类
	属性:
	name:String age:int teachAge:int course:String
	方法:say() 输出教师的个人信息
	*/
	
	public static void main(String[] args) {
		//第二步，创建类的对象
		Teacher teacher = new Teacher();
		Student student = new Student();
		
		//第三步，通过 对象.属性 或者 对象.方法，调用对象的结构
		teacher.name = "钱老师";
		teacher.age = 25;
		teacher.teacherAge = 3;
		teacher.course = "高数";
		teacher.say();
		System.out.println("==========================");
		student.name = "张三";
		student.age = 18;
		student.major = "高数课程（一）";
		student.interests = "Running";
		student.say();
		
	}
	
}

//第一步，创建类，设计类的成员	
class Teacher{
	//类的属性
	String name;
	int age;
	int teacherAge;
	String course;
	
	//类的方法
	public void say(){
		System.out.println("老师的名字为: " + name + "\n" + "年龄为：" + age + "\n" + "教龄为：" + teacherAge + "\n" +"授课内容为：" + course);
	}
}


//第一步，创建学生类，设计类的成员
class Student{
	//类的属性
	String name;
	int age;
	String major;
	String interests;
	
	//类的方法
	public void say(){
		System.out.println("学生的名字为: " + name + "\n" + "年龄为：" + age + "\n" + "主修课程为：" + major + "\n" +"兴趣爱好为：" + interests);
	}
}

4、类的成员之二：方法

4.1、类中的方法声明和使用

/*
 * 类中方法的声明和使用
 * 
 * 方法：描述类应该具有的功能。
 * 比如：Math类：sqrt()\random() \...
 *     Scanner类：nextXxx() ...
 *     Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...
 * 
 * 1).举例：
 * public void eat(){}
 * public void sleep(int hour){}
 * public String getName(){}
 * public String getNation(String nation){}
 * 
 * 2). 方法的声明：权限修饰符  返回值类型  方法名(形参列表){
 * 					方法体
 * 			  }
 *   注意：static、final、abstract 来修饰的方法，后面再讲。
 *   
 * 3). 说明：
 * 		3.1) 关于权限修饰符：默认方法的权限修饰符先都使用public
 * 			Java规定的4种权限修饰符：private、public、缺省、protected  -->封装性再细说
 * 
 * 		3.2) 返回值类型： 有返回值  vs 没有返回值
 * 			3.2.1)  如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
 *                return关键字来返回指定类型的变量或常量：“return 数据”。
 * 				  如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要
 *               使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
 * 
 * 			3.2.2) 我们定义方法该不该有返回值？
 * 				① 题目要求
 * 				② 凭经验：具体问题具体分析
 * 
 *      3.3) 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
 *      3.4) 形参列表:方法名可以声明0个、1个，或多个形参。
 *      	3.4.1) 格式:数据类型1 形参1，数据类型2 形参2,...
 *      
 *      	3.4.2) 我们定义方法时，该不该定义形参？
 *      		① 题目要求
 *      		② 凭经验，具体问题具体分析
 *      3.5) 方法体:方法功能的体现。
 *  4). return关键字的使用：
 *  	1).使用范围:使用在方法体中
 *  	2).作业: ① 结束方法
 *  		    ② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
 *  	3).注意点:return关键字后不可声明执行语句。
 *  5). 方法的使用中，可以调用当前类的属性或方法。
 *  	特殊的:方法A中又调用了方法A:递归方法。
 *  	方法中不能定义其他方法。
 */

代码演示：

package com.rucoding.d8;

/**
 * @author LiuYiXin
 *
 */
public class CustomerTest {
	public static void main(String[] args) {
		//第二步，创建类的对象
		Customer customer = new Customer();
		
		//第三步，通过 对象.属性 或者 对象.方法，调用对象的内部结构
		customer.eat();
		customer.sleep(8);
		
		//讨论形参是否需要设置的问题
//		int[] arr = new int[]{3,4,5,2,5};
//		customer.sort();
		
	}
}


//第一步，创建类， 设计类的成员
class Customer{
	//类的成员变量， 属性
	String name;
	int age;
	boolean isMale;
	
	//类的方法
	public void eat(){
		System.out.println("客户吃饭");
		return;
		//return后不可以声明表达式
		//System.out.println("hello");
	}
	
	public void sleep(int hour){
		System.out.println("休息了" + hour + "个小时");
		eat(); //方法中可以继续调用其他方法
//	    sleep(10); //报错StackOverflowError ，一直定义形参的局部变量hour，一直入栈， 导致栈溢出
	}
	
	//有返回值类型的方法
	public String getName(){
		if(age > 18){
			return name;
		}else{
			return "Tom";  //必须有返回值
		}
	}
	
	public String getNation(String nation){
		String info = "我的国籍是: " + nation;
		return info;
	}
	
	//讨论形参是否需要设置的问题
//	public void sort(int[] arr){
//		
//	}
//	
//	public void sort(){
//		int[] arr = new int[]{3,4,5,2,5};
//		//;
//	}
	
}

练习1：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R6acA1sn-1634630207435)(object_images/image-20211015105722062.png)]

练习1代码演示：

package com.rucoding.d8;

/**
 * @author LiuYiXin
 *
 */
public class PersonTest01 {
	/*
	 * 要求：
	 * (1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，输出字符串
	 * “studying”，调用showAge()方法显示age值，调用addAge()方法给对象的age属性值增加2岁。
	 * (2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。
	 * 
	*/
	
	public static void main(String[] args) {
		//第二步，创建类的对象
		PersonHuman p1 = new PersonHuman();
		//第三步，通过 对象.属性 或者 对象.方法 ，调用对象的结构
		p1.name = "小新";
		p1.age = 18;
		p1.sex = 1;
		
		p1.study();
		p1.showAge();
		System.out.println(p1.name + "两年后的年龄为：" + p1.addAge(2));
		
		System.out.println("==========================");
		PersonHuman p2 = new PersonHuman();
		p2.showAge(); //0
		p2.addAge(10);
		p2.showAge(); //10
		
	}
	
}


//第一步，创建类， 设计类的成员
class PersonHuman{
	//类的属性
	String name;
	int age;
	/**
	 * sex 为 1 代表 男性
	 * 为 0 代表女性
	 */
	int sex;
	
	//类的成员方法
	public void study(){
		System.out.println("studying");
	}
	
	public void showAge(){
		System.out.println("age为：" + age);
	}
	
	public int addAge(int i){
		age +=i;
		return age;
	}
	
}

练习2：

* 2.利用面向对象的编程方法，设计类Circle计算圆的面积。

练习2的代码演示：

package com.rucoding.d8;

/**
 * @author LiuYiXin
 *
 */
public class CircleTest {
	/*
	 * 2.利用面向对象的编程方法，设计类Circle计算圆的面积。
	 */
	
	public static void main(String[] args) {
		//第二步，创建类的对象
		Circle c1 = new Circle();
		//第三步，通过 对象.属性 或者 对象.方法，调用对象的内部结构
		c1.radiu = 2;
		System.out.println("圆的面积为：" + c1.getArea());
	}
}	


//第一步，创建类， 设计类的成员
class Circle{
	//类的属性
	double radiu;
	
	//类的方法
	public double getArea(){
		return Math.PI * radiu * radiu;
	}
	
	
}

练习3：

/*
 * 1) 编写程序，声明一个method方法，在方法中打印一个10*8的*型矩形，在main方法中调用该方法。
 * 2) 修改上一个程序，在method方法中，除打印一个10*8的*型矩形外，再计算该矩形的面积，
 * 并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
 * 
 * 3) 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m*n的*型矩形，
 * 并计算该矩形的面积，将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
 * 
 */

练习3的代码演示：

package com.rucoding.d8;

/**
 * @author LiuYiXin
 *
 */
public class JuZhenTest {
	/*
	 * 1) 编写程序，声明一个method方法，在方法中打印一个10*8的*型矩形，在main方法中调用该方法。
	 * 2) 修改上一个程序，在method方法中，除打印一个10*8的*型矩形外，再计算该矩形的面积，
	 * 并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
	 * 
	 * 3) 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m*n的*型矩形，
	 * 并计算该矩形的面积，将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
	 * 
	 */

	public static void main(String[] args) {
		//第二步，创建类的对象
		JuZhen jz = new JuZhen();
		//第三步， 通过 对象.属性 或者 对象.方法，调用对象的内部结构
//		jz.method();
		//修改1
//		int area = jz.getArea();
//		System.out.println("面积值为：" + area);
		//修改2
		int area2 = jz.getArea2(5,5);
		System.out.println("面积值为：" + area2);
		
	}
	
	
}

//第一步，创建类， 设计类的成员
class JuZhen{
	//类的属性
	
	//类的方法
	public void method(){
		//外层控制行数，内层控制列数
		for(int i = 1;i <= 8;i++){
			for(int j = 1;j <= 10;j++){
				System.out.print("*" + " ");
			}
			System.out.println();
		}
	}
	
	//修改1
	public int getArea(){
		int area = 8 * 10;
		//外层控制行数，内层控制列数
		for(int i = 1;i <= 8;i++){
			for(int j = 1;j <= 10;j++){
				System.out.print("*" + " ");
			}
			System.out.println();
		}
		return area;
	}
	
	//修改2
	public int getArea2(int m,int n){
		int area = m * n;//计算面积
		//外层控制行数， 内层控制列数
		for(int i = 1;i <= m;i++){
			for(int j = 1;j <=n;j++){
				System.out.print("*" + " ");
			}
			System.out.println();
		}
		return area;
	}
	
}

练习4：

/*
 * 4). 对象数组题目：
 * 定义类Student，包含三个属性：
 * 学号number(int)，年级state(int)，成绩score(int)。
 * 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
 * 问题一：打印出3年级(state值为3）的学生信息。
 * 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
 * 提示：1) 生成随机数：Math.random()，返回值类型double;  
 * 		2) 四舍五入取整：Math.round(double d)，返回值类型long。
 * 
 */

练习4代码演示：

package com.rucoding.d8;

/**
 * @author LiuYiXin
 *
 */
public class StudentTest {
	/*
	 * 4). 对象数组题目：
	 * 定义类Student，包含三个属性：
	 * 学号number(int)，年级state(int)，成绩score(int)。
	 * 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
	 * 问题一：打印出3年级(state值为3）的学生信息。
	 * 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
	 * 提示：1) 生成随机数：Math.random()，返回值类型double;  
	 * 		2) 四舍五入取整：Math.round(double d)，返回值类型long。
	 * 
	 */
	
	public static void main(String[] args) {
		//创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
		StudentInfo[] stuArr = new StudentInfo[20]; //声明
		for(int i = 0;i < stuArr.length;i++){
			//给数组元素赋值
			stuArr[i] = new StudentInfo(); //未声明之前，堆空间的索引0~19 都为null
			stuArr[i].number = i + 1; //赋值学号
			stuArr[i].state  = (int)(Math.random()*(6 - 1 + 1) +1); //赋值年级1~6 [1,6]
			stuArr[i].score = (int)(Math.random()*(100 - 0 + 1)); //赋值成绩 0~100 [0,100]
		}
		//遍历学生信息
		
		for(int i = 0;i < stuArr.length;i++){
			System.out.print("学号:" + stuArr[i].number);
			System.out.print(" 年级:" + stuArr[i].state);
			System.out.print(" 成绩:" + stuArr[i].score);
			System.out.println();
		}
		
		System.out.println("==============以上为学生的成绩信息============");
		
		//第二步，创建类的对象
		StudentInfo s1 = new StudentInfo();
		
		//第三步，通过 对象.属性 或者 对象.方法 ，调用对象的内部结构
		//问题一：打印出3年级(state值为3）的学生信息。
		for(int i = 0;i < stuArr.length;i++){
			if(3 == stuArr[i].state){
				System.out.print("学号:" + stuArr[i].number);
				System.out.print(" 年级:" + stuArr[i].state);
				System.out.print(" 成绩:" + stuArr[i].score);
				System.out.println();
			}		
		}
		
		System.out.println("=========按照学生成绩排序==========");
		
		//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
		for(int i = 0;i < stuArr.length - 1;i++){
			for(int j = 0;j < stuArr.length - 1 - i;j++){
				//按照成绩排序，
				if(stuArr[j].score > stuArr[j + 1].score){
					StudentInfo temp = stuArr[j];
					stuArr[j] = stuArr[j + 1];
					stuArr[j + 1] = temp;
				}
			}
		}
			
		//遍历学生信息
		for(int i = 0;i < stuArr.length;i++){
			System.out.print("学号:" + stuArr[i].number);
			System.out.print(" 年级:" + stuArr[i].state);
			System.out.print(" 成绩:" + stuArr[i].score);
			System.out.println();
		}
		
	}
	
}

//第一步， 创建类， 设计类的成员
class StudentInfo{
	//类的属性
	int number; //学号
	int state; //年级
	int score; //成绩
	
}

练习4代码优化演示：

package com.rucoding.d8;

/**
 * @author LiuYiXin
 *
 */
public class StudentTest2 {
	/*
	 * 4). 对象数组题目：
	 * 定义类Student，包含三个属性：
	 * 学号number(int)，年级state(int)，成绩score(int)。
	 * 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
	 * 问题一：打印出3年级(state值为3）的学生信息。
	 * 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
	 * 提示：1) 生成随机数：Math.random()，返回值类型double;  
	 * 		2) 四舍五入取整：Math.round(double d)，返回值类型long。
	 * 
	 */
	
	public static void main(String[] args) {
		
		//创建对象
		StudentTest2 stuTest2 = new StudentTest2();
		
		//创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
		StudentInfo2[] stuArr = new StudentInfo2[20]; //声明
		for(int i = 0;i < stuArr.length;i++){
			//给数组元素赋值
			stuArr[i] = new StudentInfo2(); //未声明之前，堆空间的索引0~19 都为null
			stuArr[i].number = i + 1; //赋值学号
			stuArr[i].state  = (int)(Math.random()*(6 - 1 + 1) +1); //赋值年级1~6 [1,6]
			stuArr[i].score = (int)(Math.random()*(100 - 0 + 1)); //赋值成绩 0~100 [0,100]
		}
		//遍历学生信息
		stuTest2.getInfo(stuArr);
		System.out.println("==============以上为学生的成绩信息============");

		//第二步，创建类的对象
		StudentInfo2 s1 = new StudentInfo2();
		
		//第三步，通过 对象.属性 或者 对象.方法 ，调用对象的内部结构
		//问题一：打印出3年级(state值为3）的学生信息。
		stuTest2.getStuInfoByState(stuArr,3);
		System.out.println("=========按照学生成绩排序==========");
		
		//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
		stuTest2.sort(stuArr);
		//遍历学生信息
	    stuTest2.getInfo(stuArr);
		
	}
	
	//遍历学生信息的方法
	/**
	 * @Description 遍历StudentInfo2[]数组的操作
	 * @param stuArr
	 */
	public void getInfo(StudentInfo2[] stuArr){
		//遍历学生信息
		for(int i = 0;i < stuArr.length;i++){
			System.out.println(stuArr[i].getStuInfo());
		}		
	}
	
	//查找学生信息
	public void getStuInfoByState(StudentInfo2[] stuArr,int state){
		for(int i = 0;i < stuArr.length;i++){
			if(3 == stuArr[i].state){
				System.out.println(stuArr[i].getStuInfo());
			}		
		}		
	}
	
	//按照学生成绩排序
	public void sort(StudentInfo2[] stuArr){
		for(int i = 0;i < stuArr.length - 1;i++){
			for(int j = 0;j < stuArr.length - 1 - i;j++){
				//按照成绩排序，
				if(stuArr[j].score > stuArr[j + 1].score){
					StudentInfo2 temp = stuArr[j];
					stuArr[j] = stuArr[j + 1];
					stuArr[j + 1] = temp;
				}
			}
		}
	}
	
	
}

//第一步， 创建类， 设计类的成员
class StudentInfo2{
	//类的属性
	int number; //学号
	int state; //年级
	int score; //成绩

	//输出学生信息的方法
	public String getStuInfo(){
		return "学号为:" + number + " 年级为:" + state + " 成绩为:" +score;
	}
}

练习4的内存结构图解：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ySDUktqb-1634630207436)(object_images/image-20211017150234089.png)]

练习5：

声明一个日期类型MyDate：有属性：年year,月month，日day。创建2个日期
对象，分别赋值为：你的出生日期，你对象的出生日期，并显示信息。

练习5的代码演示：

package com.rucoding.d8;

/**
 * @author LiuYiXin
 *
 */
public class ObjectTest01 {
	//声明一个日期类型MyDate：有属性：年year,月month，日day。创建2个日期
	//对象，分别赋值为：你的出生日期，你对象的出生日期，并显示信息。
	
	public static void main(String[] args) {
		Mydate m1 = new Mydate();//第二步，创建类的对象
		new ObjectTest01().setInfo(m1,1997, 10, 31);
		m1.printBirthDate(); //第三步， 对象.属性或者对象.方法
		
		Mydate m2 = new Mydate();
		new ObjectTest01().setInfo(m2,1997, 4, 20);
		m2.printBirthDate();
	}
	
	
	//赋值方法
	public void setInfo(Mydate m1,int y,int m,int d){
		m1.year = y;
		m1.month = m;
		m1.day = d;
	}
	
}



//第一步，创建类，设计类的成员
class Mydate{
	//属性定义
	int year; //年份
	int month; //月份
	int day; //日期
	
	//输出信息
	public void printBirthDate(){
		System.out.println("出生日期为: " + year + "年" + month + "月" + day + "日");
	}
	
}

4.2、自定义数组的工具类

/*
 * 自定义数组工具类
 */
public class ArrayUtil {

	// 求数组的最大值
	public int getMax(int[] arr) {
		int maxValue = arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (maxValue < arr[i]) {
				maxValue = arr[i];
			}
		}
		return maxValue;
	}

	// 求数组的最小值
	public int getMin(int[] arr) {
		int minValue = arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (minValue > arr[i]) {
				minValue = arr[i];
			}
		}
		return minValue;
	}

	// 求数组总和
	public int getSum(int[] arr) {
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		return sum;
	}

	// 求数组平均值
	public int getAvg(int[] arr) {
		int avgValue = getSum(arr) / arr.length;
		return avgValue;
	}

	// 反转数组
	public void reverse(int[] arr) {
		for (int i = 0; i < arr.length / 2; i++) {
			int temp = arr[i];
			arr[i] = arr[arr.length - i - 1];
			arr[arr.length - i - 1] = temp;
		}
	}

	// 复制数组
	public int[] copy(int[] arr) {
		int[] arr1 = new int[arr.length];
		for (int i = 0; i < arr1.length; i++) {
			arr1[i] = arr[i];
		}
		return null;
	}

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

	// 遍历数组
	public void print(int[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + ",");
		}
		System.out.println("]");
	}

	// 查找指定元素
	public int getIndex(int[] arr, int dest) {
		//线性查找
		for (int i = 0; i < arr.length; i++) {
			if (dest==arr[i]) {
				return i;
			}
		}
		return -1;
	}
}

4.3、方法的重载

方法的重载（overload）
1)、定义: 在同一类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。
	“两同一不同” : 同一个类、相同的方法名
				 参数列表不同: 参数个数不同、参数类型不同
2)、举例: Arrays类中的重载sort() / binarySeacher()
3)、判断是否重载: 与方法的返回类型、权限修饰符、形参变量名、方法体都无关。
4)、在通过对象调用方法时，如何确定某一个指定的方法
	方法名 ====> 参数列表

代码演示：

package com.rucoding.d9;

/**
 * @author LiuYiXin
 *
 */
public class OverLoadTest {
	/*
	 * 明确方法重载的定义：；两同一不同
	 * 同一个类、同一个方法名
	 * 参数类型不同
	 */
	public static void main(String[] args) {
		OverLoadTest overLoadTest = new OverLoadTest();
		overLoadTest.getSum("1", 2);
	}
	
	//以下四个方法构成了重载
	public void getSum(int i,int j){
		System.out.println("1");
	}
	
	public void getSum(double i ,double j){
		System.out.println("2");
	}
	
	public void getSum(String i,int j){
		System.out.println("3");
	}
	
	public void getSum(int i,String j){
		System.out.println("4");
	}
	
}

练习1：

1).判断：与void show(int a,char b,double c){} 构成重载的有：

a)void show(int x,char y,double z){} // no
b)int show(int a,double c,char b){} // yes
c) void show(int a,double c,char b){} // yes
d) boolean show(int c,char b){} // yes
e) void show(double c){} // yes 
f) double show(int x,char y,double z){} // no
g) void shows(){double c} // no

练习2：

/*
 * 1.编写程序，定义三个重载方法并调用。方法名为mOL。
 * 三个方法分别接收一个int参数、两个int参数、一个字符串参数。
 * 分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
 * 在主类的main ()方法中分别用参数区别调用三个方法。
 * 2.定义三个重载方法max()，
 * 第一个方法求两个int值中的最大值，
 * 第二个方法求两个double值中的最大值，
 * 第三个方法求三个double值中的最大值，并分别调用三个方法。
 * 
 */

代码演示：

package com.rucoding.d9;

/**
 * @author LiuYiXin
 *
 */
public class OverLoadever {
	public static void main(String[] args) {
		/*
		 * 1.编写程序，定义三个重载方法并调用。方法名为mOL。
		 * 三个方法分别接收一个int参数、两个int参数、一个字符串参数。
		 * 分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
		 * 在主类的main ()方法中分别用参数区别调用三个方法。
		 * 2.定义三个重载方法max()，
		 * 第一个方法求两个int值中的最大值，
		 * 第二个方法求两个double值中的最大值，
		 * 第三个方法求三个double值中的最大值，并分别调用三个方法。
		 * 
		 */
	
		//1.调用3个方法mOL
		OverLoadever overLoadever = new OverLoadever();	
		System.out.println(overLoadever.mOL(5));
		System.out.println(overLoadever.mOL(5,6));
		System.out.println(overLoadever.mOL("方法重载"));
		
		//2.调用方法max()
		System.out.println("较大值为：" + overLoadever.max(5, 6));
		System.out.println("较大值为：" + overLoadever.max(7, 6.0));
		System.out.println("较大值为：" + overLoadever.max(17,36,100));
		
	}
	
	//重载方法mOL()
	public int mOL(int i){
		return i*i;
	}
	
	public int mOL(int i,int j){
		return i*j;
	}
	
	public String mOL(String str){
		return str;
	}
	
	//重载方法max()
	public int max(int i,int j){
		return (i > j) ? i : j;
	}	
	
	public double max(double d1,double d2){
		return (d1 > d2) ? d1 : d2;
	}
	
	public double max(double d1,double d2,double d3){
		double max =  (d1 > d2) ? d1 : d2;
		return (max > d3) ? max : d3;
	}
	
}

4.5、可变个数的形参

JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。
/*
 * 可变个数形参的方法
 * 1.jdk 5.0新增的内容
 * 2.具体使用：
 * 	2.1 可变个数形参的格式：数据类型 ... 变量名
 * 	2.2 当调用可变个数形参的方法时，传入的参数的个数可以是：0个，1个，2个...
 * 	2.3可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
 *  2.4可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。即二者不可共存。
 *  2.5可变个数形参在方法中的形参中,必须声明在末尾。
 *  2.6可变个数形参在方法中的形参中，最多只能声明一个可变形参。
 */

代码演示：

package com.rucoding.d9;

/**
 * @author LiuYiXin
 *
 */
public class MethodArgs {
	/*
	 * 可变个数形参的方法
	 * 1.jdk 5.0新增的内容
	 * 2.具体使用：
	 * 	2.1 可变个数形参的格式：数据类型 ... 变量名
	 * 	2.2 当调用可变个数形参的方法时，传入的参数的个数可以是：0个，1个，2个...
	 * 	2.3可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
	 *  2.4可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。即二者不可共存。
	 *  2.5可变个数形参在方法中的形参中,必须声明在末尾。
	 *  2.6可变个数形参在方法中的形参中，最多只能声明一个可变形参。
	 */
	public static void main(String[] args) {
		//
		MethodArgs mTest = new MethodArgs();
		mTest.show(new String[]{"AA","BB","CC","EE"});
	}
	
	public void show(String ... strs){ //可变参数
		System.out.println("show(String ... strs)");
		for(int i = 0;i < strs.length;i++){
			System.out.println(strs[i]);
		}
	}
	
//	此方法与上一方法不可共存
//	public void show(String[] strs){
//		
//	}
	
	//The variable argument type String of the method show must be the last parameter
//	public void show(String ... strs,int i){
//		
//	}  //报错意思，String ... strs多参数必须放在最后位置声明
//	
	public void show(int i,String ... strs){
		
	}
}

4.6、方法参数的值传递机制（重点）

/*
 * 关于变量的赋值
 * 
 * 	如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
 * 	如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
 * 
 */

代码演示：

package com.rucoding.d9;

/**
 * @author LiuYiXin
 *
 */
public class ValueTransferTest {
	public static void main(String[] args) {
		//如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
		int m = 10;
		int n = m;
		System.out.println("m = " + m + ", n = " + n);
		n = 20;
		System.out.println("m = " + m + ", n = " + n);
		
		//如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
		Order o1 = new Order();
		o1.orderId = 1024;
		
		Order o2 = o1;	//赋值后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体
		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " + o2.orderId);

		o2.orderId = 1002;
		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " + o2.orderId);

	}
}
//创建类， 设计类的成员
class Order{
	int orderId;
}

4.6.1 基本数据类型的值传递

代码图解：

package com.rucoding.d9;

/**
 * @author LiuYiXin
 *
 */
public class ValueTransferTest1 {
	/*
	 * 方法的形参的传递机制：值传递
	 * 
	 * 1.形参：方法定义时，声明的小括号内的参数
	 *   实参：方法调用时，实际传递给形参的数据
	 * 
	 * 2.值传递机制：
	 *  如果参数是基本数据类型，此时实参赋值给形参的是实参真是存储的数据值。
	 */
	public static void main(String[] args) {
		int m = 10;
		int n = 20;
		
		System.out.println("m = " + m + ", n = " + n);
		//交换两个值的操作
//		int temp = m;
//		m = n;
//		n = temp;
		
		ValueTransferTest1 v1 = new ValueTransferTest1();
		v1.swap(m, n);//可以画一下内存结构图
		System.out.println("m = " + m + ", n = " + n);
	}
	
	public void swap(int m,int n){
		int temp = m;
		m = n;
		n = temp;
	}
	
}

内存结构图解：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LB9tU2JX-1634630207437)(object_images/image-20211018103554718.png)]

4.6.2 引用数据类型的值传递

代码图解1：

package com.rucoding.d9;

/**
 * @author LiuYiXin
 *
 */
public class ValueTransferTest2 {
	/*
	 *  如果参数是引用数据类型，此时实参赋值给形参的是实参存储数据的地址值。
	 */
	public static void main(String[] args) {
		//创建类的对象
		Data data = new Data();
		data.m = 10;
		data.n = 20;
		System.out.println("m = " + data.m + ", n = " + data.n);
		
		//交换m和n的值
//		int temp = data.m;
//		data.m = data.n;
//		data.n = temp;
		ValueTransferTest2 v2 = new ValueTransferTest2();
		v2.swap(data);
		System.out.println("m = " + data.m + ", n = " + data.n);
	}
	
	public void swap(Data data){
		int temp = data.m;
		data.m = data.n;
		data.n = temp;
	}
	
}

//创建类， 设计类的成员
class Data{
	int m;
	int n;
}

内存结构图解：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8iEGA8Cx-1634630207438)(object_images/image-20211018104511067.png)]

练习1：

代码演示：

package com.rucoding.d9;

/**
 * @author LiuYiXin
 *
 */
public class ValueTransferTest3{
	public static void main(String args[]){
		ValueTransferTest3 test = new ValueTransferTest3();
		test.first();
	}
	
	public void first(){
		int i=5;
		Value v=new Value();
		v.i=25;
		second(v,i);
		System.out.println(v.i); //20
	}
	
	public void second(Value v,int i){
		i=0;
		v.i=20;
		Value val=new Value();
		v=val;
		System.out.println(v.i+" "+i);  //15 0
		
	}
}
class Value {
	int i= 15;
}

内存结构图解：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MoIiWVkL-1634630207439)(object_images/image-20211018110615731.png)]

面试题：

代码演示：

package com.rucoding.d9;

/**
 * @author LiuYiXin
 *
 */
public class MethodTest {
	//面试题
	public static void main(String[] args) {
		int a = 10;
		int b = 10;
		method(a,b);//需要在method方法被调用后， 仅打印出a=100,b=200
		System.out.println("a=" + a);
		System.out.println("b=" + b);
	}
	//
	public static void method(int a,int b){
		a = a * 10;
		b = b * 20;
		System.out.println("a=" + a);
		System.out.println("b=" + b);
		System.exit(0); //终止当前正在运行的 Java 虚拟机
	}
}

练习2：

代码演示：

package com.rucoding.d9;

/**
 * @author LiuYiXin
 *
 */
public class MethodArgsTest {
	/*
	 * 微软：
	 * 定义一个int型的数组：int[] arr = new int[]{12,3,3,34,56,77,432};
	 * 让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组。 
	 */
	public static void main(String[] args) {
		int[] arr = new int[]{12,3,3,34,56,77,432};
		//方式一
//		int temp = arr[0]; //固定住 首元素
//		for(int i = 0;i < arr.length;i++){
//			arr[i] = arr[i] / temp;
//		}
		
		
		//方式二 倒着遍历数据 推荐这种写法
		for(int i = arr.length - 1;i >= 0;i--){
			arr[i] = arr[i] / arr[0];
		}
		
		for(int i =0 ;i < arr.length;i++){
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}
}

练习3：

代码演示：

package com.rucoding.d9;

/**
 * @author LiuYiXin
 *
 */
public class ArrayPrintResult {
	public static void main(String[] args) {
		int[] arr = new int[]{1,2,4};
		//传进去的是一个Object的对象
		System.out.println(arr); //[I@15db9742
		
		char[] charArr = new char[]{'a','c','d'};
		//传进去的是一个数组，里面遍历数据了
		System.out.println(charArr);
	}
}

练习4：

/*
 * 练习4：将对象作为参数传递给方法
 * (1)定义一个Circle类，包含一个double型的radius属性代表圆的半径，一个findArea()方法返回圆的面积。
 * 
 * (2)定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：
 * public void printAreas(Circle c,int time)
 * 在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。
 * 例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。
 * 
 * (3)在main方法中调用printAreas()方法，调用完毕后输出当前半径值。
 *
 */

代码演示：

设计Circle类：

package com.rucoding.d9;

/**
 * @author LiuYiXin
 *
 */
public class Circle {
	//定义类， 并设计类的成员
	double radius;
	
	//
	public double findArea(){
		return Math.PI * radius * radius;
	}
}

测试类：

package com.rucoding.d9;

/**
 * @author LiuYiXin
 *
 */
public class PassObject {
	
	
	public static void main(String[] args) {
		//创建对象
		PassObject passObject = new PassObject();
		Circle c = new Circle();
		passObject.printAreas(c, 5);
		System.out.println("now Radius is：" + c.radius);
	}
	
	public void printAreas(Circle c,int time){
		System.out.println("Radius\t\tArea");
		for(int i = 1;i <= time;i++){
			c.radius = i;
			System.out.println(c.radius + "\t\t" + c.findArea());
		}
		c.radius = time + 1;
		
	}
	
}

4.7、递归方法

/*
 * 递归方法的使用(了解)
 * 1.递归方法：一个方法体内调用它自身。
 * 2.方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
 * 
 * 3.递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
 *   向下拆解的思维
 */

代码演示：

package com.rucoding.d9;

/**
 * @author LiuYiXin
 *
 */
public class RecursionTest {
	public static void main(String[] args) {
		//递归方法
		//求1~100的总和
		int sum = 0;
		for(int i = 1;i <= 100;i++){
			sum += i;
		}
		System.out.println(sum);
		//
		RecursionTest recursionTest = new RecursionTest();
		int sumRecursion = recursionTest.getSum(100);
		System.out.println(sumRecursion);
		
		int sum2 = recursionTest.getSum2(6);
		System.out.println(sum2);
	}
	
	//递归方法求和 1 - n
	public int getSum(int n){ 
		//递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
		if(n == 1){
			return 1;
		}
		return n + getSum(n - 1);
	}
	
	//阶乘也是如此，n!  加号+改为乘积号*
	public int getSum2(int n){ 
		//递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
		if(n == 1){
			return 1;
		}
		return n * getSum2(n - 1);
	}
}

练习1：

代码演示：

package com.rucoding.d9;

/**
 * @author LiuYiXin
 *
 */
public class RecurisonDemo {
	//例:已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
	//其中n是大于0的整数，求f(10)的值。
	public static void main(String[] args) {
		RecurisonDemo r = new RecurisonDemo();
		int f = r.f(10);
		System.out.println(f);
	}
	
	public int f(int n){
		if(n == 0){
			return 1;
		}else if(n == 1){
			return 4;
		}else{
			//f(n+2)=2*f(n+1) + f(n) ,向下拆解的方式，
//			return f(n+2)=2*f(n+1) + f(n); //按照此写法，n只会一直增加， 在栈stack一直声明此形参，导致栈溢出
			return 2*f(n - 1) + f(n - 2); // 从f(n+2) ==》f(n) ,只需 n = n-2即可 ，f(n) = 2*f(n-1) + f(n-2)
		}
	}
	
}

练习2：

斐波那契数列:
/*
 * 输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值
 * 1  1  2  3  5  8  13  21  34  55
 * 规律：一个数等于前两个数之和
 * 要求：计算斐波那契数列(Fibonacci)的第n个值，并将整个数列打印出来
 * 
 */

代码演示;

package com.rucoding.d9;

/**
 * @author LiuYiXin
 *
 */
/*
 * 输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值
 * 1  1  2  3  5  8  13  21  34  55
 * 规律：一个数等于前两个数之和
 * 要求：计算斐波那契数列(Fibonacci)的第n个值，并将整个数列打印出来
 * 
 */
public class Recursion2 {

	public static void main(String[] args) {
		Recursion2 r2 = new Recursion2();
		for(int i = 1;i <= 10;i++){ //并将整个斐波那契数列打印出来
			System.out.print(r2.f(i) + " ");
		}
		
	
	}
	
	//输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值
	public int f(int n){
		if(n == 1 || n == 2){
			return 1;
		}else{
			return f(n-1) + f(n-2);
		}
	}
	
}

小结

方法 (提到方法讨论的要点)：
①.方法的重载
②.可变个数的形参
③.值传递
④.递归

5、面向对象特征之一：封装与隐藏

1)、封装性的引入与体现
	现实当中，我们使用洗衣机，我们只需要选择对应功能， 启动开关即可，有必要关注内部的结构构造? 有必要碰电动机嘛？
2)、我们的程序设计追求“高内聚，低耦合”
	高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
	低耦合：仅对外暴露少量的方法用于使用。	
3)、隐藏对象内部的复杂性，只对外公开简单的接口。
	便于外界调用，从而提高系统的可扩展性、可维护性。
	通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
==============================================================================================
/*
 * 面向对象的特征一:封装与隐藏
 * 一、问题的引入：
 *    当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对‘对象的属性’进行赋值。这里，赋值操作要受到
 *    属性的数据类型和存储范围的制约。但除此之外，没有其他制约条件。但是，实际问题中，我们往往需要给属性赋值
 *    加入额外限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行条件的添加。比如说，下面代码的setLegs
 *    同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的(private)
 *    --》此时，针对于属性就体现了封装性。
 *    
 * 二、封装性的体现：
 *    我们将类的属性私有化(private),同时,提供公共的(public)方法来获取(getXxx)和设置(setXxx)
 *    
 *    拓展：封装性的体现：① 如上 ② 单例模式 ③ 不对外暴露的私有方法
 *
 */

代码演示：

package com.rucoding.day10;

/**
 * @author LiuYiXin
 *
 */
public class AnimalTest {
	//封装性的体现
	/*
	 * 类的属性私有化，并同时提供对应的公共方法，get方法和set方法
	 * 单例模式（后面会讲到的）
	 * 不对外暴露的私有方法
	 */
	public static void main(String[] args) {
		//创建对象
		Animal animal = new Animal();
		animal.name = "佩奇";
		animal.age = 6;
//		animal.legs = 2; //1、假如此时输入的legs数为负数，咋办，是否可以加个判断
		animal.setLegs(2); //此时是通过方法赋值legs属性
//		animal.legs;// 上面提供了方法赋值， 对象.属性 方式 The field Animal.legs is not visible
		animal.show();
		System.out.println(animal.getLegs());
		System.out.println(animal.getAge());
	}	
}

//第一步， 创建类， 设计类的成员
class Animal{
	String name;
	int age;
	private int legs; //设置私有化
	
	//加个判断方法，赋值操作
	public void setLegs(int i){
		if(i >= 0 && i % 2 == 0){
			legs = i;
		}else{
			legs = 0;
		}
	}
	
	//属性legs设置为私有化， 对外得提供获取方法
	public int getLegs(){
		return legs;
	}
	
	//设置age属性私有化后， 无法再通过 “对象.属性”方式赋值操作， 提供对象的set方法
	public void setAge(int a){
		age = a;
	}
	//提供对应的set赋值方法后 ，得提供对应的获取属性值得方法get()
	public int getAge(){
		return age;
	}
	
	public void eat(){
		System.out.println("eating ....");
	}
	
	public void show(){
		System.out.println("name=" + name + " age=" + age + " legs=" + legs);
	}
	
}

5.1、四种权限修饰符的理解与测试

Java的权限修饰符有private、缺省、protected、public 置于类的成员定义前，用来限定对象对该类成员的访问权限。

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	Yes
缺省	Yes	Yes
protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes

代码验证：

package com.rucoding.day10;

/**
 * @author LiuYiXin
 *
 */
public class Order {
	//类的成员属性
	private int orderPrivate;// 设置私有化private的属性
	int orderDefault; //设置缺省的属性
	public int orderPublic; //设置公共public属性
	
	//类的成员方法
	private void methodPrivate(){
		orderPrivate = 1;
		orderDefault = 2;
		orderPublic = 3;
	}
	
	void methodDefault(){
		orderPrivate = 1;
		orderDefault = 2;
		orderPublic = 3;
	}
	
	public void methodPublic(){
		orderPrivate = 1;
		orderDefault = 2;
		orderPublic = 3;
	}
	
}

同一个包package下的OrderTest类：

package com.rucoding.day10;

/**
 * @author LiuYiXin
 *
 */
public class OrderTest {
	public static void main(String[] args) {
		Order order = new Order();
		
		//出了 Order 类之后，私有的结构就不可调用了
//		order.orderPrivate = 1;//The field Order.orderPrivate is not visible
		order.orderDefault = 2;  //同一个包下可以调用
		order.orderPublic = 3;
		
		order.methodDefault();//同一个包下可以调用
		order.methodPublic();
		//出了 Order 类之后，私有的结构就不可调用了
//		order.methodPrivate();
	}
}

不同包package下的OrderTest类：

package com.rucoding.day10_1;

import com.rucoding.day10.Order;

/**
 * @author LiuYiXin
 *
 */
public class OrderTest {
	public static void main(String[] args) {
		//不同包下的测试
		Order order = new Order();
		
		//不同包下，私有的、缺省的就不能被调用了
//		order.orderPrivate = 1;
//		order.orderDefault = 2;
		order.orderPublic = 3;
		
		order.methodPublic();
		//不同包下，私有的、缺省的就不能被调用了
//		order.methodPrivate();
//		order.methodDefault();
	}
}

小结

1)、protected权限修饰符，后面会讲到，这里先不提及。
2)、对于class类的权限修饰符只可以是public和default缺省。
3)、public类可以在任何地方被访问。
4)、default类只可以是在同一个包下的类访问。

5.2、封装性的练习

/*
 * 1).创建程序,在其中定义两个类：Person 和 PersonTest 类。
 * 定义如下：用 setAge()设置人的合法年龄(0~130)，用 getAge()返回人的年龄。
 * 
 */

代码演示：

Person类：

package com.rucoding.day10;

/**
 * @author LiuYiXin
 *
 */
public class Person {
	//创建类，设计类的成员
	private int age;
	
	//对外提供对应的set和get方法
	public void setAge(int i){
		//可判断，age属性的非法性质
		if(i < 0 || i > 130){
			System.out.println("传入的数据非法");
			return;//结束方法
		}else{
			age = i;
		}
	}
	public int getAge(){
		return age;
	}
}

PersonTest类：

package com.rucoding.day10;

/**
 * @author LiuYiXin
 *
 */
public class PersonTest {
	public static void main(String[] args) {
		//创建对象
		Person person = new Person();
//		person.age = 1;//The field Person.age is not visible
		person.setAge(180);
		System.out.println(person.getAge());
	}
	
}

6、构造器（构造方法）

6.1、构造器的理解

类的构造器使用:
一、类的构造器的作用:
1)、new创建对象
2)、初始化对象的属性

二、说明
 * 1).如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器。
 * 2).定义构造器的格式:
 * 			权限修饰符  类名(形参列表) { }
 * 3).一个类中定义的多个构造器，彼此构成重载。
 * 4).一旦显式的定义了类的构造器之后，系统不再提供默认的空参构造器。
 * 5).一个类中，至少会有一个构造器		
 */

代码演示：

package com.rucoding.day10_1;

/**
 * @author LiuYiXin
 *
 */
public class PersonTest {
	public static void main(String[] args) {
		//创建对象 new + 构造器
		Person person = new Person();//Person()这里就是构造器
		person.eat();
		
		Person person2 = new Person("Tom");
		System.out.println(person2.name);
	}
}

//创建类，设计类的成员
class Person{
	//属性
	String name;
	int age;
	
	//构造器
	public Person(){
		System.out.println("我是无参构造器");
	}
	
	public Person(String n){
		name = n;
	}
	
	public Person(String n,int a){
		name = n;
		age = a;
	}
	
	public void eat(){
		System.out.println("eating...");
	}
	
}

练习：

/*
 * 编写两个类，TriAngle 和 TriAngleTest，
 * 其中 TriAngle 类中声明私有的底边长 base 和高 height，同时声明公共方法访问私有变量。
 * 此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。
 * 
 */

TriAngle类：

package com.rucoding.day10_1;

/**
 * @author LiuYiXin
 *
 */
public class TriAngle {
	//类的属性
	private double base; //底边长
	private double height;//高
	
	
	//提供对应的构造器，对象属性初始化
	public TriAngle(){
		
	}
	
	//有参构造器，初始化
	public TriAngle(double b,double h){
		base = b;
		height = h;
	}
	
	
	//提供对应对外得get和set方法
	public void setBase(double b){
		base = b;
	}
	
	public double getBase(){
		return base;
	}
	
	public void setHeight(double h){
		height = h;
	}
	
	public double getHeight(){
		return height;
	}
	
}

TriAngleTest类：

package com.rucoding.day10_1;

/**
 * @author LiuYiXin
 *
 */
public class TriAngleTest {
	public static void main(String[] args) {
		//创建对象
		TriAngle triAngle = new TriAngle();
		triAngle.setBase(3.2);
		triAngle.setHeight(5.0);
		System.out.println("底边长base：" + triAngle.getBase() + " 高为：" + triAngle.getHeight());
		//构造器
		TriAngle triAngle2 = new TriAngle(3.2,5.0);
		double area = triAngle2.getBase() * triAngle2.getHeight() / 2;
		System.out.println("三角形的面积为：" + area);
	}
}

6.2、总结属性赋值的过程

代码演示：

package com.rucoding.day10_1;

/**
 * @author LiuYiXin
 *
 */
public class UserTest {
	/*
	 * 总结:属性赋值的先后顺序
	 * 
	 * ① 默认初始化值
	 * ② 显式初始化
	 * ③ 构造器中赋值
	 * ④ 通过"对象.方法" 或 “对象.属性”的方式，赋值
	 * 
	 * 以上操作的先后顺序:① - ② - ③ - ④
	 * 
	 */
	public static void main(String[] args) {
		User user = new User();
		System.out.println(user.age);
		
		User user2 = new User(2);
		user2.setAge(3);
		System.out.println(user2.age);
	}
	
}
//创建类， 设计类的属性
class User{
	String name;
	int age;
	
	public User(){
		
	}
	
	public User(int a){
		age = a;
	}
	
	public void setAge(int a){
		age = a;
	}
}

6.3、JavaBean的使用

JavaBean 是一种Java语言写成的可重用组件
所谓的javaBean, 是符合如下标准的Java类:
> 类是公共的
> 有一个无参的公共构造器
> 有属性，，且有对应的set和get方法

代码演示：

package com.rucoding.day10_1;

/**
 * @author LiuYiXin
 *
 */
public class Customer { //类是公共的
	/*
	 * JavaBean 是一种 Java 语言写成的可重用组件。
	 * 所谓 javaBean，是指符合如下标准的 Java 类：
	 * 		> 类是公共的
	 * 		> 有一个无参的公共的构造器
	 * 		> 有属性，且有对应的 get、set 方法
	 * 
	 */
	
	//有一个无参的公共的构造器
	public Customer(){}
	
	//类的成员
	private int id; //有属性
	private String name;
	
	//对应的set和get方法 
	public void setId(int i){
		id = i;
	}
	public int getId(){
		return id;
	}
	
	public void setName(String n){ //且有对应的 get、set 方法
		name = n;
	}
	
	public String getName(){
		return name;
	}
}

6.4、UML类图

UML统计建模语言简介

图解：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x08O9RPK-1634630207441)(object_images/image-20211019100013194.png)]

1)、+表示public类型，-表示private类型，#表示protected类型
2)、方法的写法:
	方法的类型(+、-)	方法名(参数名: 参数类型): 返回值类型

7、this关键字

/*
 * this 关键字的使用
 * 1.this 用来修饰、调用：属性、方法、构造器
 * 
 * 2.this 修饰属性和方法:
 * 		this 理解为：当前对象,或当前正在创建的对象。
 * 	 
 *  2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性和方法。
 *  	通常情况下，我们都选择省略“this.”。特殊情况下，如果方法的形参和类的属性同名，我们必须显式
 *  	的使用"this.变量"的方式，表明此变量是属性，而非形参。
 * 
 *  2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用正在创建的对象属性和方法。
 *  	但是，通常情况下，我们都选择省略“this.”。特殊情况下，如果构造器的形参和类的属性同名，我们必须显式
 *  	的使用"this.变量"的方式，表明此变量是属性，而非形参。
 *  
 *  3.this 调用构造器
 *  	① 我们可以在类的构造器中，显式的使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
 *  	② 构造器中不能通过"this(形参列表)"的方式调用自己。
 *  	③ 如果一个类中声明了n个构造器，则最多有n -1个构造器中使用了"this(形参列表)"。
 *  	④ "this(形参列表)"必须声明在类的构造器的首行！
 *  	⑤ 在类的一个构造器中，最多只能声明一个"this(形参列表)"。
 */

7.1、this调用属性、方法、构造器

代码演示：

package com.rucoding.day10_2;

/**
 * @author LiuYiXin
 *
 */
public class PersonTest{
	public static void main(String[] args) {
		//创建对象
		Person person = new Person();
		person.setAge(18);
		System.out.println(person.getAge());
		
		person.eat();
		
		Person person2 = new Person("Jack",21);
		System.out.println(person2.getAge());
		
		
	}
}


class Person{
	//创建类， 设计类的成员
	private String name;
	private int age; //属性私有化
	
	//构造器
	public Person(){
		this.eat();//调用方法
		String infoNeedInit = "Person 初始化时，需要考虑如下的 1,2,3,4...(共 40 行代码)";
		System.out.println(infoNeedInit);
	}
	
	//有参构造器
	public Person(String name){
		this();
		this.name = name;
	}
	
	//有参构造器
	public Person(int age){
		this.age = age;
	}
	
	//有参构造器
	public Person(String name,int age){
		this(name);
		this.name = name;
		this.age = age;
	}
	
	
	//对外提供对应的set和get方法
	public void setName(String name){
		//之前我们定义形参的时候，是String n ,此时name = n 赋值操作，但是我们习惯性的变量名是
//		name = name; //假如这样写， 编译器觉得都是这里的形参name，为了区分，我们这时使用关键字this
		this.name = name;//this表示当前对象的，this.name即是当前对象的name属性，后者的name为形参
	}
	
	public String getName(){
		return name;
	}
	
	public void setAge(int age){
		this.age = age;
	}
	
	public int getAge(){
		return age;
	}
	
	
	public void eat(){
		System.out.println("eating。。。");
		this.study(); //this可以调用方法
	}
	public void study(){
		System.out.println("studying。。。");
	}
	
	
}

练习：

添加必要的构造器，综合应用构造器的重载，this关键字。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sTy5U4Pi-1634630207441)(object_images/image-20211019103044836.png)]

代码演示：

Boy类：

package com.rucoding.day10_2;

/**
 * @author LiuYiXin
 *
 */
public class Boy {
	//创建类，设计类的成员
	private String name;
	private int age;
	
	//对外提供对应的set和get方法
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	
	public void setAge(int age){
		this.age = age;
	}
	
	public int getAge(){
		return age;
	}
	
	public Boy(){
		
	}
	
	//初始化构造器
	public Boy(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	
	//marry方法
	public void marry(Girl girl){
		System.out.println("我是" + this.getName() + " 我想娶" + girl.getName());
	}
	
	//shout方法
	public void shout(){
		if(this.age > 22){
			System.out.println("可以考虑结婚");
		}else{
			System.out.println(this.getName() + ",你现在不是法定结婚年龄，再等等?");
		}
	}
	
}

Girl类：

package com.rucoding.day10_2;

/**
 * @author LiuYiXin
 *
 */
public class Girl {
	//创建类， 设计类的成员
	private String name;
	private int age;
	
	//对外提供对应的set和get方法
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	
	public Girl(){
		
	}
	
	//初始化构造器
	public Girl(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	//marry方法
	public void marry(Boy boy){
		System.out.println("我是" + this.name + " 我想嫁给" + boy.getName());
		boy.marry(this);
	}
	//compare方法
	public int compare(Girl girl){
		return this.age - girl.age;
	}
	
}

测试类BoyGirlTest：

package com.rucoding.day10_2;

/**
 * @author LiuYiXin
 *
 */
public class BoyGirlTest {
	public static void main(String[] args) {
		//创建对象
		Boy boy = new Boy("罗密欧",21);
		boy.shout();//通过 对象.方法调用对象的内部结构
		
		Girl girl = new Girl("朱丽叶",18);
		girl.marry(boy);
		
		Girl girl2 = new Girl("祝英台",19);
		int compare = girl.compare(girl2);
		if(compare > 0){
			System.out.println(girl.getName() + "的年龄大");
		}else if(compare < 0){
			System.out.println(girl2.getName() + "的年龄大");
		}else{
			System.out.println("一样大");
		}
		
	}
}

7.2、综合练习1

#练习: 1)、写一个名为 Account 的类模拟账户。该类的属性和方法如下所示。
该类包括的属性：
账号 id，余额 balance，年利率 annualInterestRate；
包含的方法：访问器方法（getter 和 setter方法），取款方法 withdraw()，存款方法 deposit()。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0u1VNfQt-1634630207442)(object_images/image-20211019141001674.png)]

**提示：**在提款方法 withdraw 中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。

创建 Customer 类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3Y0Q1gNt-1634630207443)(object_images/image-20211019141139814.png)]

a. 声明三个私有对象属性：firstName、lastName 和 account。
b. 声明一个公有构造器，这个构造器带有两个代表对象属性的参数（f 和 l）
c. 声明两个公有存取器来访问该对象属性，方法 getFirstName 和 getLastName 返回相应的属
性。
d. 声明 setAccount 方法来对 account 属性赋值。
e. 声明 getAccount 方法以获取 account 属性。

3).写一个测试程序。
（1） 创建一个 Customer ，名字叫 Jane Smith, 他有一个账号为 1000，余额为 2000 元，
年利率为 1.23％ 的账户。
（2） 对 Jane Smith 操作。
存入 100 元，再取出 960 元。再取出 2000 元。
打印出 Jane Smith 的基本信息
尚硅谷 Java 基础编程 宋红康
成功存入 ：100.0
成功取出：960.0
余额不足，取款失败
Customer [Smith, Jane] has a account: id is 1000, annualInterestRate is 1.23％, balance is 
1140.0

代码演示：

Account类：

package com.rucoding.day10_3;

/**
 * @author LiuYiXin
 *
 */
public class Account {
	//创建类， 设计类的成员
	private int id; //账户id
	private double balance; //账户余额
	private double annualInterestRate; //年利率
	
	//初始化构造器
	public Account(int id,double balance,double annualInterestRate){
		this.id = id;
		this.balance = balance;
		this.annualInterestRate = annualInterestRate;
	}
	
	//属性的私有化， 需提供对外得set和get方法
	
	public void setId(int id){
		this.id = id;
	}
	public int getId(){
		return id;
	}
	
	public void setBalance(double balance){
		this.balance = balance;
	}
	
	public double getBalance(){
		return balance;
	}
	
	public void setAnnualInterestRate(double annualInterestRate){
		this.annualInterestRate = annualInterestRate;
	}
	public double getAnnualInterestRate(){
		return annualInterestRate;
	}
	
	//取钱的方法
	public void withdraw(double amount){
		//提示在提款方法 withdraw 中，
		//需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。
		if(this.balance < amount){
			System.out.println("余额不足，取款失败");
//			return;//
		}else{   //加了return else{}可以省去 ，判断分支内容还得保留
			this.balance -= amount;
			System.out.println("成功取出：" + amount);
		}
		
		
	}
	
	//存钱的方法
	public void deposit(double amount){
		if(amount > 0){
			balance += amount;
			System.out.println("成功存入 ：" + amount);
		}
		
	}
	
}

Customer类：

package com.rucoding.day10_3;

/**
 * @author LiuYiXin
 *
 */
public class Customer {
	//创建类， 设计类的属性
	private String firstNam;
	private String lastName;
	private Account account;
	
	public Customer(String f,String l){
		this.firstNam = f;
		this.lastName = l;
	}

	/**
	 * @return the account
	 */
	public Account getAccount() {
		return account;
	}

	/**
	 * @param account the account to set
	 */
	public void setAccount(Account account) {
		this.account = account;
	}

	/**
	 * @return the firstNam
	 */
	public String getFirstNam() {
		return firstNam;
	}

	/**
	 * @return the lastName
	 */
	public String getLastName() {
		return lastName;
	}
	
	
	
}

测试类CustomerAccountTest：

package com.rucoding.day10_3;

/**
 * @author LiuYiXin
 *
 */
public class CustomerAccountTest {
	/*
	 * （1） 创建一个 Customer ，名字叫 Jane Smith, 他有一个账号为 1000，余额为 2000 元，
		年利率为 1.23％ 的账户。
		（2） 对 Jane Smith 操作。
		存入 100 元，再取出 960 元。再取出 2000 元。
		打印出 Jane Smith 的基本信息
		
		成功存入 ：100.0
		成功取出：960.0
		余额不足，取款失败
		Customer [Smith, Jane] has a account: id is 1000, annualInterestRate is 1.23％, balance is 
		1140.0
	 */
	
	public static void main(String[] args) {
		Customer customer = new Customer("Jane","Smith");
		
		Account account = new Account(1000,2000,0.123);
		customer.setAccount(account);
		
		customer.getAccount().deposit(100);
		customer.getAccount().withdraw(960);
		customer.getAccount().withdraw(2000);
		
		System.out.println("Customer [" + customer.getLastName() + "," + customer.getFirstNam() + 
				"] has a account：id is " +customer.getAccount().getId() + " ,annualInterestRate is " +
				customer.getAccount().getAnnualInterestRate() * 100 + "%" + ", balance is " + customer.getAccount().getBalance());
		
	}
	
}

综合练习2：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KYFidPvZ-1634630207444)(object_images/image-20211019144037843.png)]

按照如下的 UML 类图，创建相应的类，提供必要的结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zsClfIQk-1634630207445)(object_images/image-20211019144337157.png)]

按照如下的 UML 类图，创建相应的类，提供必要的结构

1)、addCustomer 方法必须依照参数（姓，名）构造一个新的 Customer 对象，然后把
它放到 customer 数组中。还必须把 numberOfCustomer 属性的值加 1。 
getNumOfCustomers 方法返回 numberofCustomers 属性值。

2)、 getCustomer 方法返回与给出的 index 参数相关的客户。
4. 创建 BankTest 类，进行测试

代码演示：

Account类：

package com.rucoding.day10_4;

/**
 * @author LiuYiXin
 *
 */
public class Account {
	//创建类， 定义类的属性
	private double balance;
	
	//构造器初始化
	public Account(double init_balance){
		this.balance = init_balance;
	}
	
	//方法的定义
	public double getBlance(){
		return balance;
	}
	
	//存钱的方法
	public void deposit(double amt){
		if(amt > 0){
			balance += amt;
			System.out.println("成功存入：" + amt );
		}
	}
	
	//取钱的方法
	public void withdraw(double amt){
		if(amt > balance){
			System.out.println("余额不足，取款失败");
			return;
		}
		balance -= amt;
		System.out.println("成功取出：" + amt);
	}
	
}

Customer类：

package com.rucoding.day10_4;

/**
 * @author LiuYiXin
 *
 */
public class Customer {
	//创建类， 设计类的成员属性
	private String firstName;
	private String lastName;
	private Account account;
	
	//构造器初始化
	public Customer(String f,String l){
		this.firstName = f;
		this.lastName = l;
	}

	/**
	 * @return the account
	 */
	public Account getAccount() {
		return account;
	}

	/**
	 * @param account the account to set
	 */
	public void setAccount(Account account) {
		this.account = account;
	}

	/**
	 * @return the firstName
	 */
	public String getFirstName() {
		return firstName;
	}

	/**
	 * @return the lastName
	 */
	public String getLastName() {
		return lastName;
	}
	
	//
	
	
}

Bank类：

package com.rucoding.day10_4;

/**
 * @author LiuYiXin
 *
 */
public class Bank {
	//
	private Customer[] customers; //声明数组变量， 未进行初始化 ,存放客户信息
	private int numberOfCustomer; //记录客户个数
	//
	public Bank(){
		//数组进行初始化
		customers = new Customer[10];
	}
	
	
	/*
	 *  addCustomer 方法必须依照参数（姓，名）构造一个新的 Customer 对象，然后把
	 *	它放到 customer 数组中。还必须把 numberOfCustomer 属性的值加 1。 
	 *	getNumOfCustomers 方法返回 numberofCustomers 属性值。
	 */
	public void addCustomer(String f,String l){
		Customer customer = new Customer(f,l);
//		customers[numberOfCustomer] = customer;
//		numberOfCustomer ++;
		//上面的写法，可以合二为一
		customers[numberOfCustomer++] = customer;
	}
	
	//获取客户数
	public int getNumberOfCustomer(){
		return numberOfCustomer;
	}
	
	//获取指定的客户, 考虑此时的index,避免空指针或者数组越界
	public Customer getCustomer(int index){
//		return customers[index]; //可能空指针或者数组越界 异常
		if(index >= 0 && index < numberOfCustomer){
			return customers[index];
		}
		return null;
	}
	
}

测试类BankTest：

package com.rucoding.day10_4;

/**
 * @author LiuYiXin
 *
 */
public class BankTest {
	public static void main(String[] args) {
		Bank bank = new Bank();
		//银行新增用户
		bank.addCustomer("Jane", "Smith");
		
		//存钱
		bank.getCustomer(0).setAccount(new Account(2000));
		
		bank.getCustomer(0).getAccount().withdraw(500);
		
		double blance = bank.getCustomer(0).getAccount().getBlance();
		
		System.out.println("客户" + bank.getCustomer(0).getFirstName() + "的账户余额为" + blance);
		
		System.out.println("***************************");
		
		bank.addCustomer("佩奇", "小猪");	
		System.out.println("银行客户的个数为: " + bank.getNumberOfCustomer());
		
	}
}

8、关键字：package、import的使用

8.1、关键字-package

/*
 * 一、package 关键字的使用
 * 1.为了更好的实现项目中类的管理，提供包的概念
 * 2.使用 package 声明类或接口所属的包，声明在源文件的首行
 * 3.包，属于标识符，遵循标识符的命名规则、规范"见名知意"
 * 4.每“.”一次,就代表一层文件目录。
 * 
 * 补充:同一个包下，不能命名同名接口或同名类
 *     不同包下，可以命名同名的接口、类。
 *
 */
 
 JDK 中主要的包介绍:
1.java.lang----包含一些 Java 语言的核心类，如 String、Math、Integer、System 和 Thread，提供常用功能
2.java.net----包含执行与网络相关的操作的类和接口。
3.java.io----包含能提供多种输入/输出功能的类。
4.java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
5.java.text----包含了一些 java 格式化相关的类
6.java.sql----包含了 java 进行 JDBC 数据库编程的相关类/接口
7.java.awt----包含了构成抽象窗口工具集（abstractwindowtoolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面				(GUI)。B/S  C/S

8.2、MVC 设计模式

MVC 是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，数据模型层。
这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，
同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-enBnc5pz-1634630207446)(object_images/image-20211019154150207.png)]

MVC模式图解：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZWL8GZko-1634630207447)(object_images/image-20211019155443409.png)]

8.3、关键字-import

/*
 * 二、import关键字的使用
 * import:导入
 * 1.在源文件中显式的使用import结构导入指定包下的类、接口
 * 2.声明在包的声明和类的声明之间
 * 3.如果需要导入多个结构，则并列写出即可
 * 4.可以使用"xxx.*"的方式,表示可以导入xxx包下的所有结构。
 * 5.如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
 * 6.如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。
 * 7.如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
 * 8.import static组合的使用：调用指定类或接口下的静态的属性或方法.
 * 
 */

代码演示：

/*
 * 二、import关键字的使用
 * import:导入
 * 1.在源文件中显式的使用import结构导入指定包下的类、接口
 * 2.声明在包的声明和类的声明之间
 * 3.如果需要导入多个结构，则并列写出即可
 * 4.可以使用"xxx.*"的方式,表示可以导入xxx包下的所有结构。
 * 5.如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
 * 6.如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。
 * 7.如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
 * 8.import static组合的使用：调用指定类或接口下的静态的属性或方法.
 * 
 */
package com.rucoding.day10_4;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;
import com.rucoding.d8.UserTest;

/**
 * @author LiuYiXin
 *
 */
public class PackageImportTest {

	public static void main(String[] args) {
		String info = Arrays.toString(new int[]{1,2,3});
		
		Bank bank = new Bank();
		
		ArrayList list = new ArrayList();
		HashMap map = new HashMap();
		
		Scanner s = null;	
		
		System.out.println("hello");
		
		UserTest us = new UserTest();
		
	}
}