封装

封装是什么呢

在面向对象程序设计中，封装是指将数据和操作数据的方法绑定在一起，并将这些绑定在一起的数据和方法封装在一个对象中。封装的目的是隐藏对象内部的实现细节，只向外界提供必要的接口，从而提高程序的复用性和可维护性

封装的好处

  • 隐藏对象内部的实现细节，只提供必要的接口，使程序更加容易使用和维护。
  • 提高程序的复用性。封装可以将一个对象的实现细节与它的外部接口分开，从而使得一个对象可以被多个程序使用。
  • 提高程序的安全性。封装可以让程序员在设计对象时更加注重数据的安全性，而不用担心外部的程序会破坏对象的内部数据。
  • 提高程序的可维护性。封装可以使程序员在修改对象内部实现时不用担心会影响到外部的程序，这样可以极大地提高程序的可维护性。

封装的步骤

  1. 修改属性的可见性来限制对属性的访问（一般限制为private）
  2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package com.base.learn;

/**
 * 客户信息类
 *
 */
public class Customer {
    private String name; // 名字
    private char gender; // 性别
    private int age; // 年龄
    private String phone; // 手机号
    private String email; // 电子邮箱

    public Customer() {
    }

    public Customer(String name, char gender, int age, String phone, String email) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.phone = phone;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

注：采用 this 关键字调用本类中的属性，也就是类中成员变量，主要是为了解决实例变量和局部变量之间发生的命名冲突

JavaBean

Java 中的封装是面向对象编程的一个基本概念，指的是将数据和操作数据的方法绑定在一起，并将这些绑定在一起的数据和方法封装在一个对象中。

JavaBean 是 Java 语言中的一种命名约定，它将一个 Java 类定义为一个可重用的组件。JavaBean 遵循 Java 中的封装思想，但是它还要满足一些特定的要求，比如必须提供一个无参的构造函数，必须提供用于访问私有属性的 getter 和 setter 方法等。所以，JavaBean 是 Java 中的封装的一种具体实现，它为 Java 中的封装提供了一种标准的方式。

小结

封装实际上是将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的访问和操作。就是把我们想提供给外界的一些方法给暴露出来，以便外界能调用到我们。

继承

继承的介绍

  • 继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。描述的是事物之间的所属关系，这种关系是：is-a 的关系。
  • 继承：就是子类继承父类的 属性 和 行为 ，使得子类对象（实例）可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的 非私有 的属性和行为。

生活中的继承

继承的好处

  • 提高代码的重用性。继承可以使一个类获得另一个类的属性和方法，从而减少重复的代码，提高代码的重用性。
  • 提高代码的可维护性。通过继承，可以将一些公共的属性和方法抽取到基类中，从而提高代码的可维护性。
  • 提高代码的可扩展性。继承可以使一个类在不改变原有代码的情况下扩展新的属性和方法，从而提高代码的可扩展性。
  • 提高代码的可读性。通过继承，可以让类与类之间建立一种父子关系，使得代码的结构更加清晰，更加容易理解。

其它

  • Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

继承的格式

在Java当中会通过extends关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

1
2
3
4
5
class 父类 {
}

class 子类 extends 父类 {
}

需要注意一点： Java 不支持多继承，但支持多重继承。就如下：

1
2
3
4
5
6
7
8
9
10
11
class A {
}
 
class B extends A {   (对的)
}

class C extends A, B {  （错的❌）
}

class C extends B {   （对的）
}

顶层父类是Object类。所有的类默认继承Object，作为父类

继承 Demo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.base.exer1;

public class Person {
    String name;
    private int age;

    public Person() {
    }

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

    public void eat() {
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉");
    }

    public int getAge() {
        return age;
    }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.base.exer1;

public class Student extends Person {
    String major;

    public Student() {
    }

    public Student(String name, int age, String major) {
        this.name = name;
        setAge(age);
        this.major = major;
    }

    public void study() {
        System.out.println("学习");
    }

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

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package com.base.exer1;

/*
 * 面向对象的特征二:继承性
 * 
 * 为什么要有继承？
 * 		多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，
 * 		那么多个类无需再定义这些属性和行为，只要继承那个类即可。
 * 一、继承性的好处
 * ① 减少了代码的冗余，提高了代码的复用性；
 * ② 便于功能的扩展；
 * ③ 为之后多态性的使用，提供了前提。
 * 
 * 二、继承性的格式
 * 	class A extends B{}
 *  A:子类、派生类、subclass
 *  B:父类、超类、基类、superclass
 *  
 *  2.1 体现：一旦子类 A 继承父类以后，子类 A 中就获取了父类 B 中声明的结构：属性、方法
 * 		特别的，父类中声明为 private 的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。
 * 		只有因为封装性的影响，使得子类不能直接调用父类的结构而已。
 *  2.2 子类继承父类以后，还可以声明自己特有的属性或方法，实现功能的拓展。
 *  	子类和父类的关系：不同于子集与集合的关系。
 *  	extends:延展、扩展
 *
 * 三、Java 中关于继承性的规定：
 *  	1.一个类可以被多个类继承
 *  	2.Java 中类的单继承性：一个类只能有一个父类
 *  	3.子父类是相对的概念。
 *  	4.子类直接继承的父类，称为：直接父类。间接继承的父类，称为，间接父类。
 *  	5.子类继承父类后，就获取了直接父类以及所有间接父类中声明的属性和方法。
 * 	
 * 四、1.如果我们没有显式的声明一个类的父类的话，则此类继承于 java.lang.Object 类
 * 	  2.所有的 java 类(除 java.long.Object 类之外)都直接或间接地继承于 java.lang.Object 类;
 * 	  3.意味着，所有的 java 类具有 java.lang.Object 类声明的功能。
 */
public class ExtendsTest {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.eat(); // 吃饭
        System.out.println("---------------");

        Student s1 = new Student();
        s1.eat();
        s1.sleep();
        s1.name = "Tom";

        s1.setAge(10);
        System.out.println(s1.getAge());
    }
}

继承的规则

并不是父类的所有内容都可以给自类继承

子类不能直接访问父类中私有的（private）的成员变量和方法

supper 关键字

跟继承有关系，这里单独开写一篇内容，介绍 super 关键字的使用

final 关键字

final 关键字修饰的类，不能被继承，这里也单独一篇内容，介绍 final 关键字