JavaSE个人复习式整理知识点之面向对象一（类与对象、封装、构造方法）

1 ⾯向对象思想

1.1 ⾯向对象思想概述

概述

Java语⾔是⼀种⾯向对象的程序设计语⾔，⽽⾯向对象思想是⼀种程序设计思想，我们在⾯向对
象思想的指引下，使⽤Java语⾔去设计、开发计算机程序。这⾥的对象泛指现实中⼀切事物，每
种事物都具备⾃⼰的属性和⾏为。⾯向对象思想就是在计算机程序设计过程中，参照现实中事
物，将事物的属性特征、⾏为特征抽象出来，描述成计算机事件的设计思想。它区别于⾯向过程
思想，强调的是通过调⽤对象的⾏为来实现功能，⽽不是⾃⼰⼀步⼀步的去操作实现。

特点

• ⾯向对象思想是⼀种更符合我们思考习惯的思想，它可以将复杂的事情简单化
• ⾯向对象的语⾔中，包含了四⼤基本特征，即封装、继承、多态和抽象。

1.2 类和对象

什么是类

• 类： 是⼀组相关属性和⾏为的集合。可以看成是⼀类事物的模板，使⽤事物的属性特征和⾏为特征来描述该类事物。

现实中，描述⼀类事物：

• 属性： 就是该事物的状态信息。
• ⾏为： 就是该事物能够做什么。

什么是对象

对象： 是⼀类事物的具体体现。对象是类的⼀个实例，必然具备该类事物的属性和⾏为。
现实中，⼀类事物的⼀个实例。

类与对象的关系

• 类是对⼀类事物的描述，是抽象的。
• 对象是⼀类事物的实例，是具体的。
• 类是对象的模板，对象是类的实体。

1.3 类的定义

事物与类的对⽐

现实世界的⼀类事物：

属性： 事物的状态信息。⾏为： 事物能够做什么。

Java中⽤class描述事物也是如此：

成员变量： 对应事物的属性。成员⽅法： 对应事物的⾏为

类的定义格式

public class ClassName {
// 成员变量
// 成员⽅法
}

• 定义类：即定义类的成员，包括成员变量和成员⽅法。
• 成员变量：和往篇文章中定义变量⼏乎是⼀样的。但位置发⽣了改变。在类中，⽅法外。
• 成员⽅法：和往篇文章中定义⽅法⼏乎是⼀样的。但得把static去掉，static的作⽤将在后续文章详细梳理

类的定义格式举例：

public class Student {
// 成员变量
String name; 
int age; 
// 成员⽅法
publicvoid study() {
	System.out.println("这是一个成员方法");
}
}

1.4 对象的使⽤

对象的使⽤格式

创建对象：

类名 对象名 = new 类名();

使⽤对象访问类中的成员：

对象名.成员变量;
对象名.成员⽅法();

对象的使⽤格式举例：

public class Person{
    public String name;// 定义成员变量
    public int age;

    public void print(String name, int age){ // 定义成员方法
        System.out.println("我叫" + name + "今年" + age + "岁");
    }

    public static void main(String[] args) {
        // 创建对象格式:类名 对象名 = new 类名();
        Person person = new Person();
        // 调用并输出成员变量
        System.out.println(person.name);// null
        System.out.println(person.age);// 0
        // 调用成员方法并传进参数
        person.print("张三", 18);// 我叫张三今年18岁
    }
}

成员变量的默认值

相比于方法内定义内的局部变量必须初始化才能使用，成员变量却有默认值并无需赋值即可使用

	数据类型	默认值
基本类型	整数（byte，short，int，long）	0
	浮点数（float，double）	0.0
	字符（char）	'\u0000'
	布尔（boolean）	false
引用类型	数组、类、接口	null

1.6 对象内存图

⼀个对象，调⽤⼀个⽅法内存图

通过上图，我们可以理解，在栈内存中运⾏的⽅法，遵循"先进后出，后进先出"的原则。变量p指向堆内存中的空间，寻找⽅法信息，去执⾏该⽅法。但是，这⾥依然有问题存在。创建多个对象时，如果每个对象内部都保存⼀份⽅法信息，这就⾮常浪费内存了，因为所有对象的⽅法信息都是⼀样的。那么如何解决这个问题呢？请看如下图解。

两个对象，调⽤同⼀⽅法内存图

对象调⽤⽅法时，根据对象中⽅法标记（地址值），去类中寻找⽅法信息。这样哪怕是多个对象，⽅法信息只保存⼀份，节约内存空间。

⼀个引⽤，作为参数传递到⽅法中内存图

引⽤类型作为参数，传递的是地址值。

1.7 成员变量和局部变量区别

变量根据定义位置的不同，我们给变量起了不同的名字。如下图所示：

• 在类中的位置不同 重点
  • 成员变量：类中，⽅法外
  • 局部变量：⽅法中或者⽅法声明上（形式参数）
• 作⽤范围不⼀样 重点
  • 成员变量：类中
  • 局部变量：⽅法中
• 初始化值的不同 重点
  • 成员变量：有默认值
  • 局部变量：没有默认值。必须先定义，赋值，最后使⽤
• 在内存中的位置不同 了解
  • 成员变量：堆内存
  • 局部变量：栈内存
• ⽣命周期不同 了解
  • 成员变量：随着对象的创建⽽存在，随着对象的消失⽽消失
  • 局部变量：随着⽅法的调⽤⽽存在，随着⽅法的调⽤完毕⽽消失

2 封装

2.1 封装概述

概述

⾯向对象编程语⾔是对客观世界的模拟，客观世界⾥成员变量都是隐藏在对象内部的，外界⽆法直接操作和修改。封装可以被认为是⼀个保护屏障，防⽌该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的⽅式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

原则

将属性隐藏起来，若需要访问某个属性，提供公共⽅法对其访问。

2.2 封装的步骤

1. 使⽤ private 关键字来修饰成员变量。
2. 对需要访问的成员变量，提供对应的⼀对 getXxx ⽅法、 setXxx ⽅法。

2.3 封装的操作 – private关键字

private的含义

1. private是⼀个权限修饰符，代表最⼩权限。
2. 可以修饰成员变量和成员⽅法。
3. 被private修饰后的成员变量和成员⽅法，只在本类中才能访问。

private的使⽤格式

private 数据类型 变量名;

1.使⽤ private 修饰成员变量，代码如下：

public class Student {
	private String name;
	private int age; 
}

2.提供 getXxx ⽅法 / setXxx ⽅法，可以访问成员变量，代码如下：

public class Student {
private String name;
private int age;
public void setName(String n) {
	name = n; 
 }
public String getName() {
	return name; 
 }
public void setAge(int a) {
	age = a; 
 }
public int getAge() {
	return age; 
 }
}

2.4 封装优化1 – this关键字

我们发现 setXxx ⽅法中的形参名字并不符合⻅名知意的规定，那么如果修改与成员变量名⼀致，是否就⻅名知意了呢？代码如下：

public class Student {
private String name;
private int age;
public void setName(String name) {
	name = name;
 }
public void setAge(int age) {
	age = age; 
 } 
}

经过修改和测试，我们发现新的问题，成员变量赋值失败了。也就是说，在修改了 setXxx() 的形参变量名后，⽅法并没有给成员变量赋值！这是由于形参变量名与成员变量名重名，导致成员变量名被隐藏，⽅法中的变量名，⽆法访问到成员变量，从⽽赋值失败。所以，我们只能使⽤this关键字，来解决这个重名问题。

this的含义

this代表所在类的当前对象的引⽤（地址值），即对象⾃⼰的引⽤。

记住：⽅法被哪个对象调⽤，⽅法中的this就代表那个对象。即谁在调⽤，this就代表谁。

this使⽤格式

this.成员变量名;

使⽤ this 修饰⽅法中的变量，解决成员变量被隐藏的问题，代码如下：

public class Student {
private String name;
private int age;
public void setName(String name) {
	// name = name;
	this.name = name; 
 }
public String getName() {
	return name; 
 }
public void setAge(int age) {
	// age = age;
	this.age = age; 
 }
public int getAge() {
	return age;
 }
}

⽅法中只有⼀个变量名时，默认也是使⽤ this 修饰，可以省略不写。

2.5 封装优化2 – 构造⽅法

⼩贴⼠：⽆论你与否⾃定义构造⽅法，所有的类都有构造⽅法，因为Java⾃动提供了⼀个⽆参数构造⽅法，⼀旦⾃⼰定义了构造⽅法，Java⾃动提供的默认⽆参数构造⽅法就会失效。

构造⽅法的定义格式

修饰符 构造⽅法名(参数列表) {
	// ⽅法体
}

构造⽅法的写法上，⽅法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚⾄不需要void。使⽤构造⽅法后，代码如下：

public class Student {
private String name;
private int age;
// ⽆参数构造⽅法
public Student() {

 }
// 有参数构造⽅法
public Student(String name,int age) {
	this.name = name;
	this.age = age;
 }
}

注意事项

1. 如果你不提供构造⽅法，系统会给出⽆参数构造⽅法。
2. 如果你提供了构造⽅法，系统将不再提供⽆参数构造⽅法。
3. 构造⽅法是可以重载的，既可以定义参数，也可以不定义参数。

2.6 标准代码 – JavaBean

JavaBean 是 Java语⾔编写类的⼀种标准规范。符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有⽆参数的构造⽅法，提供⽤来操作成员变量的 set 和 get ⽅法。

public class ClassName {
	// 成员变量
	// 构造⽅法
	// ⽆参构造⽅法【必须】
	// 有参构造⽅法【建议】
	// 成员⽅法
	// getXxx()
	// setXxx()
}

编写符合 JavaBean 规范的类，以学⽣类为例，标准代码如下：

public class Student {
// 成员变量
private String name;
private int age;
// 构造⽅法
public Student() {

 }
public Student(String name,int age) {
	this.name = name;
	this.age = age; 
 }
// 成员⽅法
public void setName(String name) {
	this.name = name;
 }
public String getName() {
	return name; 
 }
public void setAge(int age) {
	this.age = age; 
 }
public int getAge() {
	return age;
 }
}

测试类，代码如下:

public class TestStudent {
 public static void main(String[] args) {
	// ⽆参构造使⽤
	Student s = new Student();
	s.setName("张三");
	s.setAge(18);
	System.out.println(s.getName() + "---" + s.getAge());
	// 带参构造使⽤
	Student s2 = new Student("王五", 18);
	System.out.println(s2.getName() + "---" + s2.getAge());
 }
}