三篇文章彻底搞懂Java面向对象之一_彻底明白java面向对象-优快云博客

写在前面，Java基础系列文章都是作者基于b站尚硅谷的Java基础视频所做的笔记，没有时间的同学可以认真看看，如果有时间的同学，还是建议看看视频，毕竟笔记说到底还是自己的东西，每个人的习惯也是不一样的，所以为了自己，学就对了，加油！
也请各位同学，如果感觉对自己有帮助，可以帮忙给个一键三连，谢谢！

文章目录

1.Java面向对象学习的三条主线
2.Java语言的基本元素：类和对象
- 2.1 类和对象的创建与使用（面向对象思想落地的实现）
- 2.2 内存解析
3.类的成员之一：属性（field）
4.类的成员之二：方法(method)
5.面向对象的特征之一：封装与隐藏
- 5.1 四种权限修饰符
6.类的成员之三：构造器(或构造方法)
7.关键字的使用

面向对象与面向过程的本质区别

作为面向对象的思维来说，当你拿到一个问题时，你分析这个问题不再是第一步先做什么，第二步再做什么，这是面向过程的思维，你应该分析这个问题里面有哪些类和对象，这是第一点，然后再分析这些类和对象应该具有哪些属性和方法。这是第二点。最后分析类和类之间具体有什么关系，这是第三点。

面向对象有一个非常重要的设计思维：合适的方法应该出现在合适的类里面。

1.Java面向对象学习的三条主线

/*
 * 一、Java面向对象学习的三条主线:
 * 1.Java类及类的成员：属性、方法、构造器、代码块、内部类
 * 2.面向对象的三大特征：封装性、继承性、多态性、(如果说有四个，那就可以再增加一个抽象性)
 * 3.其它关键字：this、super、static、final、abstract、interface、package、import
 * 
 * 二、面向过程和面向对象的理解
 * 
 * 举例："人把大象装进冰箱"
 * 1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做
 * ①把冰箱门打开
 * ②抬起大象，塞进冰箱
 * ③把冰箱门关闭
 * 
 * 2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
 * 人{
 * 		打开(冰箱){
 * 			冰箱.开开();
 * 		}
 * 
 * 		抬起(大象){
 * 			大象.进入(冰箱);
 * 		}
 * 
 * 		关闭(冰箱){
 * 			冰箱.闭合();
 * 		}
 * 
 * }
 * 
 * 冰箱{
 * 		打开(){}
 * 		闭合(){}
 * }
 * 
 * 大象{
 * 		进入(冰箱){
 * 		}
 * }
 * 
 * 三、面向对象的两个要素：
 * 类：类是对一类事物的描述，是抽象的、概念上的定义
 * 对象：对象是实际存在的该类事物的每个个体，因而也称为实例(instance)
 * > 面向对象程序设计的重点是类的设计
 * > 设计类，就是设计类的成员
 * 
 */

2.Java语言的基本元素：类和对象

2.1 类和对象的创建与使用（面向对象思想落地的实现）

/*
 * 一、设计类，其实就是设计类的成员
 * 
 * 	属性 = 成员变量 = field = 域、字段
 * 	方法 = 成员方法 = 函数 = method
 * 
 * 	创建类的对象 = 类的实例化 = 实例化类
 * 
 * 二、类和对象的使用（面向对象思想落地的实现）
 * 1.创建类，设计类的成员
 * 2.创建类的对象
 * 3.通过"对象.属性"或"对象.方法"调用对象的结构
 * 
 * 三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static）
 * 		意味着：如果我们修改一个对象的属性a，则不影响另外一个对象的属性a的值
 * 
 * 四、对象的内存解析
 * 	
 */
//测试类
public class PersonTest {
	
	public static void main(String[] args) {
		//2.创建Person类的对象
		Person p1 = new Person();
		
		//调用对象的结构：属性、方法
		//调用属性："对象.属性"
		p1.name = "Tom";
		p1.isMale = true;
		System.out.println(p1.name);
		
		//调用方法："对象.方法"
		p1.eat();
		p1.sleep();
		p1.talk("C语言");
		
		//**************************************
		Person p2 = new Person();
		System.out.println(p2.name); //null
		System.out.println(p2.isMale); //false
		//**************************************
		//将p1变量保存的对象地址值 赋给 p3，导致p1和p3指向了堆空间中的同一个对象实体
		Person p3 = p1;
		System.out.println(p3.name);//Tom
		
		p3.age = 10;
		System.out.println(p1.age); //10
	}
  
}

//1.创建类，设计类的成员
class Person{
	
	//属性
	String name;
	int age = 1;
	boolean isMale;
	
	//方法
	public void eat() {
		System.out.println("人可以吃饭");
	}
	
	public void sleep() {
		System.out.println("人可以睡觉");
	}
	
	public void talk(String language) {
		System.out.println("人可以说话,使用的是：" + language);
	}
	
}

2.2 内存解析

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

案例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= new Person();
p1.name = "胡利民";
p1.age = 23;
Person p2 = new Person();
p2.age = 10;

3.类的成员之一：属性（field）

3.1 语法格式

/*
语法格式：
修饰符  数据类型  属性名 = 初始化值;

1.说明1: 修饰符
1.1常用的权限修饰符有：private、缺省、protected、public
1.2其他修饰符：static、final (暂不考虑)
2.说明2：数据类型
2.1任何基本数据类型(如int、Boolean) 或 任何引用数据类型。
3.说明3：属性名
3.1属于标识符，符合命名规则和规范即可。
*/

3.2 变量的分类：成员变量与局部变量

在方法体外，类体内声明的变量称为成员变量。
在方法体内部声明的变量称为局部变量。

3.3 成员变量（属性）和局部变量的区别？

	成员变量	局部变量
声明的位置	直接声明在类中	方法形参或内部、代码块内、构造器内等
修饰符	private、public、static、final等	`不能用权限修饰符修饰，可以用final修饰`
初始化值	`有默认初始化值`	没有默认初始化值，`必须显式赋值`，方可使用
内存加载位置	堆空间或静态域内	栈空间

/*
 * 类中属性的使用
 * 
 * 属性（成员变量） VS 局部变量
 * 1.相同点：
 * 		1.1 定义变量的格式：数据类型 变量名 = 变量值
 * 		1.2 先声明，后使用
 * 		1.3 变量都有其对应的作用域
 * 		1.4 都有生命周期
 * 
 * 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
 * 
 * 		局部变量：没有默认初始化值
 * 			意味着我们在调用使用局部变量之前，一定要显式赋值
 * 			特别的：形参在调用时，我们再赋值即可。例：47行，59行
 * 		
 * 		2.4在内存中加载的位置
 * 		属性(成员变量)：加载到堆空间中(非static)
 * 		局部变量：加载到栈空间
 */
public class UserTest {
	
	public static void main(String[] args) {
		User u1 = new User();
		System.out.println(u1.name);
		System.out.println(u1.age);
		System.out.println(u1.isMale);
		u1.eat();
    u1.talk("英语");
	}

}

class User{
	
	//属性（或成员变量）
	String name;
	public int age;
	boolean isMale;
	
	public void talk(String language) { //language:形参,也是局部变量
		System.out.println("我们使用" + language + "进行交流");
	}
	
	public void eat() {
		String food = "烙饼"; //局部变量
		System.out.println("北方人喜欢吃：" + food);
	}
	
}

练习

要求：

编写教师类和学生类，并通过测试类创建对象进行测试
Student类
属性:
name:String  age:int  major:String  interests:String
方法:say() 返回学生的个人信息
  
Teacher类
属性:
name:String  age:int  teachAge:int  course:String
方法:say() 输出教师的个人信息

代码测试：

public class School {
	public static void main(String[] args) {
		Student stu = new Student();
        stu.name = "小明";
        stu.age = 20;
		
		Teacher tea = new Teacher();
		tea.name = "王老师";
        tea.age = 25;
        
        tea.say(stu.name,stu.age);
        stu.say(tea.name, tea.age);
	}	
}

class Student{
	String name;
	int age;
	String major;
	String interests;
	
	void say(String name, int age){
		System.out.println("这个学生是："+name+"年龄是："+age);	}
}

class Teacher{
	String name;
	int age;
	String teachAge;
	String course;
	
	void say(String name, int age){
		System.out.println("这个老师是："+name+"年龄是："+age);
	}
}

3.4 成员变量与局部变量的内存位置

//人类
class Person{
	//1.属性 
	String name;  //姓名 
	int age = 1;  //年龄 
	boolean isMale;  //是否是男性

	public void show(String nation){ //nation:局部变量

	String color; //color:局部变量

	color = "yellow"; 
	}
  
}

//测试类
class PersonTest {
	public static void main(String[] args) {
		Person p = new Person();
		p.show("USA");
	}
}

4.类的成员之二：方法(method)

/*
 * 类中方法的声明和使用
 * 
 * 方法：描述类应该具有的功能。
 * 比如：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关于权限修饰符：
 * 			Java规定的四种权限修饰符：private、public、缺省(default)、protected
 * 
 * 		3.2返回值类型：有返回值  VS  没有返回值
 * 			3.2.1如果方法有返回值，则必须在方法声明时，指定返回值的类型。
 * 					同时，方法中需要使用return关键字来返回指定类型的变量或常量	
 * 				 如果方法没有返回值，则方法声明时，使用void来表示。
 * 					通常，没有返回值的方法，就不需要使用return。
 * 					但是如果需要使用的话，只能用"return;"，表示结束此方法的意思
 * 		
 * 		3.3方法名：属于标识符，遵循标识符的规则和规范，"见名知意"
 * 
 * 		3.4形参列表：方法可以声明0个，1个，或者多个形参
 * 			3.4.1 格式：数据类型1 形参1，数据类型2 形参2，...
 * 			
 * 		3.5方法体：方法功能的体现
 * 
 * 	4.return关键字的使用：
 * 			1.使用范围：使用在方法体中
 * 			2.作用：①结束方法
 * 					   ②针对于有返回值类型的方法，使用"return 数据"方法返回所需要的数据
 * 			3.注意点：return关键字后面不可以再声明执行语句
 * 	
 *  5.方法中：可以调用当前类的属性或方法，但是不可以定义其他方法
 *  	特殊的：方法A中又调用了方法A：递归方法  	       
 */
public class CustomerTest {
	
	public static void main(String[] args) {
		Customer cust = new Customer();
		cust.eat();
		cust.sleep(8);
	}

}

class Customer{
	
	//属性
	String name;
	int age;
	boolean isMale;
	
	//方法
	public void eat() {
		System.out.println("客户吃饭");
	}
	
	public void sleep(int hour) {
		System.out.println("休息了" + hour + "个小时");
		eat();
	}
	
	public String getName() {
		if(age > 18) {
			return name;
		}else {
			return "Tom";
		}
		
	}
	
	public String getNation(String nation) {
		String info = "我的国籍是" + nation;
		return info;
	}
	
}

练习

public class Person {
	
	String name;
	int age;
	/**
	 * sex:1 表明是男性
	 * sex: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;
		
	}

}

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

练习2

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

//测试类
public class CircleTest {
	
	public static void main(String[] args) {
		Circle c1 = new Circle();
		c1.radius = 2;
		c1.findArea();
	}
	
}

//圆
class Circle{
	
	//属性
	double radius;
	
	//求圆的面积
	//方式一：
//	public double findArea() {
//		double area = Math.PI * radius * radius;
//		return area;
//	}
	
	//方式二：
	public void findArea() {
		double area = Math.PI * radius * radius;
		System.out.println("面积为 " + area);
	}
	
}

练习3

/*
 * 3.1 编写程序，声明一个method方法，在方法中打印一个10*8 的*型矩形， 在main方法中调用该方法。
 * 
 * 3.2 修改上一个程序，在method方法中，除打印一个10*8的*型矩形外，再
 * 计算该矩形的面积 ，并将其作为方法返回值 。在main方法中调用该方法 ， 接收返回的面积值并打印。
 * 
 * 3.3 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个 m*n的*型矩形，
 * 并计算该矩形的面积， 将其作为方法返回值。在main方法 中调用该方法，接收返回的面积值并打印。
 */
public class Exer3Test {
	
	public static void main(String[] args) {
		Exer3Test e = new Exer3Test();
		
		//3.1测试
		e.method();
		
		//3.2测试
		int erea = e.method();
		System.out.println("面积为：" + erea);
	}
	
	//3.1
//	public void method() {
//		for(int i = 0;i < 10;i++) {
//			for(int j = 0;j < 8;j ++) {
//				System.out.print("* ");
//			}
//			System.out.println();
//		}
//	}
	
	//3.2
	public int method() {
		for(int i = 0;i < 10;i++) {
			for(int j = 0;j < 8;j ++) {
				System.out.print("* ");
			}
			System.out.println();
		}
		
		return 10 * 8;
	}

}

练习4

/*
 * 定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩 score(int)。 
 * 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。 
 * 
 * 问题一：打印出3年级(state值为3）的学生信息。 
 * 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
 * 
 * 1) 生成随机数：Math.random()，返回值类型double;
 * 随机数[a,b]公式：( Math.random() * (b - a + 1) + a)
 * 
 * 2) 四舍五入取整：Math.round(double d)，返回值类型long
 */
public class StudentTest {
	public static void main(String[] args) {
		//声明一个Student类型的数组
		Student[] stu = new Student[20];
		
		for(int i = 0;i <stu.length;i++){
			//给数组元素赋值
			stu[i] = new Student();
			//给Student对象的属性赋值
			stu[i].number = i + 1;
			//年级:[1,6]
      //Math.random()计算公式：[a,b] = (int)(Math.random() * (b - a + 1) + a)
			stu[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
			//成绩:[0,100]
			stu[i].score = (int)(Math.random() * (100 - 0 + 1));
		}
		
		//遍历学生数组
		for(int i = 0;i < stu.length;i++){
//			System.out.println(stu[i].number + "," + stu[i].state 
//				+  "," + stu[i].score);
			System.out.println(stu[i].info());
		}
		System.out.println("*********以下是问题1*********");
		
		//问题一：打印3年级(state值为3）的学生信息。
		for(int i = 0;i < stu.length;i++){
			if(stu[i].state == 3){
				System.out.println(stu[i].info());
			}
		}
		System.out.println("********以下是问题2**********");
		
		//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息。
		for(int i = 0;i < stu.length - 1;i++){
			for(int j = 0;j <stu.length - 1 - i;j++){
				if(stu[j].score >stu[j+1].score){
					//如果需要换序，交换的是数组的元素，Student对象！！！
					Student temp = stu[j];
					stu[j] = stu[j+1];
					stu[j+1] = temp;
				}
			}
		}
		
		//遍历学生数组
		for(int i = 0;i < stu.length;i++){
			System.out.println(stu[i].info());
		}
		
	}
}
class Student{
	int number;	//学号
	int state;	//年级
	int score;	//成绩
	
	//显示学生信息的方法
	public String info(){
		return "学号:" + number + ",年级:" + state + ",成绩:" + score;
	}
}

练习4优化

/*
 * 定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩 score(int)。 
 * 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。 
 * 
 * 问题一：打印出3年级(state值为3）的学生信息。 
 * 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
 * 
 * 1) 生成随机数：Math.random()，返回值类型double;
 * 随机数[a,b]公式：( Math.random() * (b - a + 1) + a)
 * 
 * 2) 四舍五入取整：Math.round(double d)，返回值类型long
 */
public class StudentTest2 {
	public static void main(String[] args) {
		//声明一个Student类型的数组
		Student2[] stu = new Student2[20];
		
		for(int i = 0;i <stu.length;i++){
			//给数组元素赋值
			stu[i] = new Student2();
			//给Student的对象的属性赋值
			stu[i].number = i + 1;
			//年级:[1,6]
			stu[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
			//成绩:[0,100]
			stu[i].score = (int)(Math.random() * (100 - 0 + 1));
		}
		
		StudentTest2 test = new StudentTest2();
		
		//遍历学生数组
		test.print(stu);
		
		System.out.println("*********以下是问题1*********");
		
		//问题一：打印出3年级(state值为3）的学生信息。
		test.searchState(stu, 3);
		System.out.println("********以下是问题2**********");
		
		//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息。
		test.sort(stu);
		
		//遍历学生数组
		for(int i = 0;i < stu.length;i++){
			System.out.println(stu[i].info());
		}
	}
	
	public void print(Student2[] stu){
		for(int i = 0;i < stu.length;i++){	
			System.out.println(stu[i].info());
		}
	}
	
	public void searchState(Student2[] stu,int state){
		for(int i = 0;i < stu.length;i++){
			if(stu[i].state == state){
				System.out.println(stu[i].info());
			}
		}
	}
	
	public void sort(Student2[] stu){
		for(int i = 0;i < stu.length - 1;i++){
			for(int j = 0;j <stu.length - 1 - i;j++){
				if(stu[j].score >stu[j+1].score){
					//如果需要换序，交换的是数组的元素，Student对象！！！
					Student2 temp = stu[j];
					stu[j] = stu[j+1];
					stu[j+1] = temp;
				}
			}
		}
	}
}
class Student2{
	int number;	//学号
	int state;	//年级
	int score;	//成绩
	
	//显示学生信息的方法
	public String info(){
		return "学号:" + number + ",年级:" + state + ",成绩:" + score;
	}
}

4.1 对象数组的内存解析

// 引用类型的变量，只能存储两类值：null或地址值（含变量类型）
Student[] stus= new Student[5];
stus[0] = new Student();
sysout(stus[0].state);//1
sysout(stus[1]);//null
sysout(stus[1].number);//异常
stus[1] = new Student();
sysout(stus[1].number);//0

class Student{
  int number;//学号
  int state = 1;//年级
  int score;//成绩
}

4.2 匿名对象的使用

/*
 * 一、理解"万事万物皆对象"
 * 1.在Java语言范畴当中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
 * 		>Scanner,String等
 * 		>文件：File
 * 		>网络资源：URL
 * 2.涉及到Java语言与前端HTML、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象
 * 
 * 二、内存解析的说明
 * 1.引用类型的变量，只能存储两类值：null 或 地址值（包含变量的类型）
 * 
 * 三、匿名对象的使用
 * 1.理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
 * 2.特征：匿名对象只能调用一次
 * 3.使用：
 */
public class InstanceTest {
	
	public static void main(String[] args) {
		Phone p = new Phone();
		System.out.println(p);
		
		//匿名对象
//		new Phone().sendEmail();
//		new Phone().playGame();
		
		new Phone().price = 1999;
		new Phone().showPrice(); //0.0
		
		//*************************************
		PhoneMall mall = new PhoneMall();
		//mall.show(p);
		//匿名对象的使用
		mall.show(new Phone());
	}

}

class PhoneMall{
	
	public void show(Phone phone) {
		phone.sendEmail();
		phone.playGame();
	}
	
}

class Phone {
	double price; //价格
	
	public void sendEmail() {
		System.out.println("发送邮件");
	}
	
	public void playGame() {
		System.out.println("玩游戏");
	}
	
	public void showPrice() {
		System.out.println("手机价格为：" + price);
	}
}

4.3 自定义数组的工具类

/*
 * 自定义数组的工具类
 */
public class ArrayUtil {
	
	//求数组的最大值
	public int getMax(int[] arr) {
		int maxValue = arr[0]; //如果随机数是负数，就不能用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]; //如果随机数是负数，就不能用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) {
		return getSum(arr) / arr.length;
	}
	
	//反转数组
	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 arr1;
	}
	
	//数组排序
	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;
							
							//错误的：
							//swap(arr[j],arr[j+1]);
							//正确的：
							swap(arr,j,j + 1);
						}
					}
				}
	}
	
	//错误的：交换数组中指定两个位置元素的值
//	public void swap(int i,int j) {
//		int temp = i;
//		i = j;
//		j = temp;
//	}
	
	//正确的：交换数组中指定两个位置元素的值
	public void swap(int[] arr,int i,int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
	
	//遍历数组
	public void print(int[] arr) {
		for(int i = 0;i < arr.length;i++) {
			System.out.print(arr[i] + "\t");
		}
	}
	
	//查找数组中指定的元素
	public int getIndex(int[] arr,int dest) {
	//线性查找：
		boolean isFlag = true;
		for(int i = 0;i < arr.length;i++) {
			if( dest == arr[i] ) {
				return i;
			}
		}
		return -1; //返回一个负数，表示没有找到		
	}
  
}

测试类

public class ArrayUtilTest {
	
	public static void main(String[] args) {
		
		ArrayUtil util = new ArrayUtil();
		int[] arr = new int[] {32,34,32,5,3,54,654,-98,0,-53,5};
		int max = util.getMax(arr);
		System.out.println("最大值为：" + max);
		
		util.print(arr);
		
		util.sort(arr);
		
		System.out.println();
		System.out.println("排序后:");
		
		util.print(arr);		
	}

}

4.4 方法的重载

/*
 * 方法的重载（overload）
 * 
 * 1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的 参数个数 或者 参数类型不同即可
 * 
 * 		"两同一不同":同一个类、相同方法名
 * 					 参数列表不同：参数个数不同，参数类型不同
 * 
 * 2.举例：
 * 		Arrays类中重载的sort() / binarySearch()
 * 
 * 3.判断是否是重载
 * 		跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
 * 
 * 4.在通过对象调用方法时，如何确定某一个指定的方法：
 * 			方法名 ---> 参数列表
 */
public class OverLoadTest {
	
	public static void main(String[] args) {
		OverLoadTest test = new OverLoadTest();
		test.getSum(1, 2);
	}
	
	//如下的4个方法构成了重载
	public void getSum(int i,int j) {
		System.out.println("1");
	}
	
	public void getSum(double d1,double d2) {
		System.out.println("2");
	}
	
	public void getSum(String s,int i) {
		System.out.println("3");
	}
	
	public void getSum(int i,String s) {
		System.out.println("4");
	}
	
//如下三个方法不构成重载  
//	public int getSum(int i,int j) {
//		return 0;
//	}
	
//	public void getSum(int m,int n) {
//		
//	}
	
//	private void getSum(int i,int j) {
//		
//	}

}

举例

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

练习

/*
 * 1.编写程序，定义三个重载方法并调用。方法名为mOL。
 * 	三个方法分别接收一个int参数、两个int参数、一个字符串参数。
 * 分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
 * 在主类的 main ()方法中分别用参数区别调用三个方法。
 
 * 2.定义三个重载方法max()，
 * 第一个方法求两个int值中的最大值，
 * 第二个方法求两个double值中的最大值，
 * 第三个方法求三个double值中的最大值，并分别调用三个方法。
 * 
 */
public class OverLoadever {
	
	public static void main(String[] args) {
		OverLoadever test = new OverLoadever();
		//1.调用3个方法
		test.mOL(5);
		test.mOL(6, 4);
		test.mOL("fg");
		
		//2.调用3个方法
		int num1 = test.max(18, 452);
		System.out.println(num1);
		double num2 = test.max(5.6, -78.6);
		System.out.println(num2);
		double num3 = test.max(15, 52, 42);
		System.out.println(num3);
	}

	//1.如下三个方法构成重载
	public void mOL(int i){
		System.out.println(i*i);
	}
	public void mOL(int i,int j){
		System.out.println(i*j);
	}
	public void mOL(String s){
		System.out.println(s);
	}
	
	//2.如下三个方法构成重载
	public int max(int i,int j){
		return (i > j) ? i : j;
	}
	public double max(double i,double j){
		return (i > j) ? i : j;
	}
	public double max(double d1,double d2,double d3){
		double max = (d1 > d2) ? d1 : d2;
		return (max > d3) ? max : d3;
	}
}

4.5 可变个数的形参

/*
 * 可变个数形参的方法
 * 
 * 1.jdk5.0新增的内容
 * 2.具体使用：
 * 		2.1 可变个数形参的格式：数据类型 ... 变量名
 * 		2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个，2个 ......
 * 		2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成方法的重载
 * 		2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。
 * 			换句话说，二者不能共存，因为可变个数的形参也可以看成是数组
 * 		2.5 可变个数形参在方法的形参中，必须声明在末尾
 * 		2.6 可变个数形参在方法的形参中，最多只能声明一个可变形参
 */
public class MethodArgsTest {
	
	public static void main(String[] args) {
		MethodArgsTest test = new MethodArgsTest();
		
//		test.show(12);
//		test.show("hello");
//		test.show("hello","world");
//		test.show();
		
		test.show(new String[] {"AA","BB","CC"});
	}
	
	public void show(int i) {
		System.out.println("1");
	}
	
//	public void show(String s) {
//		System.out.println("2");
//	}
	
	public void show(String ... strs) {
		System.out.println("3");
		
		for(int i = 0;i < strs.length;i++) {
			System.out.println(strs[i]);
		}
		
	}
	
	//可变个数的形参在方法的形参中，必须声明在末尾
//	public void show(String ... strs,int i) { //编译不通过
//		System.out.println("4");
//	}
	
	public void show(int i,String ... strs) {
		System.out.println("5");
	}
	
}

4.6 方法参数的值传递机制(重点)

关于变量的赋值

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

}

class Order{
	
	int orderId;
	
}

针对于基本数据类型

/*
 * 方法形参的传递机制：值传递
 * 
 * 1.形参：方法定义时，声明的小括号内的参数
 *   实参：方法调用时，实际传递给形参的数据
 *   
 * 2.值传递机制：
 * 如果形参是基本数据类型，此时实参赋给形参的是：实参真实存储的数据值
 * 如果形参是引用数据类型，此时实参赋给形参的是：实参存储数据的地址值
 * 
 */
public class ValueTransferTest1 {

	public static void main(String[] args) {
		
		int m = 10;
		int n = 20;
		
		System.out.println("m = " + m + ", n = " + n); // m = 10, n = 20
		//交换两个变量的值的操作
//		int temp = m;
//		m = n;
//		n = temp;
		ValueTransferTest1 test = new ValueTransferTest1();
		test.swap(m, n); //此时的m,n是实参
		
		System.out.println("m = " + m + ", n = " + n); // m = 10, n = 20
	}
	
	public void swap(int m,int n) { //此时的m,n是形参
		int temp = m;
		m = n;
		n = temp;
    System.out.println("swap方法 " + "m = " + m + ", n = " + n);
    //swap方法 m = 20, n = 10
	}
	
}

针对于引用数据类型

/*
 * 方法形参的传递机制：值传递
 * 
 * 1.形参：方法定义时，声明的小括号内的参数
 *   实参：方法调用时，实际传递给形参的数据
 *   
 * 2.值传递机制：
 * 如果形参是基本数据类型，此时实参赋给形参的是：实参真实存储的数据值
 * 如果形参是引用数据类型，此时实参赋给形参的是：实参存储数据的地址值
 * 
 */
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 = 10, n = 20
		
		//交换m和n的值
//		int temp = data.m;
//		data.m = data.n;
//		data.n = temp;
		
		ValueTransferTest2 test = new ValueTransferTest2();
		
		test.swap(data); //此时的data是实参
		
		System.out.println("m = " + data.m + ", n = " + data.n); // m = 20, n = 10

	}
	
	public void swap(Data data) { //此时的data是形参
		int temp = data.m;
		data.m = data.n;
		data.n = temp;
    System.out.println("swap方法 "+"m = " + data.m + ", n = " + data.n);
    //swap方法 m = 20, n = 10
	}

}

class Data{
	int m;
	int n;
}

练习1

public class TransferTest3{
	public static void main(String args[]){
		TransferTest3 test=new TransferTest3();
		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;
}

练习2

在这里插入图片描述

public class Test {
  
  public static void main(String[] args) {
	int a = 10;
	int b = 10;
	method(a, b); //需要在method方法被调用之后，仅打印出a=100,b=200，请写出method方法的代码
	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虚拟机
	}
  
}

程序运行结果：

a=100
b=200

练习3

/*
 * 微软：
 * 定义一个int型的数组：int[] arr = new int[]{12,3,3,34,56,77,432};
 * 让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组。 
 */
 
//错误写法
for(int i= 0;i < arr.length;i++){
	arr[i] = arr[i] / arr[0]; //arr[0] / arr[0] = 1,这样就导致arr[0] = 1了，后面所有数除以arr[0]都		是它本身
}

//正确写法1
for(int i = arr.length –1;i >= 0;i--){
	arr[i] = arr[i] / arr[0];
}

//正确写法2
int temp = arr[0]; //定义一个临时变量temp
for(int i= 0;i < arr.length;i++){
	arr[i] = arr[i] / temp;
}

练习4

/*
 * int[] arr = new int[10];
 * System.out.println(arr);//地址值?
 * 
 * char[] arr1 = new char[10];
 * System.out.println(arr1);//地址值?
 */
public class ArrayPrint {

	public static void main(String[] args) {
		int[] arr = new int[]{1,2,3};
		System.out.println(arr);//地址值
		
		char[] arr1 = new char[]{'a','b','c'}; //char型数组打印的都是里面存储的数据，而不是地址值
		System.out.println(arr1);//abc
	}
}

练习5

/*
 * 练习5：将对象作为参数传递给方法
 * (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()方法，调用完毕后输出当前半径值。
 *
 */
public class Circle {
	
	double radius; //半径
	
  //返回圆的面积
	public double findArea() {
		return Math.PI * radius * radius;
	}

}

PassObject类

public class PassObject {
	
	public static void main(String[] args) {
		
		PassObject test = new PassObject();
		
		Circle c = new Circle();
		
		test.printAreas(c, 5);
		
		System.out.println("\t now radius is " + c.radius);
	}
	
	public void printAreas(Circle c, int time) {
		
		for(int i = 1;i <= time;i++) {
			//设置圆的半径值
			c.radius = i;
			double area = c.findArea();
			System.out.println(c.radius + "\t\t" + area);
		}
		
		c.radius = time + 1;
		
	}

}

4.7 递归

/*
 * 递归方法的使用（了解）
 * 1.递归方法：一个方法体内调用它自身
 * 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执 行无须循环控制。
 * 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死 循环。
 */
public class RecursionTest {
	
	public static void main(String[] args) {
		//例1：计算1-100之间所有自然数的和
		//方式一：
		int sum = 0;
		for(int i = 1;i <= 100;i++) {
			sum += i;
		}
		System.out.println(sum);
		
		//方式二：
		RecursionTest test = new RecursionTest();
		int sum1 = test.getSum(100);
		System.out.println(sum1);
		
		System.out.println("-------------------");
		
		System.out.println(test.f(10));
	}
	
	//例2：计算1-n之间所有自然数的和
	public int getSum(int n) {
		if(n == 1) {
			return 1;
		}else {
			return n + getSum(n - 1);
		}
	}
	
	//例3：计算1-n之间所有自然数的乘积:相当于n!,表示n的阶乘
	public int getSum1(int n) {
		
		if(n == 1) {
			return 1;
		}else {
			return n * getSum1(n - 1);
		}
		
	}
	
	/*
	 * 例4：已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2 * f(n+1) + f(n),
	 * 其中n是大于0的整数，求f(10)的值。
	 * 
	 * 解题思路：可以把f(n+2)当做f(n)，f(n+1)当做f(n-1)，f(n)当做f(n-2)
	 */
	public int f(int n) {
		if(n == 0) {
			return 1;
		}else if(n == 1) {
			return 4;
		}else {
			return 2 * f(n - 1) + f(n - 2);
		}
	}

}

练习

/*
 * 输入一个数据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 test = new Recursion2();
		int value = test.f(10);
		System.out.println(value);
	}
	
	public int f(int n) {

		if (n == 1 || n == 2) {
			return 1;
		} else {
			return f(n - 1) + f(n - 2);
		}
	}
}

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

封装性的引入与体现
为什么需要封装？封装的作用和含义？
我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？
我要开车，…

我们程序设计追求“高内聚，低耦合”。
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅对外暴露少量的方法用于使用。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

/*
 * 面向对象的特征一：封装与隐藏
 * 一、问题的引入：
 * 		当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对 对象的属性进行赋值。
 * 		这里，赋值操作要受到属性的数据类型和存储范围的制约。
 * 		除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值，加入额外的限制条件。
 * 		这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）
 *  	同时，我们需要避免用户再使用"对象.属性"的方式直接对属性进行赋值。而需要将属性声明为私有的(private).
 *  	-->此时，针对于属性就体现了封装性。
 *  
 * 二、封装性的体现：
 * 		我们将类的属性xxx私有化(private),同时，
 * 		提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
 * 	拓展：封装性的体现：① 如上  ② 不对外暴露私有的方法  ③ 单例模式   ...
 * 
 * 三、封装性的体现，需要权限修饰符来配合。
 * 1.Java规定的4种权限（从小到大排列）：private、缺省(default)、protected、public
 * 2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
 * 3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
 *        修饰类的话，只能使用：缺省(default)、public
 * 
 * 总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，
 * 体现类及类的内部结构在被调用时的可见性的大小。
 *  
 */
public class AnimalTest {
	
	public static void main(String[] args) {
		Animal a = new Animal();
		a.name = "大黄";
		
		a.show();
		
		//a.setLegs(6);
		a.setLegs(-6);
		
		a.show();
	}

}

class Animal{
	
	String name;
	private int age;
	private int legs; //腿的个数
	
	//对属性的设置
	public void setLegs(int l) {
		if(l >= 0 && l % 2 == 0) {
			legs = l;
		}else {
			legs = 0;
		}
		
	}
	
	//对属性的获取
	public int getLegs() {
		return legs;
	}
	
	//提供关于属性age的get和set方法
	public int getAge(){
		return age;
	}
	public void setAge(int a){
		age = a;
	}
	
	public void eat() {
		System.out.println("动物进食");
	}
	
	public void show() {
		System.out.println("name = " + name + ", age = " + age + ", legs = " + legs);
	}
	
}

5.1 四种权限修饰符

Java规定的4种权限修饰符（从小到大排列）：private、缺省(default)、protected、public

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

4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
具体的：
4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
对于（类）class的权限修饰只可以用public和default(缺省)
- public类可以在任意地方被访问。
- default类只可以被同一个包内部的类访问。

Order类

/*
 * 三、封装性的体现，需要权限修饰符来配合。
 *   1.Java 规定的 4 种权限：(从小到大排序)private、缺省(default)、protected、public
 *   2.4 种权限用来修饰类及类的内部结构：属性、方法、构造器、内部类
 *   3.具体的，4 种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
 * 		 修饰类的话，只能使用：缺省、public
 *  总结封装性：Java 提供了 4 中权限修饰符来修饰类积累的内部结构，体现类及类的内部结构的可见性的方法。
 * 
 */
public class Order {

	private int orderPrivate;
	int orderDefault;
	public int orderPublic;
	
	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;
	}
}

OrderTest 类

public class OrderTest {

	public static void main(String[] args) {
		
		Order order = new Order();
		
		order.orderDefault = 1;
		order.orderPublic = 2;
		//出了 Order 类之后，私有的结构就不可调用了
//		order.orderPrivate = 3;//The field Order.orderPrivate is not visible
		
		order.methodDefault();
		order.methodPublic();
		//出了 Order 类之后，私有的结构就不可调用了
//		order.methodPrivate();//The method methodPrivate() from the type Order is not visible
	}
}

相同项目不同包的 OrderTest 类

public class OrderTest {

	public static void main(String[] args) {
		Order order = new Order();
		
		order.orderPublic = 2;
		//出了 Order 类之后，私有的结构、缺省的声明结构就不可调用了
//		order.orderDefault = 1;
//		order.orderPrivate = 3;//The field Order.orderPrivate is not visible
		
		order.methodPublic();
		//出了 Order 类之后，私有的结构、缺省的声明结构就不可调用了
//		order.methodDefault();
//		order.methodPrivate();//The method methodPrivate() from the type Order is not visible
	}
}

在这里插入图片描述

封装性的练习

/*
 * 1.创建程序,在其中定义两个类：Person和PersonTest类。定义如下：
 * 用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。
 */
public class Person {
	
	private int age;
	private String name;
	
	public Person(){
		age = 18;
	}
	
	public Person(String n,int a){
		name = n;
		age = a;
	}
	
	public void setAge(int a){
		if(a < 0 || a > 130){
//			throw new RuntimeException("传入的数据非法！");
			System.out.println("传入的数据非法！");
			return;
		}
		age = a;
	}
	
	public int getAge(){
		return age;
	}
	
	//绝对不要这样写！！
//	public int doAge(int a){
//		age = a;
//		return age;
//	}
	
	public void setName(String n){
		name = n;
	}
	public String getName(){
		return name;
	}
	
}

测试类

/*
 * 在PersonTest类中实例化Person类的对象b，
 * 调用setAge()和getAge()方法，体会Java的封装性。
 */
public class PersonTest {
	public static void main(String[] args) {
		
		Person p1 = new Person();
//		p1.age = 1;编译不通过
		
		p1.setAge(12);
		
		System.out.println("年龄为：" + p1.getAge());
		
//		p1.doAge(122);
				
		Person p2 = new Person("Tom", 21);
		System.out.println("name = " + p2.getName() + ",age = " + p2.getAge());
		
	}
}

6.类的成员之三：构造器(或构造方法)

/*
 * 类的结构之三：构造器（或构造方法、constructor）的使用
 * construct：建设、建造。  construction:CCB    constructor:建设者
 * 
 * 一、构造器的作用：
 * 1.创建对象
 * 2.初始化对象的信息
 * 
 * 二、说明：
 * 1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器(无参的构造器)
 * 2.定义构造器的格式：权限修饰符 类名(形参列表){ }
 * 3.一个类中定义的多个构造器，彼此构成重载
 * 4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
 * 5.一个类中，至少会有一个构造器。
 */
public class PersonTest {
	public static void main(String[] args) {
		//创建类的对象:new + 构造器
		Person p = new Person();
		
		p.eat();
		
		Person p1 = new Person("Tom");
		
		System.out.println(p1.name); //Tom
	}
}

class Person{
	//属性
	String name;
	int age;
	
	//构造器
	public Person(){
		System.out.println("Person().....");
	}
	
	public Person(String n){
		name = n;
	}
	
	public Person(String n,int a){
		name = n;
		age = a;
	}

	//方法
	public void eat(){
		System.out.println("人吃饭");
	}
	
	public void study(){
		System.out.println("人可以学习");
	}
	
}

练习1

/* 2.在前面定义的 Person 类中添加构造器，
 * 利用构造器设置所有人的 age 属性初始值都为 18。
 * 
 */
public class Person {

	private int age;
	
	public Person(){
		age = 18;
	}
}

public class PersonTest {

	public static void main(String[] args) {
		Person p1 = new Person();

		System.out.println("年龄为:" + p1.getAge());
	}
}

练习2

/* 
 * 3.修改上题中类和构造器，增加 name 属性,
 *   使得每次创建 Person 对象的同时初始化对象的 age 属性值和 name 属性值。
 */
public class Person {

	private int age;
	private String name;
	
	public Person(){
		age = 18;
	}
	
	public Person(String n,int a){
		name = n;
		age = a;
	}
	
	public void setName(String n){
		name = n;
	}
	
	public String getName(){
		return name;
	}
	
	public void setAge(int a){
		if(a < 0 || a > 130){
//			throw new RuntimeException("传入的数据据非法");
			System.out.println("传入的数据据非法");
			return;
		}
		
		age = a;
	}
	
	public int getAge(){
		return age;
	}
}

public class PersonTest {

	public static void main(String[] args) {
		
		Person p2 = new Person("Tom",21);
		
		System.out.println("name = " + p2.getName() + ",age = " + p2.getAge());
	}
}

练习3

/*
 * 编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的底边长base和高height，
 * 同时声明公共方法访问私有变量。
 * 此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。
 */
public class TriAngle { //angle:角    angel:天使
	
	private double base;//底边长
	private double height;//高
	
	public TriAngle(){
		
	}
	
	public TriAngle(double b,double h){
		base = b;
		height = h;
	}
	
	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类

public class TriAngleTest {
	public static void main(String[] args) {
		
		TriAngle t1 = new TriAngle();
		t1.setBase(2.0);
		t1.setHeight(2.4);
//		t1.base = 2.5;//The field TriAngle.base is not visible
//		t1.height = 4.3;
		System.out.println("base : " + t1.getBase() + ",height : " + t1.getHeight());
		
		TriAngle t2 = new TriAngle(5.1,5.6);
		System.out.println("base : " + t2.getBase() + ",height : " + t2.getHeight());
	}
}

6.1 总结：属性赋值的先后顺序

/*
 * 总结：属性赋值的先后顺序
 * 
 * ① 默认初始化
 * ② 显式初始化
 * ③ 构造器中初始化
 * 
 * ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值
 * 
 * 以上操作的先后顺序：① - ② - ③ - ④  
 */
public class UserTest {
	public static void main(String[] args) {
		User u = new User();
		
		System.out.println(u.age);
		
		User u1 = new User(2);
		
		u1.setAge(3);
		u1.setAge(5);
		
		System.out.println(u1.age);
	}
}

class User{
	String name;
	int age = 1;
	
	public User(){
		
	}
	
	public User(int a){
		age = a;
	}
	
	public void setAge(int a){
		age = a;
	}
	
}

6.2 JavaBean的使用

/*
 * JavaBean是一种Java语言写成的可重用组件。

	所谓JavaBean，是指符合如下标准的Java类：
		>类是公共的
		>有一个无参的公共的构造器(构造器的权限与类的权限相同)
		>有属性，且有对应的get、set方法
 * 
 */
public class Customer {
	
	private int id;
	private String name;
	
	public Customer(){
		
	}
	
	public void setId(int i){
		id = i;
	}
	public int getId(){
		return id;
	}
	public void setName(String n){
		name = n;
	}
	public String getName(){
		return name;
	}
	
}

6.3 UML 类图

7.关键字的使用

7.1 关键字：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(形参列表)"，用来调用其他的构造器
 */
public class PersonTest {
	public static void main(String[] args) {
		
		Person p1 = new Person();
		
		p1.setAge(1);
		System.out.println(p1.getAge());
		
		p1.eat();
		
		System.out.println();
		
		Person p2 = new Person("Jerry",20);
		System.out.println(p2.getAge());
		
	}
}

class Person{
	
	private String name;
	private int age;
	
	public Person(){
		
//		this.eat();
		String info = "Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)";
		System.out.println(info);
	}
	
	public Person(String name){
		this();
		this.name = name;
		
	}
	
	public Person(int age){
		this();
		this.age = age;
		
	}
	
	public Person(String name,int age){
		this(age);
		this.name = name;
		//this.age = age;
		//Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)
	}
	
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return this.name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return this.age;
	}
	
	public void eat(){
		System.out.println("人吃饭");
		this.study();
	}
	public void study(){
		System.out.println("人学习");
	}
	
}

this的练习

Boy类

public class Boy {
	private String name;
	private int age;
	
	public Boy() {
		
	}
	
	public Boy(String name) {
		this.name = name;
	}

	public Boy(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public void marry(Girl girl){
		System.out.println("我想娶" + girl.getName());
	}
	
	public void shout(){
		if(this.age >= 22){
			System.out.println("你可以去合法登记结婚了！");
		}else{
			System.out.println("先多谈谈恋爱~~");
		}
		
	}
}

Girl类

public class Girl {
	
	private String name;
	private int age;
	
	public Girl() {

	}
	public Girl(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void marry(Boy boy){
		System.out.println("我想嫁给" + boy.getName());
		boy.marry(this);
	}
	
	/**
	 * @Description 比较两个对象的大小
	 * @author shkstart
	 * @date 2019年1月18日下午4:02:09
	 * @param girl
	 * @return  正数：当前对象大；  负数：当前对象小；  0：当前对象与形参对象相等
	 */
	public int compare(Girl girl){
//		if(this.age > girl.age){
//			return 1;
//		}else if(this.age < girl.age){
//			return -1;
//		}else{
//			return 0;
//		}
		
		return this.age - girl.age;
	}
}

测试类

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 girl1 = new Girl("祝英台",19);
		int compare = girl.compare(girl1);
		if(compare > 0){
			System.out.println(girl.getName() + "大");
		}else if(compare < 0){
			System.out.println(girl1.getName() + "大");
		}else{
			System.out.println("一样大");
		}
	}
}

练习2

/*
 * 写一个测试程序。
 * （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
 */

Account类

public class Account {
	
	private int id;//账号
	private double balance;//余额
	private double annualInterestRate;//年利率
	
	public Account (int id, double balance, double annualInterestRate ){
		this.id = id;
		this.balance = balance;
		this.annualInterestRate = annualInterestRate;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public double getBalance() {
		return balance;
	}

	public void setBalance(double balance) {
		this.balance = balance;
	}

	public double getAnnualInterestRate() {
		return annualInterestRate;
	}

	public void setAnnualInterestRate(double annualInterestRate) {
		this.annualInterestRate = annualInterestRate;
	}
	//在提款方法withdraw中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。
	public void withdraw (double amount){//取钱
		if(balance < amount){
			System.out.println("余额不足，取款失败");
			return;
		}
		balance -= amount;
		System.out.println("成功取出：" + amount);
	}
	
	public void deposit (double amount){//存钱
		if(amount > 0){
			balance += amount;
			System.out.println("成功存入：" + amount);
		}
	}
}

Customer类

public class Customer {
	
	private String firstName;
	private String lastName;
	private Account account;
	
	public Customer(String f,String l){
		this.firstName = f;
		this.lastName = l;
	}

	public Account getAccount() {
		return account;
	}

	public void setAccount(Account account) {
		this.account = account;
	}

	public String getFirstName() {
		return firstName;
	}

	public String getLastName() {
		return lastName;
	}

}

CustomerTest类

public class CustomerTest {
	public static void main(String[] args) {
		Customer cust = new Customer("Jane", "Smith");
		
		Account acct = new Account(1000, 2000, 0.0123);
		
		cust.setAccount(acct);
		
		cust.getAccount().deposit(100);
		cust.getAccount().withdraw(960);
		cust.getAccount().withdraw(2000);
		
		System.out.println("Customer[" + cust.getLastName() + "," + cust.getFirstName() + 
				"] has a account: id is " + cust.getAccount().getId() + ",annualInterestRate is "+
		cust.getAccount().getAnnualInterestRate() * 100 + "% ,balance is " + cust.getAccount().getBalance());
	}
}

练习2

Account类

public class Account {
	
	private double balance;
	
	public Account(double init_balance){
		this.balance = init_balance;
	}
	
	public double getBalance(){
		return balance;
	}
	
	//存钱操作
	public void deposit(double amt){
		if(amt > 0){
			balance += amt;
			System.out.println("存钱成功");
		}
	}
	//取钱操作
	public void withdraw(double amt){
		if(balance >= amt){
			balance -= amt;
			System.out.println("取钱成功");
		}else{
			System.out.println("余额不足");
		}
	}
}

Customer类

public class Customer {
  
	private String firstName;
	private String lastName;
	private Account account;
	
	public Customer(String f, String l) {
		this.firstName = f;
		this.lastName = l;
	}

	public Account getAccount() {
		return account;
	}

	public void setAccount(Account account) {
		this.account = account;
	}

	public String getFirstName() {
		return firstName;
	}

	public String getLastName() {
		return lastName;
	}
	
}

Bank类

public class Bank {

	private Customer[] customers;// 存放多个客户的数组
	private int numberOfCustomers;// 记录客户的个数

	public Bank() {
		customers = new Customer[10];
	}

	// 添加客户
	public void addCustomer(String f, String l) {
		Customer cust = new Customer(f, l);
		// customers[numberOfCustomers] = cust;
		// numberOfCustomers++;
		// 或
		customers[numberOfCustomers++] = cust;
	}

	// 获取客户的个数
	public int getNumOfCustomers() {
		return numberOfCustomers;
	}

	// 获取指定位置上的客户
	public Customer getCustomer(int index) {
		// return customers[index];//可能报异常
		if (index >= 0 && index < numberOfCustomers) {
			return customers[index];
		}
		return null;
	}
}

BankTest类

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 balance = bank.getCustomer(0).getAccount().getBalance();
		System.out.println("客户：" + bank.getCustomer(0).getFirstName() + "的账户余额为：" + balance);
		
		System.out.println("***********************");
		bank.addCustomer("万里", "杨");
		
		System.out.println("银行客户的个数为：" + bank.getNumOfCustomers());
	}
}

7.2 关键字：package 的使用

/*
 * 一、package关键字的使用
 * 1.为了更好的实现项目中类的管理，提供包的概念
 * 2.使用package声明类或接口所属的包，声明在源文件的首行
 * 3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
 * 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

7.3 MVC设计模式

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

7.4 import 的使用

import java.lang.reflect.Field;
import java.util.*;

import cn.sxt.exer4.Account;
import cn.sxt.exer4.Bank;
import cn.sxt.java2.java3.Dog;

import static java.lang.System.*;
import static java.lang.Math.*;
/*
 * 二、import关键字的使用
 * import:导入
 * 1. 在源文件中显式的使用import结构导入指定包下的类、接口
 * 2. 声明在包的声明和类的声明之间
 * 3. 如果需要导入多个结构，则并列写出即可
 * 4. 可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构
 * 5. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构
 * 6. 如果使用的类或接口是本包下定义的，则可以省略import结构
 * 7. 如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
 * 8. 使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
 * 
 * 9. import static:导入指定类或接口中的静态结构:属性或方法。 
 */
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!");
		
		Person p = new Person();
		
		Account acct = new Account(1000);
		//全类名的方式显示
		cn.sxt.exer3.Account acct1 = new cn.sxt.exer3.Account(1000,2000,0.0123);
		
		Date date = new Date();
		java.sql.Date date1 = new java.sql.Date(5243523532535L);
		
		Dog dog = new Dog();
		
		Field field = null;
		
		out.println("hello");
		
		long num = round(123.434);
	}
}