JavaSE[笔记][面向对象]上

第四章 面向对象[上]

面向过程与面向对象

何谓“面向对象”的编程思想？

首先解释一下“思想”。 先问你个问题：你想做个怎样的人？ 可能你会回答：我想做个好人，孝敬父母，尊重长辈，关爱亲朋…
你看，这就是思想。这是你做人的思想，或者说，是你做人的原则。做人有做人的原则，编程也有编程的原则。这些编程的原则呢，就是编程思想。

面向过程(POP) 与面向对象(OOP)

• 面向对象：Object Oriented Programming
• 面向过程：Procedure Oriented Programming

/*
 * 一、学习面向对象内容的三条主线
 * 1.Java 类及类的成员：属性、方法、构造器、代码块、内部类
 * 2.面向对象的三大特征：封装、继承、多态性、(抽象性)
 * 3.其它关键字：this、super、static、final、abstract、interface、package、import 等
 * 
 * 二、人把大象装进冰箱
 * 1.面向过程:强调的是功能行为，以函数为最小单位，考虑怎么做。
 * 
 * ① 打开冰箱
 * ② 把大象装进冰箱
 * ③ 把冰箱门关住 
 * 
 * 2.面向对象:强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
 * 人{
 * 		打开(冰箱){
 * 			冰箱.开门();
 * 		}操作(大象){
 * 			大象.进入(冰箱);
 * 		}关闭(冰箱){
 * 			 冰箱.关门();     
 * 		}
 * }
 * 
 * 冰箱{
 * 		开门(){
 * 		}  
 * 		关门(){
 * 		}
 * }
 * 
 * 大象{
 * 		进入(冰箱){
 * 		}
 * }
 */

面向对象的思想概述

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

类和对象

• 三、面向对象的两个要素：
• 类:对一类事物的描述，是抽象的、概念上的定义
  *对象:是实际存在的该类事物的每个个体，因而也称为实例(instance)。
  • 可以理解为：类= 抽象概念的人；对象= 实实在在的某个人
• 面向对象程序设计的重点是类的设计;
• 设计类，其实就是设计类的成员。

Java 类及类的成员

现实世界的生物体，大到鲸鱼，小到蚂蚁，都是由最基本的细胞构成的。同理，Java 代码世界是由诸多个不同功能的类构成的。
现实生物世界中的细胞又是由什么构成的呢？细胞核、细胞质、… 那么，Java 中用类 class 来描述事物也是如此。常见的类的成员有：

属性：对应类中的成员变量
行为：对应类中的成员方法

类与对象的创建及使用

* 一、设计类、其实就是设计类的成员
 * Field = 属性 = 成员变量 = 域、字段
 * Method = (成员)方法 = 函数 
 * 
 * 创建类 = 类的实例化 = 实例化类
 * 
 * 二.类和对象的使用(面向对象思想落地的实现)
 * 1.创建类，设计类的成员
 * 2.创建类的对象
 * 3.通过“对象.属性”或“对象.方法”调用对象的结构
 * 三、如果创建类一个类的多个对象，则每个对象都独立的拥有一套类的属性。(非 static 的)
 * 	  意味着:如果我们修改一个对象的属性 a，则不影响另外一个对象属性 a 的值。
 */
//测试类
public class PersonTest {
    
    
	public static void main(String[] args) {
    
    
		//2.创建 Person 类的对象
		//创建对象语法：类名对象名= new 类名();
		Person p1 = new Person();
		//Scanner scan = new Scanner(System.in);
		
		//调用类的结构：属性、方法
		//调用属性:“对象.属性”
		p1.name = "Tom";
		p1.age = 25;
		p1.isMale = true;
		System.out.println(p1.name);
		
		//调用方法:“对象.方法”
		p1.eat();
		p1.sleep();
		p1.talk("chinese");
		//**********************
		Person p2 = new Person();
		System.out.println(p2.name); //null
		System.out.println(p2.isMale);
		//**********************
		//将 p1 变量保存的对象地址值赋给 p3,导致 p1 和 p3 指向了堆空间中的一个对象实体。
		Person p3 = p1;
		System.out.println(p3.name);
		
		p3.age = 10;
		System.out.println(p1.age); //10
	}
}
/*
 * 类的语法格式：
 * 修饰符 class 类名{
    
    
 * 		属性声明;
 * 		方法声明;
 * }
 * 说明：修饰符 public：类可以被任意访问类的正文要用{
    
      }括起来
 */
//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);
	}
}

对象的创建和使用：内存解析

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

案例 1

Person p1= newPerson();
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;

类的成员之一：属性

/*

• 类中属性的使用
• 属性(成员变量) 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 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.talk("俄语");
}

}
class User{
//属性(或成员变量)
String name; //不加 private 即为缺省
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

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

EG:

public class School {
public static void main(String[] args) {
Student stu = new Student();
stu.name = “小明”;
stu.age = 16;

	Teacher tea = new Teacher();
	tea.name = "王老师";
    tea.age = 27;
    
    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);
}

}

4.4 类的成员之二：方法
/*

• 类中方法的声明和使用
• 方法：描述类应该具有的功能。
• 比如：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:递归方法。
  

•  方法中不能定义其他方法。
  

*/
public class CustomerTest {
public static void main(String[] args) {

	Customer cust1 = new Customer();
	
	cust1.eat();
	
	//测试形参是否需要设置的问题

// int[] arr = new int[]{3,4,5,2,5};
// cust1.sort();

	cust1.sleep(8);
	
}

}
//客户类
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);
}

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,63,2,5};
// //。。。。
// }

public void info(){
	//错误的

// public void swim(){
//
// }

}

}

练习1

创建一个Person类，其定义如下：

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();
	
	p1.showAge();
	
	int newAge = p1.addAge(2);
	System.out.println(p1.name + "的年龄为" + newAge);
	
	System.out.println(p1.age);	//20
	
	//*******************************
	Person p2 = new Person();
	p2.showAge();	//0
	p2.addAge(10);
	p2.showAge();	//10
	
	p1.showAge();	//20
}

}
练习2

/*

• 2.利用面向对象的编程方法，设计类Circle计算圆的面积。
  */
  //测试类
  public class CircleTest {
  public static void main(String[] args) {
  Circle c1 = new Circle();

   c1.radius = 2.1;
   
   //对应方式一:
  

// double area = c1.findArea();
// System.out.println(area);

	//对应方式二:
	c1.findArea();
	//错误的调用
	double area = c1.findArea(3.4);
	System.out.println(area);
}

}
//圆:3.14rr
class Circle{
//属性
double radius;

//圆的面积方法
//方法1：

// public double findArea(){
// double area = 3.14 * radius * radius;
// return area;
// }
//方法2：
public void findArea(){
double area = Math.PI * radius * radius;
System.out.println(“面积为:” + area);
}
//错误情况:
public double findArea(Double r){
double area = 3.14 * r * r;
return area;
}
}

练习3

/*

• 3.1 编写程序，声明一个method方法，在方法中打印一个108的型矩形，在main方法中调用该方法。
• 3.2修改上一个程序，在method方法中，除打印一个108的型矩形外，再计算该矩形的面积，
• 并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
• 3.3 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个mn的型矩形，
• 并计算该矩形的面积，将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。

*/
public class ExerTest {

public static void main(String[] args) {
	
	ExerTest esr = new ExerTest();
	//3.1测试

// esr.method();

	//3.2测试
	//方式一：

// int area = esr.method();
// System.out.println(“面积为:” + area);

	//方式二:

// System.out.println(“面积为:” + esr.method());

	//3.3测试
	System.out.println("面积为:" + esr.method(6,5));
}
//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;
// }

//3.3
public int method(int m,int n){
	for(int i = 0;i < m;i++){
		for(int j = 0;j < n;j++){
			System.out.print("* ");
		}
		System.out.println();
	}
	return m * n;
}

}

练习四

/*

• 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 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]
		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;

•  2) 四舍五入取整：Math.round(double d)，返回值类型long。
  

• 此代码是对StudentTest.java的改进，将操作数组的功能封装到方法中。
  */
  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());
   }
  

  }

  /**
  *

  • @Description 遍历Student[]数组的操作
  • @author subei
  • @date 2020年4月15日下午8:25:36
  • @param stu
    */
    public void print(Student2[] stu){
    for(int i = 0;i < stu.length;i++){
    System.out.println(stu[i].info());
    }
    }

  /**
  *

  • @Description 查找Student数组中指定年级的学习信息
  • @author subei
  • @date 2020年4月15日下午8:22:34
  • @param stu
  • @param state
    */
    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());
    }
    }
    }

  /**
  *

  • @Description 给Student数组排序
  • @author subei
  • @date 2020年4月15日下午8:24:33
  • @param stu
    */
    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;
  }
  }

类的成员之二：方法
类中方法的声明和使用

*
 * 类中方法的声明和使用
 * 
 * 方法：描述类应该具有的功能。
 * 比如：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:递归方法。
 *  	方法中不能定义其他方法。
 */
public class CustomerTest {
	public static void main(String[] args) {
		
		Customer cust1 = new Customer();
		
		cust1.eat();
		
		//测试形参是否需要设置的问题
//		int[] arr = new int[]{3,4,5,2,5};
//		cust1.sort();
		
		cust1.sleep(8);
		
	}
}

//客户类
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);
	}
	
	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,63,2,5};
//		//。。。。
//	}
	
	public void info(){
		//错误的
//		public void swim(){
//			
//		}
		
	}
}

练习1
创建一个Person类，其定义如下：

ublic 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();
	
	p1.showAge();
	
	int newAge = p1.addAge(2);
	System.out.println(p1.name + "的年龄为" + newAge);
	
	System.out.println(p1.age);	//20
	
	//*******************************
	Person p2 = new Person();
	p2.showAge();	//0
	p2.addAge(10);
	p2.showAge();	//10
	
	p1.showAge();	//20
}

}

练习2

/*

• 2.利用面向对象的编程方法，设计类Circle计算圆的面积。
  */
  //测试类
  public class CircleTest {

  public static void main(String[] args) {
  Circle c1 = new Circle();

   c1.radius = 2.1;
   
   //对应方式一:
  

// double area = c1.findArea();
// System.out.println(area);

	//对应方式二:
	c1.findArea();

	//错误的调用
	double area = c1.findArea(3.4);
	System.out.println(area);
}

}
//圆:3.14rr
class Circle{
//属性
double radius;

//圆的面积方法
//方法1：

// public double findArea(){
// double area = 3.14 * radius * radius;
// return area;
// }
//方法2：
public void findArea(){
double area = Math.PI * radius * radius;
System.out.println(“面积为:” + area);
}
//错误情况:
public double findArea(Double r){
double area = 3.14 * r * r;
return area;
}
}

练习3

/*

• 3.1 编写程序，声明一个method方法，在方法中打印一个108的型矩形，在main方法中调用该方法。
• 3.2修改上一个程序，在method方法中，除打印一个108的型矩形外，再计算该矩形的面积，
• 并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
• 3.3 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个mn的型矩形，
• 并计算该矩形的面积，将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。

*/
public class ExerTest {

public static void main(String[] args) {
	
	ExerTest esr = new ExerTest();
	//3.1测试

// esr.method();

	//3.2测试
	//方式一：

// int area = esr.method();
// System.out.println(“面积为:” + area);

	//方式二:

// System.out.println(“面积为:” + esr.method());

	//3.3测试
	System.out.println("面积为:" + esr.method(6,5));
}
//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;
// }

//3.3
public int method(int m,int n){
	for(int i = 0;i < m;i++){
		for(int j = 0;j < n;j++){
			System.out.print("* ");
		}
		System.out.println();
	}
	return m * n;
}

}

练习四

/*

• 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 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]
		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;

•  2) 四舍五入取整：Math.round(double d)，返回值类型long。**
  

• 此代码是对StudentTest.java的改进，将操作数组的功能封装到方法中。
  */
  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());
   }
  

  }

  /**
  *

  • @Description 遍历Student[]数组的操作
  • @author subei
  • @date 2020年4月15日下午8:25:36
  • @param stu
    */
    public void print(Student2[] stu){
    for(int i = 0;i < stu.length;i++){
    System.out.println(stu[i].info());
    }
    }

  /**
  *

  • @Description 查找Student数组中指定年级的学习信息
  • @author subei
  • @date 2020年4月15日下午8:22:34
  • @param stu
  • @param state
    */
    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());
    }
    }
    }

  /**
  *

  • @Description 给Student数组排序
  • @author subei
  • @date 2020年4月15日下午8:24:33
  • @param stu
    */
    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;
  }
  }

理解“万事万物皆对象”
/* 1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构。

•  》Scanner,String等
  

•  》文件：File
  

•  》网络资源：URL
  

• 2.涉及到Java语言与前端html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。
  */

对象数组的内存解析

/*
引用类型的变量，只可能存储量两类值：null或地址值（含变量类型）
*/
Student[] stus= newStudent[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;//成绩
}

匿名对象的使用

/*

• 三、匿名对象的使用

• 1.理解:我们创建的对象，没有显示的赋值给一个变量名。即为匿名对象。

• 2.特征：匿名对象只能调用一次。

• 3.使用:如下
  */
  public class InstanceTest {
  public static void main(String[] args) {
  Phone p = new Phone();
  // p = null;
  System.out.println§;

   p.sendEmail();
   p.playGame();
   
   //匿名对象
  

// new Phone().sendEmail();
// new Phone().playGame();

	new Phone().price = 1999;
	new Phone().showPrice();	//0.0
	
	//*******************************
	PhoneMall mall = new PhoneMall();

// mall.show§;
//匿名对象的使用
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);
}

}

自定义数组的工具类

工具类
/*

• 自定义数组工具类
  */
  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;
  }
  }
  测试类
  class ArrayUtilTest {

  public static void main(String[] args) {
  ArrayUtil util = new ArrayUtil();
  int[] arr = new int[]{32,5,26,74,0,96,14,-98,25};
  int max = util.getMax(arr);
  System.out.println(“最大值为:” + max);

// System.out.print(“排序前:”);
// util.print(arr);
//
// util.sort(arr);
// System.out.print(“排序后:”);
// util.print(arr);

	System.out.println("查找:");
	int index = util.getIndex(arr, 5);
	if(index > 0){
		System.out.println("找到了，索引地址:" + index);
	}else{
		System.out.println("没找到");
	}
}

}

再谈方法

方法的重载(overload)
/*

• 方法的重载(overload)loading…
• 1.定义:在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

•  “两同一不同”:同一个类、相同方法名
  

•  		  参数列表不同：参数个数不同，参数类型不同
  

• 2.举例:

•  Arrays类中重载的sort() / binarySearch()
  

• 3.判断是否重载

•  与方法的返回值类型、权限修饰符、形参变量名、方法体都无关。
  

• 4.在通过对象调用方法时，如何确定某一个指定的方法：

•  方法名---》参数列表
  

*/
public class OverLoadTest {

public static void main(String[] args) {
	OverLoadTest test = new OverLoadTest();
	test.getSum(1, 2);	//调用的第一个，输出1
}

//如下的四个方法构成了重载
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){
	
}

//以下3个是错误的重载

// 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)intshow(int a,double c,charb){} // yes
c) void show(int a,double c,char b){} // yes
d) booleanshow(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;
}

}
可变个数的形参

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可变个数形参在方法中的形参中，最多只能声明一个可变形参。
  */
  public class MethodArgs {

  public static void main(String[] args) {
  MethodArgs test = new MethodArgs();
  test.show(12);
  // test.show(“hell0”);
  // test.show(“hello”,“world”);
  // test.show();

  test.show(new String[] { "AA", "BB", "CC" });
  

  }

  public void show(int i) {

  }

  // public void show(String s){
  // System.out.println(“show(String)”);
  // }
  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){
  //
  // }

  public void show(int i, String… strs) {

  }

  //The variable argument type String of the method show must be the last parameter
  // public void show(String… strs,int i,) {
  //
  // }
  }

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

/*

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

*/
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);
	
	n = 20;
	
	System.out.println("m = " + m + ", n = " + n);

	System.out.println("***********引用数据类型:********");
	
	Order o1 = new Order();
	o1.orderId = 1001;
	
	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;
}

针对基本数据类型

/*

• 方法的形参的传递机制：值传递

• 1.形参：方法定义时，声明的小括号内的参数

• 实参：方法调用时，实际传递给形参的数据

• 2.值传递机制：

• 如果参数是基本数据类型，此时实参赋值给形参的是实参真是存储的数据值。
  */
  public class ValueTransferTest1 {

  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 test = new ValueTransferTest1();
	test.swap(m, n);
	
	System.out.println("m = " + m + ", n = " + n);
	
}

public void swap(int m,int n){
	int temp = m;
	m = n;
	n = temp;
}

}

针对引用数据类型

• 如果参数是引用数据类型，此时实参赋值给形参的是实参存储数据的地址值。
  */
  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 test = new ValueTransferTest2();
	test.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;

}

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

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

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

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

/*

• 面向对象的特征一:封装与隐藏
• 一、问题的引入：
• 当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到
• 属性的数据类型和存储范围的制约。但除此之外，没有其他制约条件。但是，实际问题中，我们往往需要给属性赋值
• 加入额外限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行条件的添加。比如说，setLegs
• 同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的(private)
• –》此时，针对于属性就体现了封装性。
• 二、封装性的体现：
• 我们将类的属性私有化(private),同时,提供公共的(public)方法来获取(getXxx)和设置(setXxx)
• 拓展：封装性的体现：① 如上 ② 单例模式 ③ 不对外暴露的私有方法

*/
public class AnimalTest {

public static void main(String[] args) {
	Animal a = new Animal();
	a.name = "大黄";

// a.age = 1;
// a.legs = 4;//The field Animal.legs is not visible

	a.show();

// a.legs = -4;
// a.setLegs(6);
a.setLegs(-6);

// a.legs = -4;//The field Animal.legs is not visible
a.show();

	System.out.println(a.name);
	System.out.println(a.getLegs());
}

}
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;
}

public void eat(){
	System.out.println("动物进食");
}

public void show(){
	System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
}

//提供关于属性 age 的 get 和 set 方法
public int getAge(){
	return age;
}

public void setAge(int a){
	age = a;
}

}

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

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

对于 class 的权限修饰只可以用 public 和 default(缺省)。
》public 类可以在任意地方被访问。
》default 类只可以被同一个包内部的类访问。

封装性的练习

/*

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

*/
public class Person {

private int age;

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;
}

}

测试类

/*

• 在 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());
  

  }
  }

构造器(构造方法)
构造器的理解
/*

• 类的结构之三:构造器(构造方法、constructor)的使用

• constructor:

• 一、构造器的作用:

• 1.创建对象

• 2.初始化对象的属性

• 二、说明

• 1.如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器。

• 2.定义构造器的格式:

•  	权限修饰符  类名(形参列表) { }
  

• 3.一个类中定义的多个构造器，彼此构成重载。

• 4.一旦显示的定义了类的构造器之后，系统不再提供默认的空参构造器。

• 5.一个类中，至少会有一个构造器
  */
  public class PersonTest {

  public static void main(String[] args) {
  //创建类的对象:new + 构造器
  Person p = new Person(); //Person()这就是构造器

   p.eat();
   
   Person p1 = new Person("Tom");
   System.out.println(p1.name);
  

  }
  }
  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(“人学习”);
  }
  }

总结属性赋值的过程

/*

• 总结:属性赋值的先后顺序
• ① 默认初始化值
• ② 显式初始化
• ③ 构造器中赋值
• ④ 通过"对象.方法" 或 “对象.属性”的方式，赋值
• 以上操作的先后顺序:① - ② - ③ - ④

*/
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);
	
	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;
}

}

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;
}

}

关键字：this 的使用

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;
}

public void setNmea(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 void setName(String name){
	this.name = name;
}

public String getName(){
	return name;
}

public void setAge(int ahe){
	this.age = age;
}

public int getAge(){
	return age;
}

public Boy(String name, int age) {
	this.name = name;
	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 String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}

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

public void marry(Boy boy){
	System.out.println("我想嫁给" + boy.getName());
}
/**
  * 
  * @Description 比较两个对象的大小
  * @author subei
  * @date 2020 年 4 月 21 日上午 9:17:35
  * @param girl
  * @return
 */
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("一样的");
	}
}

}

关键字：package、import 的使用

关键字—package

/* * 一、package 关键字的使用

• 1.为了更好的实现项目中类的管理，提供包的概念
• 2.使用 package
  声明类或接口所属的包，生命在源文件的首行
• 3.包，属于标识符，遵循标识符的命名规则、规范"见名知意" *
  4.每“.”一次,就代表一层文件目录。 *
• 补充:同一个包下，不能命名同名接口或同名类 *
  不同包下，可以命名同名的接口、类。
• */ public class PackageImportTest {

}

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

MVC 设计模式

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

关键字—import

import java.util.*;

import account2.Bank;

/*

• 二、import关键字的使用
• import:导入
• 1.在源文件中显式的使用import结构导入指定包下的类、接口
• 2.声明在包的声明和类的声明之间
• 3.如果需要导入多个结构，则并列写出即可
• 4.可以使用"xxx.*"的方式,表示可以导入xxx包下的所有结构。
• 5.如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
• 6.如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。
• 7.如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
• 8.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");
	
	UserTest us = new UserTest();
	
}

}