类与对象、封装、构造⽅法

类与对象

⾯向对象思想：

Java 语⾔是⼀种⾯向对象的程序设计语⾔，⽽⾯向对象思想是⼀种程序设计思想，我们在⾯向对

象思想的指引下，使⽤ Java 语⾔去设计、开发计算机程序。这⾥的 对象 泛指现实中⼀切事物，每

种事物都具备⾃⼰的 属性和⾏为 。⾯向对象思想就是在计算机程序设计过程中，参照现实中事

物，将事物的属性特征、⾏为特征抽象出来，描述成计算机事件的设计思想。它区别于⾯向过程

思想，强调的是通过调⽤对象的⾏为来实现功能，⽽不是⾃⼰⼀步⼀步的去操作实现。

举例

洗⾐服：

⾯向过程：把⾐服脱下来 -> 找⼀个盆 -> 放点洗⾐粉 -> 加点⽔ -> 浸泡 10 分钟 -> 揉⼀揉 ->

清洗⾐服 -> 拧⼲ -> 晾起来

⾯向对象：把⾐服脱下来 -> 打开全⾃动洗⾐机 -> 扔⾐服 -> 按钮 -> 晾起来

区别：

⾯向过程：强调步骤。

⾯向对象：强调对象，这⾥的对象就是洗⾐机。

⾯向对象的语⾔中，包含了三⼤基本特征，即封装、继承和多态。

什么是类

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

为特征来描述该类事物。

现实中，描述⼀类事物：

属性：就是该事物的状态信息。

⾏为：就是该事物能够做什么。

举例：⼩猫。

属性：名字、体重、年龄、颜⾊。

⾏为：⾛、跑、叫。

什么是对象

对象： 是⼀类事物的具体体现。对象是类的⼀个 实例 （对象并不是找个⼥朋友），必然具备

该类事物的属性和⾏为。

现实中，⼀类事物的⼀个实例。

举例：⼀只⼩猫。

属性： tom 、 5kg 、 2 years 、 yellow 。

⾏为：溜墙根⾛、蹦跶的跑、喵喵叫。

类与对象的关系：

类是对⼀类事物的描述，是 抽象的 。

对象是⼀类事物的实例，是 具体的 。

类是对象的模板，对象是类的实体 。

类的定义 ：

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

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

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

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

定义类： 就是定义类的成员，包括 成员变量 和 成员⽅法 。

成员变量： 和以前定义变量⼏乎是⼀样的。只不过位置发⽣了改变。 在类中，⽅法外 。

成员⽅法： 和以前定义⽅法⼏乎是⼀样的。只不过把 static去掉。

类的定义格式举例：

public class Student {
 // 成员变量
 String name; // 姓名
 int age; // 年龄
 // 成员⽅法
 // 学习的⽅法
 publicvoid study() {
System.out.println("好好学习，天天向上");
 }
 // 吃饭的⽅法
 publicvoid eat() {
 System.out.println("学习饿了要吃饭");
 }
}

对象的使⽤：

创建对象：

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

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

对象名 . 成员变量 ;

对象名 . 成员⽅法 ();

对象的使⽤格式举例：

public class Test01_Student {
 public static void main(String[] args) {
 // 创建对象格式:类名 对象名 = new 类名();
 Student s = new Student();
 System.out.println(" s: " + s); // com.bonnie.Student@100363
 
 // 直接输出成员变量值
 System.out.println("姓名:" + s.name); // null
 System.out.println("年龄:" + s.age); // 0
 System.out.println("----------");
 // 给成员变量赋值
 s.name = "李发鬓";
 s.age = 18;
 // 再次输出成员变量的值
 System.out.println("姓名:" + s.name); // 李发鬓
 System.out.println("年龄:" + s.age); // 18
 System.out.println("----------");
 // 调⽤成员⽅法
 s.study(); // "好好学习，天天向上"
s.eat(); // "学习饿了要吃饭"
 }
}

成员变量的默认值

 练习：

定义⼿机类：

public class Phone {
 // 成员变量
String brand; // 品牌
 int price; // 价格
 String color; // 颜⾊
 // 成员⽅法
// 打电话
public void call(String name) {
 System.out.println("给" + name + "打电话");
 }
 // 发短信
 public void sendMessage() {
 System.out.println("群发短信");
 }
}

 定义测试类：

public class Test02Phone {
 public static void main(String[] args) {
 // 创建对象
 Phone p = new Phone();
// 输出成员变量值
 System.out.println("品牌:" + p.brand); // null
 System.out.println("价格:" + p.price); // 0
 System.out.println("颜⾊:" + p.color); // null
 System.out.println("------------");
 
 // 给成员变量赋值
 p.brand = "锤子";
 p.price = 2999;
 p.color = "棕色";
 
 // 再次输出成员变量值
 System.out.println("品牌:" + p.brand); // 锤子
 System.out.println("价格:" + p.price); // 2999
 System.out.println("颜⾊:" + p.color); // 棕色
 System.out.println("------------");
 
 // 调⽤成员⽅法
 p.call("杨洋");
 p.sendMessage();
  }
 }

对象内存图

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

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

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

成员变量和局部变量区别

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

1.在类中的位置不同 

成员变量：类中，⽅法外

局部变量：⽅法中或者⽅法声明上（形式参数）

2.作⽤范围不⼀样 

成员变量：类中

局部变量：⽅法中

3,。初始化值的不同 

成员变量：有默认值

局部变量：没有默认值。必须先定义，赋值，最后使⽤

4.在内存中的位置不同 

成员变量：堆内存

局部变量：栈内存

5.⽣命周期不同 

成员变量：随着对象的创建⽽存在，随着对象的消失⽽消失

局部变量：随着⽅法的调⽤⽽存在，随着⽅法的调⽤完毕⽽消失

封装：

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

原则：

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

封装的步骤

1. 使⽤ private 关键字来修饰成员变量。

2. 对需要访问的成员变量，提供对应的⼀对 getXxx ⽅法、 setXxx ⽅法。

封装的操作 -- 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;
 } 
}

封装优化 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;
 }
}

封装优化 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. 构造⽅法是可以重载的，既可以定义参数，也可以不定义参数。

标准代码 -- 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());
 }
}

构造方法

 构造方法语法结构

构造方法是在类中定义的方法，不同于其他的方法，构造方法的定义有如下两个规则：

• 构造方法的名称必须与类名相同。
• 构造方法没有返回值，但也不能写void。

语法：

[访问修饰符] 类名( ) {

      // 构造方法体

}

 通过构造方法初始化成员变量

构造方法常用于实现对象成员变量的初始化。

 this关键字的使用 

this关键字用在方法体中，用于指向调用该方法的当前对象；简单的说：哪个对象调用方法，this指的就是哪个对象。严格来讲在方法中需要通过this关键字指明当前对象。

例如：

为了方便起见，在没有歧义的情况下可以省略this：

在构造方法中，用来初始化成员变量的参数一般和成员变量取相同的名字，这样会有利于代码的可读性，但此处就必须通过this关键字来区分成员变量和参数了（不能省略this）。例如：

 默认构造方法

 构造方法的重载