面向对象的特性

• 面向对线三大特性：封装

封装：

在Java中，{ } 就是封装。

类是对大量对象进行抽象，抽象出相同的属性和方法，将属性和方法封装形成类。
方法是对代码的封装。

封装的好处：

1. 隐藏代码细节。使用方法时，只关心格式和作用，不关心代码实现。
2. 模块化开发。

---

• 面向对线三大特性：继承

--------继承就是一个关键字：extends

继承的格式：

继承一定是两个类之间的关系。

public class 子类 extends 父类{}

在 Java 中只支持单继承。一个类只能有一个直接父类。

继承之后的好处：

子类可以使用父类的属性和方法。

PS：子类可以使用父类的所有属性和方法。只不过，当属性使用 private 修饰时，表示私有。父类中声明的私有属性和方法，可以继承但不能使用。

继承关系的实现方式是什么：

在 Java 中继承关系的实现方式：是为每一个子类实例配置一个其父类实例。

并使用 super 这个引用，从子类实例中指向父类实例。

创建两个实例的先后顺序：

根据上图我们可以发现，创建子类实例时，也一定会创建一个父类实例。

实例的创建过程，一定要调用类的构造方法。

父类与子类之间的实例的创建顺序： 先创建好父类实例，再创建好子类实例。

父类与子类的构造方法的调用顺序： 先调用子类构造方法，在子类构造方法的第一行，调用父类构造方法。

public class A {
    private int i;
    public A() {
        System.out.println("A类默认构造方法！");
    }
    public void print(){
        System.out.println("A.print()");
    }
}

public class B extends A{
    public B() {
        System.out.println("B类默认构造方法！");
    }
    public static void main(String[] args) {
        B b = new B();
        b.print();//调用父类的方法。
    }
}

A类默认构造方法！
B类默认构造方法！
A.print()

---

• this 和 super 关键字

this 是一个在实例内部指向其自身实例的引用。

super 是一个在子类实例内部指向其父类实例的引用。

this： 三种用法

1. this() ----在构造方法内部引用自身其他构造方法的格式。
2. this.属性 ----调用自身属性的格式。
3. this.方法() ----调用自身方法的格式。

super： 三种用法

1. super() ----在子类构造方法的第一行，调用父类构造方法的格式。
2. super.属性 ----调用父类属性的格式。
3. super.方法() ----调用父类方法的格式。

---

• 方法重写

方法重写：在父类与子类有相同的方法，这个方法就叫方法重写。

public class A {
    public void print(){
        System.out.println("A.print()");
    }
}

public class B extends A{
	@Override
    public void print(){
        System.out.println("B.print()");
    }
}

---

• 面向对象语言三大特性：继承（软件工程）

父类是怎么来的？

类是对大量对象的抽象。

父类对大量子类的抽象。抽的是相同的属性和方法。

父类中保存了所有子类共性的属性和方法。

子类中自己的特性的属性和方法。

父类更通用。子类更具体。

什么样的二个类可以继承：

判断条件是 ： is-a 是一个。
必须满足 子类 是 一个父类。 子类 is-a 父类

类与类之间的关系（扩展）： 类与类之间的关系。

1. is-a 是一个 继承 子类是一个父类
2. has-a 有一个 组合 类的属性
3. use-a 用一个 依赖 方法的参数

---

什么时候用方法重写:

当发现从父类继承的方法，在子类中不适用时。就可以在子类中对这个方法进行重写操作。

为什么要继承和方法重写:

在面向对象语言特性中：封装，继承，多态是三大特性。
其中封装和继承都是为了实现多态服务的。

封装的目的是为了能获到类，属性，方法。

继承的目的是在不修改源文件的情况下，可以实现对功能的修改。
依据"开放－封闭"原则：对扩展开放，对修改关闭。

所以当有一个类，中的方法需要进行更新时。我们应该扩展一个子类。在子类中重写这个方法。

继承和方法重写真正的目的是在不修改源文件的情况，扩展一个子类，实现对父类的修改。

面向对象的最后一个特性叫多态。使用多态可以实现所有使用父类的位置，都可以用子类对象替换。