JAVA基础学习笔记-day05-面向对象基础

乐天呀

已于 2023-11-16 09:17:31 修改

阅读量307

点赞数 6

分类专栏：编程语言 # JAVA 文章标签： java 学习笔记开发语言

于 2023-11-13 22:03:06 首次发布

本文链接：https://blog.csdn.net/qq_41008110/article/details/134320311

版权

编程语言同时被 2 个专栏收录

17 篇文章 0 订阅

订阅专栏

JAVA

17 篇文章 0 订阅

订阅专栏

JAVA基础学习笔记-day05-面向对象基础

面向对象基础
1. 面向对象概述
2. Java语言的基本元素：类和对象
3. 对象的内存解析
- 3.1 JVM内存结构划分
- 3.2 对象内存解析
4. 类的成员之一：成员变量(field)
- 4.1 如何声明成员变量
- 4.2 成员变量 vs 局部变量
5. 类的成员之二：方法(method)
6. 对象数组
7. 方法
8. 关键字：package、import
9. 面向对象特征一：封装性(encapsulation)
- 9.1 Java如何实现数据封装
- 9.2 封装性的体现
10. 类的成员之三：构造器(Constructor)
11. 阶段性知识补充

博文主要是自己学习JAVA基础中的笔记，供自己以后复习使用，参考的主要教程是B站的
尚硅谷宋红康2023大数据教程
锲而不舍，金石可镂。——荀况

面向对象基础

‘学习面向对象的三条主线:’
Java类及类的成员：（重点）属性、方法、构造器；（熟悉）代码块、内部类
面向对象的特征：封装、继承、多态、（抽象）
其他关键字的使用：this、super、package、import、static、final、interface、abstract等

1. 面向对象概述

面向对象，是软件开发中的一类编程风格、开发范式。除了面向对象，还有面向过程、指令式编程和
函数式编程。

面向过程的程序设计思想（Process-Oriented Programming），简称 POP

关注的焦点是过程：过程就是操作数据的步骤。如果某个过程的实现代码重复出现，那么就可以
把这个过程抽取为一个函数。这样就可以大大简化冗余代码，便于维护。
典型的语言：C语言
代码结构：以函数为组织单位。
是一种“ 执行者思维 ”，适合解决简单问题。扩展能力差、后期维护难度较大。

面向对象的程序设计思想（ Object Oriented Programming），简称 OOP

关注的焦点是类：在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽
象出来，用类来表示。
典型的语言：Java、C#、C++、Python、Ruby和PHP等
代码结构：以类为组织单位。每种事物都具备自己的属性和 行为/功能 。
是一种“ 设计者思维 ”，适合解决复杂问题。代码扩展性强、可维护性高。

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

2.1 类和对象概述

类(Class) 和对象(Object) 是面向对象的核心概念。
类：具有相同特征的事物的抽象描述，是 抽象的 、概念上的定义。
对象：实际存在的该类事物的每个个体，是 具体的 ，因而也称为实例(instance) 。

2.2 类的成员概述

面向对象程序设计的重点是类的设计
类的设计，其实就是类的成员的设计

类，是一组相关属性和行为的集合，这也是类最基本的两个成员。
**属性：**该类事物的状态信息。对应类中的 成员变量
成员变量 <=> 属性 <=> Field
**行为：**该类事物要做什么操作，或者基于事物的状态能做什么。对应类中的 成员方法
(成员)方法 <=> 函数 <=> Method

2.3 面向对象完成功能的三步骤（重要）

步骤1：类的定义
类的定义使用关键字：class。格式如下：

[修饰符] class 类名{
	属性声明;
	方法声明;
}
举例1：
public class Person{
	//声明属性age
	int age ;
	//声明方法showAge()
	public void eat() {
		System.out.println("人吃饭");
	}
}

步骤2：对象的创建
创建对象，使用关键字：new

//方式1：给创建的对象命名
//把创建的对象用一个引用数据类型的变量保存起来，这样就可以反复使用这个对象了
类名 对象名 = new 类名();
//方式2：
new 类名()//也称为匿名对象
//例如
class PersonTest{
	public static void main(String[] args){
		//创建Person类的对象
		Person per = new Person();
		//创建Dog类的对象
		Dog dog = new Dog();
	}
}

步骤3：对象调用属性或方法
对象是类的一个实例，必然具备该类事物的属性和行为（即方法）。
使用" 对象名.属性 " 或 " 对象名.方法 "的方式访问对象成员（包括属性和方法）

public class Person{
	String name;
	char gender;
	Dog dog;
	//喂宠物
	public void feed(){
		dog.eat();
	}
}
public class Game{
	public static void main(String[] args){
		Person p = new Person();
		//通过Person对象调用属性
		p.name = "康师傅";
		p.gender = '男';
		p.dog = new Dog(); //给Person对象的dog属性赋值
		//给Person对象的dog属性的type、nickname属性赋值
		p.dog.type = "柯基犬";
		p.dog.nickName = "小白";
		//通过Person对象调用方法
		p.feed();
	}
}

2.4 匿名对象 (anonymous object)

我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。
如：new Person().shout();
使用情况
如果一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
我们经常将匿名对象作为实参传递给一个方法调用。

3. 对象的内存解析

3.1 JVM内存结构划分

在这里插入图片描述
其中：

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

3.2 对象内存解析

class Person { //类：人
	String name;
	int age;
	boolean isMale;
}
public class PersonTest { //测试类
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.name = "赵同学";
		p1.age = 20;
		p1.isMale = true;
		Person p2 = new Person();
		p2.age = 10;
		Person p3 = p1;
		p3.name = "郭同学";
	}
}

在这里插入图片描述

说明：
堆：凡是new出来的结构(对象、数组)都放在堆空间中。对象的属性存放在堆空间中。
- 创建一个类的多个对象（比如p1、p2），则每个对象都拥有当前类的一套"副本"（即属性）。当通过一个对象修改其属性时，不会影响其它对象此属性的值。
- 当声明一个新的变量使用现有的对象进行赋值时（比如p3 = p1），此时并没有在堆空间中创建新的对象。而是两个变量共同指向了堆空间中同一个对象。当通过一个对象修改属性时，会影响另外一个对象对此属性的调用
面试题：对象名中存储的是什么呢？
答：对象地址

public class StudentTest{
	public static void main(String[] args){
		System.out.println(new Student());//Student@7852e922
		Student stu = new Student();
		System.out.println(stu);//Student@4e25154f
		int[] arr = new int[5];
		System.out.println(arr);//[I@70dea4e
	}
}
//直接打印对象名和数组名都是显示“类型@对象的hashCode值"，所以说类、数组都是引用数据类型，引
//用数据类型的变量中存储的是对象的地址，或者说指向堆中对象的首地址。

4. 类的成员之一：成员变量(field)

4.1 如何声明成员变量

[修饰符1] class 类名{
[修饰符2] 数据类型 成员变量名 [= 初始化值];
}
public class Person{
	private int age; //声明private变量 age
	public String name = “Lila”; //声明public变量 name
}

位置要求：必须在类中，方法外
修饰符2(暂不考虑)
常用的权限修饰符有：private、缺省、protected、public
其他修饰符：static、final
数据类型
任何基本数据类型(如int、Boolean) 或任何引用数据类型。
成员变量名
属于标识符，符合命名规则和规范即可。
初始化值
根据情况，可以显式赋值；也可以不赋值，使用默认值

4.2 成员变量 vs 局部变量

在这里插入图片描述其中，static可以将成员变量分为两大类，静态变量和非静态变量。其中静态变量又称为类变量，
非静态变量又称为实例变量或者属性。接下来先学习实例变量。
成员变量与局部变量的对比:
相同点

变量声明的格式相同：数据类型变量名 = 初始化值
变量必须先声明、后初始化、再使用。
变量都有其对应的作用域。只在其作用域内是有效的

不同点

	1.  声明位置和方式 （1）实例变量：在类中方法外 （2）局部变量：在方法体{}中或方法的形参列表、代
码块中
	2、在内存中存储的位置不同 （1）实例变量：堆 （2）局部变量：栈
	3、生命周期 （1）实例变量：和对象的生命周期一样，随着对象的创建而存在，随着对象被GC回收而消
亡， 而且每一个对象的实例变量是独立的。 （2）局部变量：和方法调用的生命周期一样，每一次方法
被调用而在存在，随着方法执行的结束而消亡， 而且每一次方法调用都是独立。
	4、作用域 （1）实例变量：通过对象就可以使用，本类中直接调用，其他类中“对象.实例变量” （2）局
部变量：出了作用域就不能使用
	5、修饰符（后面来讲） （1）实例变量：public,protected,private,final,volatile,transient等 （2）局部变
量：final
	6、默认值 （1）实例变量：有默认值 （2）局部变量：没有，必须手动初始化。其中的形参比较特殊，
靠实参给它初始化。

对象属性的默认初始化赋值
在这里插入图片描述

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

5.1 方法(method、函数)的理解

方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为 函数或过程 。
将功能封装为方法的目的是，可以实现代码重用，减少冗余，简化代码
Java里的方法 不能独立存在 ，所有的方法必须定义在类里。

5.3 如何声明方法

[修饰符] 返回值类型 方法名([形参列表])[throws 异常列表]{
	方法体的功能代码
}

一个完整的方法 = 方法头 + 方法体。方法头就是 [修饰符] 返回值类型方法名([形参列表])[throws异常列表] ，也称为 方法签名 通常调用方法时只需要关注方法头就可以，从方法头可以看出这个方法的功能和调用格式。方法体就是方法被调用后要执行的代码。对于调用者来说，不了解方法体如何实现的，并不影响方法的使用。
方法头可能包含5个部分

修饰符：可选的。方法的修饰符也有很多，例如：public、protected、private、static、abstract、native、final、synchronized等，后面会一一学习。
- 其中，权限修饰符有public、protected、private。在讲封装性之前，我们先默认使用pulbic修饰方法。
- 其中，根据是否有static，可以将方法分为静态方法和非静态方法。其中静态方法又称为类方
  法，非静态方法又称为实例方法。咱们在讲static前先学习实例方法。
返回值类型： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者。
- 无返回值，则声明：void
- 有返回值，则声明出返回值类型（可以是任意类型）。与方法体中“ return 返回值 ”搭配使用
方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”
形参列表：表示完成方法体功能时需要外部提供的数据列表。可以包含零个，一个或多个参数。
- 无论是否有参数，()不能省略
- 如果有参数，每一个参数都要指定数据类型和参数名，多个参数之间使用逗号分隔，例如：
  - 一个参数： (数据类型参数名)
  - 二个参数： (数据类型1 参数1, 数据类型2 参数2)
- 参数的类型可以是基本数据类型、引用数据类型
throws 异常列表：可选，在【第09章-异常处理】章节再讲

方法体：方法体必须有{}括起来，在{}中编写完成方法功能的代码
关于方法体中return语句的说明：
- return语句的作用是结束方法的执行，并将方法的结果返回去
- 如果返回值类型不是void，方法体中必须保证一定有 return 返回值; 语句，并且要求该返回值结果的类型与声明的返回值类型一致或兼容。
- 如果返回值类型为void时，方法体中可以没有return语句，如果要用return语句提前结束方法的执
  行，那么return后面不能跟返回值，直接写return ; 就可以。
- return语句后面就不能再写其他代码了，否则会报错：Unreachable code

补充：方法的分类：按照是否有形参及返回值
在这里插入图片描述

5.4 如何调用实例方法

//格式
对象.方法名([实参列表])
（1）必须先声明后使用，且方法必须定义在类的内部
（2）调用一次就执行一次，不调用不执行。
（3）方法中可以调用类中的方法或属性，不可以在方法内部定义方法。
关键字return的使用
	return在方法中的作用：
		作用1：结束一个方法
		作用2：结束一个方法的同时，可以返回数据给方法的调用者
	注意点：在return关键字的直接后面不能声明执行语句

5.5 方法调用内存分析

方法 没有被调用 的时候，都在 方法区 中的字节码文件(.class)中存储。
方法 被调用 的时候，需要进入到 栈内存 中运行。方法每调用一次就会在栈中有一个入栈动作，即给当前方法开辟一块独立的内存区域，用于存储当前方法的局部变量的值。
当方法执行结束后，会释放该内存，称为出栈，如果方法有返回值，就会把结果返回调用处，如
果没有返回值，就直接结束，回到调用处继续执行下一条指令。
栈结构：先进后出，后进先出。
在这里插入图片描述

6. 对象数组

数组的元素可以是基本数据类型，也可以是引用数据类型。当元素是引用类型中的类时，我们称为对象
数组。
注意：
对象数组，首先要创建数组对象本身，即确定数组的长度，然后再创建每一个元素对象，如果不创建，
数组的元素的默认值就是 null ，所以很容易出现 空指针异常NullPointerException 。
练习

/*（1）定义矩形类Rectangle，包含长、宽属性，area()返回矩形面积的方法，perimeter()返回矩形周长的
方法，String getInfo()返回圆对象的详细信息（如：长、宽、面积、周长等数据）的方法
（2）在测试类中创建长度为3的Rectangle[]数组，用来装3个矩形对象，并给3个矩形对象的长分别赋值
为10,20,30，宽分别赋值为5,15,25，遍历输出
*/
package com.atguigu.test08.array;
public class Rectangle {
	double length;
	double width;
	public double area(){//面积
	return length * width;
}
	public double perimeter(){//周长
		return 2 * (length + width);
	}
	public String getInfo(){
		return 	"长：" + length +
				"，宽：" + width +
				"，面积：" + area() +
				"，周长：" + perimeter();
	}
}
package com.atguigu.test08.array;
public class ObjectArrayTest {
	public static void main(String[] args) {
		//声明并创建一个长度为3的矩形对象数组
		Rectangle[] array = new Rectangle[3];
		//创建3个矩形对象，并为对象的实例变量赋值，
		//3个矩形对象的长分别是10,20,30
		//3个矩形对象的宽分别是5,15,25
		//调用矩形对象的getInfo()返回对象信息后输出
		for (int i = 0; i < array.length; i++) {
			//创建矩形对象
			array[i] = new Rectangle();
			//为矩形对象的成员变量赋值
			array[i].length = (i+1) * 10;
			array[i].width = (2*i+1) * 5;
			//获取并输出对象对象的信息
			System.out.println(array[i].getInfo());
	}
	
	}
}

内存解析
在这里插入图片描述

7. 方法

7.1 方法的重载（overload）

**概念：**在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可。
参数列表不同，意味着参数个数或参数类型的不同。
特点：与修饰符、返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参
数类型)。调用时，根据方法参数列表的不同来区别。
重载方法调用：JVM通过方法的参数列表，调用匹配的方法。

先找个数、类型最匹配的
再找个数和类型可以兼容的，如果同时多个方法可以兼容将会报错
例如：

//返回两个整数的和
public int add(int x,int y){
	return x+y;
}
//返回三个整数的和
public int add(int x,int y,int z){
	return x+y+z;
}
//返回两个小数的和
public double add(double x,double y){
	return x+y;
}

7.2 可变个数的形参

在JDK 5.0 中提供了Varargs(variable number of arguments)机制。即当定义一个方法时，形参的类型可以确定，但是形参的个数不确定，那么可以考虑使用可变个数的形参。
格式：

方法名(参数的类型名 ...参数名)
//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String...books);
特点:
1. 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
2. 可变个数形参的方法与同名的方法之间，彼此构成重载
3. 可变参数方法的使用与方法参数部分使用数组是一致的，二者不能同时声明，否则报错。
4. 方法的参数部分有可变形参，需要放在形参声明的最后
5. 在一个方法的形参中，最多只能声明一个可变个数的形参

7.3 方法的参数传递机制

7.3.1 形参和实参

形参（formal parameter）：在定义方法时，方法名后面括号()中声明的变量称为形式参数，简称形参。
实参（actual parameter）：在调用方法时，方法名后面括号()中的使用的值/变量/表达式称为实际
参数，简称实参。

7.3.2 参数传递机制：值传递

Java里方法的参数传递方式只有一种： 值传递 。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

//栈：每个方法在调用时，都会有以栈帧的方法压入栈中。栈帧中保存了当前方法中声明的变量：方法内声明的，形参
//堆：存放new出来的"东西"：对象（成员变量在对象中）、数组实体（数组元素）。
//注意：变量前如果声明有类型，那么这就是一个新的刚要定义的变量。如果变量前没有声明类型，那就说明此变量在之前已经声明过。
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);
	}
	public void second(Value v, int i) {
		i = 0;
		v.i = 20;
		Value val = new Value();
		v = val;
		System.out.println(v.i + " " + i);
	}
}
class Value {
	int i = 15;
}

内存解析
在这里插入图片描述

7.4 递归(recursion)方法

递归方法调用：方法自己调用自己的现象就称为递归。
递归的分类:直接递归、间接递归。
直接递归：方法自身调用自己。

public void methodA(){
	methodA();
}

间接递归：可以理解为A()方法调用B()方法，B()方法调用C()方法，C()方法调用A()方法。

public static void A(){
	B();
}
public static void B(){
	C();
}
public static void C(){
	A();
}

说明：

递归方法包含了一种 隐式的循环 。
递归方法会 重复执行 某段代码，但这种重复执行无须循环控制。
递归一定要向 已知方向 递归，否则这种递归就变成了无穷递归，停不下来，类似于 死循环 。最终发生 栈内存溢出 。

注意：

递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的
多，所以在使用递归时要慎重。
在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存 。考虑使用循环迭
代

8. 关键字：package、import

8.1 package(包)

package，称为包，用于指明该文件中定义的类、接口等结构所在的包。

package 顶层包名.子包名 ;
//举例：pack1\pack2\PackageTest.java
package pack1.pack2; //指定类PackageTest属于包pack1.pack2
public class PackageTest{
	public void display(){
		System.out.println("in method display()");
	}
}

说明：

一个源文件只能有一个声明包的package语句
package语句作为Java源文件的第一条语句出现。若缺省该语句，则指定为无名包。
包名，属于标识符，满足标识符命名的规则和规范（全部小写）、见名知意
- 包通常使用所在公司域名的倒置：com.atguigu.xxx。
- 大家取包名时不要使用" java.xx "包
包对应于文件系统的目录，package语句中用 “.” 来指明包(目录)的层次，每.一次就表示一层文件目录。
同一个包下可以声明多个结构（类、接口），但是不能定义同名的结构（类、接口）。不同的包下可以定义同名的结构（类、接口）

8.1.1 包的作用

包可以包含类和子包，划分 项目层次 ，便于管理
帮助 管理大型软件 系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式
解决 类命名冲突 的问题
控制 访问权限

举例：MVC设计模式
MVC是一种软件构件模式，目的是为了降低程序开发中代码业务的耦合度。
MVC设计模式将整个程序分为三个层次： 视图模型(Viewer)层，控制器(Controller)层，与数据模型(Model)层 。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。
视图层viewer：显示数据,为用户提供使用界面，与用户直接进行交互。

相关工具类 view.utils
自定义view view.ui
控制层controller：解析用户请求，处理业务逻辑，给予用户响应
应用界面相关 controller.activity
存放fragment controller.fragment
显示列表的适配器 controller.adapter
服务相关的 controller.service
抽取的基类 controller.base
模型层model：主要承载数据、处理数据
数据对象封装 model.bean/domain
数据库操作类 model.dao
数据库 model.db

8.1.2 JDK中主要的包介绍

java.lang ----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread，提供常用功能
java.net ----包含执行与网络相关的操作的类和接口。 java.io ----包含能提供多种输入/输出功能的
类。
java.util ----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关
的函数。
java.text ----包含了一些java格式化相关的类
java.sql ----包含了java进行JDBC数据库编程的相关类/接口
java.awt ----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。

8.2 import(导入)

为了使用定义在其它包中的Java类，需用import语句来显式引入指定包下所需要的类。相当于 import语句告诉编译器到哪里去寻找这个类 。

import 包名.类名;
//举例
import pack1.pack2.Test; //import pack1.pack2.*;表示引入pack1.pack2包中的所有结构
public class PackTest{
	public static void main(String args[]){
		Test t = new Test(); //Test类在pack1.pack2包中定义
		t.display();
	}
}

注意事项

import语句，声明在包的声明和类的声明之间。
如果需要导入多个类或接口，那么就并列显式多个import语句即可
如果使用 a.* 导入结构，表示可以导入a包下的所有的结构。举例：可以使用java.util.*的方
一次性导入util包下所有的类或接口。
如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
如果已经导入java.a包下的类，那么如果需要使用a包的子包下的类的话，仍然需要导入。
如果在代码中使用不同包下的同名的类，那么就需要使用类的全类名的方式指明调用的是哪个类。
（了解） import static 组合的使用：调用指定类或接口下的静态的属性或方法

9. 面向对象特征一：封装性(encapsulation)

随着我们系统越来越复杂，类会越来越多，那么类之间的访问边界必须把握好，面向对象的开发原则要遵循“ 高内聚、低耦合 ”。

高内聚、低耦合是软件工程中的概念，也是UNIX 操作系统设计的经典原则。
内聚，指一个模块内各个元素彼此结合的紧密程度；耦合指一个软件结构内不同模块之间互连程度的度量。内聚意味着重用和独立，耦合意味着多米诺效应牵一发动全身。

而“高内聚，低耦合”的体现之一：
高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合 ：仅暴露少量的方法给外部使用，尽量方便外部调用。

9.1 Java如何实现数据封装

实现封装就是控制类或成员的可见性范围。这就需要依赖访问控制修饰符，也称为权限修饰符来控制。
权限修饰符： public 、 protected 、缺省、 private 。具体访问范围如下：
在这里插入图片描述
具体修饰的结构：

外部类：public、缺省
成员变量、成员方法、构造器、成员内部类：public、protected、缺省、private

9.2 封装性的体现

概述：私有化类的成员变量，提供公共的get和set方法，对外暴露获取和修改属性的功能。
成员变量封装的好处：

让使用者只能通过事先预定的方法来 访问数据 ，从而可以在该方法里面加入控制逻辑，限制对成员变量的不合理访问。还可以进行数据检查，从而有利于保证对象信息的完整性。
便于修改 ，提高代码的可维护性。主要说的是隐藏的部分，在内部修改了，如果其对外可以的访问方式不变的话，外部根本感觉不到它的修改。例如：Java8->Java9，String从char[]转为byte[]内部实现，而对外的方法不变，我们使用者根本感觉不到它内部的修改。

public class Person {
	private String name;
	private int age;
	private boolean marry;
	//提供 getXxx 方法 / setXxx 方法，可以访问成员变量
	public void setName(String n) {
		name = n;
	}
	public String getName() {
		return name;
	}
	public void setAge(int a) {
		age = a;
	}
	public int getAge() {
		return age;
	}

注意：

开发中，一般成员实例变量都习惯使用private修饰，再提供相应的public权限的get/set方法访问。
对于final的实例变量，不提供set()方法。（后面final关键字的时候讲）
对于static final的成员变量，习惯上使用public修饰。

10. 类的成员之三：构造器(Constructor)

我们new完对象时，所有成员变量都是默认值，如果我们需要赋别的值，需要挨个为它们再赋值，太麻烦了。我们能不能在new对象时，直接为当前对象的某个或所有成员变量直接赋值呢？
可以，Java给我们提供了 构造器（Constructor) ，也称为 构造方法 。
构造器的作用:
new对象，并在new对象的时候为实例变量赋值。
语法格式:

[修饰符] class 类名{
	[修饰符] 构造器名(){
		// 实例初始化代码
	}
	[修饰符] 构造器名(参数列表){
		// 实例初始化代码
	}
}

注意：

构造器名必须与它所在的类名必须相同。
它没有返回值，所以不需要返回值类型，也不需要void。
构造器的修饰符只能是权限修饰符，不能被其他任何修饰。比如，不能被static、final、
synchronized、abstract、native修饰，不能有return语句返回值。

public class Student {
	private String name;
	private int age;
	// 无参构造
	public Student() {}
	// 有参构造
	public Student(String n,int a) {
		name = n;
		age = a;
	}
}

使用说明：

当我们没有显式的声明类中的构造器时，系统会默认提供一个无参的构造器并且该构造器的修饰符默认与类的修饰符相同。
当我们显式的定义类的构造器以后，系统就不再提供默认的无参的构造器了。
在类中，至少会存在一个构造器。
构造器是可以重载的

11. 阶段性知识补充

类中属性赋值过程：
1、在类的属性中，可以有哪些位置给属性赋值？
① 默认初始化
② 显式初始化
③ 构造器中初始化
④ 通过"对象.属性"或"对象.方法"的方式，给属性赋值
这些位置执行的先后顺序是怎样？
顺序：① - ② - ③ - ④
说明：

上述中的①、②、③在对象创建过程中，只执行一次。
④ 是在对象创建后执行的，可以根据需求多次执行。

JavaBean：

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

好比你做了一个扳手，这个扳手会在很多地方被拿去用。这个扳手也提供多种功能(你可以拿
这个扳手扳、锤、撬等等)，而这个扳手就是一个组件。

所谓JavaBean，是指符合如下标准的Java类：

类是公共的
有一个无参的公共的构造器
有属性，且有对应的get、set方法

用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。
《Think in Java》中提到，JavaBean最初是为Java GUI的可视化编程实现的。你拖动IDE构建工具创建一个GUI 组件（如多选框），其实是工具给你创建Java类，并提供将类的属性暴露出来给你修改调整，将事件监听器暴露出来

UML类图：