JavaSE第07篇：面向对象之封装

Z时代
2024-01-10
分类：综合

面向对象是一种编程思想，是目前最主流、最有效地处理复杂业务逻辑的手段，而Java就是一门纯粹的面向对象编程语言。在Java中面向对象相关的概念有很多，比如：封装、继承、多态等。本篇我们将会开始面向对象编程的部分知识，其中主要有了解面向对象的概念、如何创建类和对象、理解封装、能写出一个标准类。

第一章：认识面向对象

1.1-面向对象概述（了解）

什么是面向对象？

面向对象是一种程序设计思想。

程序设计的目的是为了用编程解决现实问题，而面向对象编程的关键在于强调对象，用什么对象来完成什么功能。

在面向对象程序设计思想中，任何的事物都可以看作对象，也就是我们经常所说的“万物皆对象”（一部手机、一个人、一条狗等等都可以看做是对象）。

对象是由属性和方法组成的。

属性：对象的状态。

方法：对象的行为或功能。

比如：一个具体的人就可以看做对象

面向对象编程思想是什么？

面向对象编程思想就是，将真实世界的复杂关系，抽象为一个个对象，然后由对象之间的分工与合作，完成对真实世界的模拟。（总而言之，就是找对象做事儿）

真实世界的复杂关系：明确需求

抽象为一个个对象：划分对象

对象之间的分工与合作：
- 分工：对象的功能
- 合作： 对象之间的关系

面向对象的三大特征

封装：封装（encapsulation）就是隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读取和修改的访问级别。

继承: 继承（ inheritance）指的是子类与父类的关系，子类可以继承父类中的属性和方法

多态: 多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。

关于对象的三大特征，后续会一一逐渐展开讲解，本篇后续将会讲解封装。

1.2-如何创建和使用对象（记忆）

上述讲到，要面向对象编程，就得找对象做事儿。

找对象的前提，得先有对象。

现在没有对象怎么办？

那就得先创建对象，创建对象的规则，需要先知道类和对象的概念及关系。

类

类（class），是对现实生活中一类具有共同特征的事物的抽象描述。

比如，“狗”，“狗”是类，不是一个具体的对象，而是一个抽象的名称或概念，泛指世界上“会汪汪叫”、“对主人忠诚”、"会看家护院"、“爱啃骨头”、“有四条腿、两只眼睛、一个鼻子、两只耳朵等”具有这一系列特征的物种的称呼。

对象

对象，具有属性和方法的一个具体的实例。

类和对象的关系

类是对象的模板，可以用来描述对象的属性和方法。

对象是类的一个具体实例。对象属于类。

所以，要想创建和使用对象，必须先有类，再通过类创建对象。

定义类的格式

关键字：class

public class 类名 {
    // 成员变量-描述对象的属性
    // 成员方法-描述对象的方法(和之前定义方法不同的是，要去掉关键字static)
}

示例：

/* 定义类 */
public class Dog {
  // 成员变量
  String name;
  String type;
  String color;
  // 成员方法
  public void eat(){
    System.out.println("我喜欢啃骨头");
  }
  public void sound(){
    System.out.println("汪汪~~~");
  }
}

注意：类名单词的首字母要大写（比如：Dog）

创建对象格式

关键字：new

类名 对象名 = new 类名()

示例：

public class DogTest {
  public static void main(String[] args) {
    // 创建对象
    Dog wangCai = new Dog();
  }
}

使用对象

操作成员变量：

获取：对象名.成员变量

设置：对象名.成员变量=值

操作成员方法：

调用方法：对象名.成员方法()

示例：

public class DogTest {
  public static void main(String[] args) {
    // 创建对象
    Dog wangCai = new Dog();
    // 设置对象的属性-成员变量
    wangCai.name = "旺财";
    wangCai.color = "黄色";
    wangCai.type = "中华田园犬";
    // 读取对象的属性
    System.out.println("这一条狗的名字：" + wangCai.name);
    System.out.println("这一条狗狗的毛色：" + wangCai.color);
    System.out.println("这一条狗狗的种族：" + wangCai.type);
    // 调用对象的方法
    wangCai.eat();
    wangCai.sound();
  }
}

注意：

类是引用数据类型，而对象就是具体的数据。

对象的命名和变量命名规则一样。

1.3-成员变量的默认值是什么（了解）

1.4-成员变量和局部变量的区别（理解）

成员变量和局部变量

成员变量：定义在类中的方法外的变量。

局部变量：定义在类中的方法内 的变量或方法的参数（形参）。

区别

位置不同
- 成员变量，类中，方法外。
- 局部变量，类中，方法内

作用范围不同
- 成员变量，作用范围-类中。
- 局部变量，作用方法-方法中

默认值不同
- 成员变量，有默认值。
- 局部变量，没有默认值。并且，使用局部变量时，局部变量必须赋值，否则编译不通过。

内存位置不同
- 成员变量，堆区
- 局部变量，栈区

生命周期不同
- 成员变量，随着对象的创建而创建，随着对象的销毁而销毁。
- 局部变量，随着方法的调用而创建，随着方法调用完毕而销毁。

1.5-内存图解对象（理解）

一个对象创建并为属性赋值的内存图

Person类代码

public class Person {
  // 成员变量
  String name;
  int age;
  // 成员方法
  public void eat(){
    System.out.println("吃饭");
  }
}

PersonTest类代码

public class PersonTest {
  public static void main(String[] args) {
    Person zs = new Person();
    zs.name = "张三";
    zs.age = 10;
  }
}

内存图解：

总结：对象是引用数据类型

一个对象调用方法的内存图

Person类代码-同上

PersonTest类代码：

public class PersonTest {
  public static void main(String[] args) {
    Person zs = new Person();
    zs.name = "张三";
    zs.age = 10;
    // 调用方法
    zs.eat();
  }
}

内存图解：

总结：调用方法时，方法会入栈执行，执行完毕后会出栈。

两个对象调用方法的内存图

Person类代码-同上

PersonTest类代码：

public class PersonTest {
  public static void main(String[] args) {
    Person zs = new Person();
    zs.name = "张三";
    zs.age = 10;
    zs.eat();
    Person ls = new Person();
    ls.name = "李四";
    ls.age = 11;
    ls.eat();
  }
}

内存图解：

总结

new关键字创建对象时，都会独立开辟空间存放对象的信息。

所有对象的成员方法都是共享方法区中的class文件中的方法（节省内存）。

第二章：面向对象-封装

2.1-什么是封装（了解）

封装（encapsulation）就是 隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读取和修改的访问级别。

封装的可以让代码更加健壮且易于维护，提高程序的安全性。

2.2-如何实现封装（记忆）

首先，private 关键字修饰成员变量

private修饰的成员变量，仅能够在本类中使用。

格式：private 数据类型成员变量名;

然后，对外提供公开的 getXXX/setXXX 方法操作对象的属性

其中，this关键字，在方法中表示调用方法的对象（调用者）。

在方法中，this关键字可以区分成员变量和局部变量，若方法中有局部变量和成员变量同名，在方法中使用this关键字调用的变量就是成员变量。

public class Person {
  private String name;
  private int 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 static void main(String[] args) {
        Person zs = new Person();
        zs.name = "张三";  // 此时内部就会调用setName方法，setName方法中的this表示对象zs
        zs.age = 10;      
        Person ls = new Person();   
        ls.name = "李四";   // 此时内部就会调用setName方法，setName方法中的this表示对象ls
        ls.age = 11;
  }

总结：

封装概述是面向对象三大特征之一（封装，继承，多态）是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的。

封装原则将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的**getXxx()/setXxx()**方法

封装好处通过方法来控制成员变量的操作，提高了代码的安全性把代码用方法进行封装，提高了代码的复用性

2.3-封装优化-构造方法（记忆）

什么是构造方法-construction

构造方法的特点：

与类同名的方法

方法修饰没有返回值类型，没有void。

注意：类默认有一个无参的构造方法。构造方法可重载

public class Person{
	// 无参构造方法
    public Person(){
    }
}

构造方法的作用

创建对象。
- 创建对象时，会默认调用类的无参构造方法。

初始化对象的属性值。
- 可以定义带参数构造方法初始化对象属性

代码：Person类

public class Person {
  private String name;
  private int age;
  // 无参数构造方法
  public Person() {
  }
  // 有参数构造方法
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  public void show(){
    System.out.println("姓名：" + this.name);
    System.out.println("年龄：" + this.age);
  }
}

代码：测试类

public class PersonTest {
  public static void main(String[] args) {
    // 【调用无参构造方法】
    Person zs = new Person();
    zs.name = "张三";
    zs.age = 10；
    zs.show(); // 打印结果：姓名：张三  年龄：10
    // 【调用有参构造方法】
    Person ls = new Person("李四",12);
    ls.show(); // 打印结果：姓名：李四 年龄：12
  }
}

构造方法注意事项

构造方法的创建
- 如果没有定义构造方法，系统将给出一个默认的无参数构造方法
- 如果定义了构造方法，系统将不再提供默认的构造方法

构造方法的重载
- 如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

推荐的使用方式
- 无论是否使用，都手工书写无参数构造方法

重要功能！
- 可以使用带参构造，为成员变量进行初始化

2.4-JavaBean （了解）

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

	public class 类名 {
        // 成员变量
        // 无参构造方法【必须】
        // 有参构造方法
        // get/set方法
        // 成员方法
	}

以上是 JavaSE第07篇：面向对象之封装的全部内容，来源链接： utcz.com/z/518524.html

JavaSE第07篇：面向对象之封装

第一章：认识面向对象

1.1-面向对象概述（了解）

1.2-如何创建和使用对象（记忆）

1.3-成员变量的默认值是什么（了解）

1.4-成员变量和局部变量的区别（理解）

1.5-内存图解对象（理解）

第二章：面向对象-封装

2.1-什么是封装 （了解）

2.2-如何实现封装（记忆）

2.3-封装优化-构造方法（记忆）

2.4-JavaBean （了解）

其他人也看了：

2.1-什么是封装（了解）