Java基础篇——面向对象之三大基本特征

目录

1、面向对象思想

1.1、面向对象定义

1.2、面向对象与面向过程的区别

1.3、类和对象

2、三大基本特征

2.1、封装

2.2、继承

2.3、多态

多态优点：

多态存在三个必要条件：

3、补充：抽象

---

Java 是面向对象的高级编程语言，类和对象是 Java 程序的构成核心。围绕着 Java 类和 Java 对象，有三大基本特性：封装、继承、多态。封装是 Java 类的编写规范，继承是类与类之间联系的一种形式，而多态为系统组件或模块之间解耦提供了解决方案。 

1、面向对象思想

面向对象编程是当今主流的程序设计思想，已经取代了过程化程序开发技术，Java 是完全面向对象编程语言，所以必须熟悉面向对象才能够编写Java 程序。

面向对象思想认为：现实世界是由对象组成的，无论大到一个国家还是小到一个原子，都是如此。并且对象都由两部分组成 - 描述对象状态或属性的数据（变量）以及描述对象行为或者功能的方法（函数）。并且与面向过程不同，面向对象是将数据和操作数据的函数紧密结合，共同构成对象来更加精确地描述现实世界，这是面向过程和面向对象两者最本质的区别。

1.1、面向对象定义

面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物，这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想就是面向对象。

1.2、面向对象与面向过程的区别

提到面向对象，不免会想到面向过程，那么什么是面向过程呢？

“面向过程”(Procedure Oriented)是一种以过程为中心的编程思想。由一系列要执行的计算步骤组成，需要一步一步的实现，通常采用自上而下、顺序执行的方式。

面向过程：侧重整个问题的解决步骤，着眼局部或者具体。

• 优点：性能比面向对象高，因为面向对象类调用时需要实例化，开销比较大，比较消耗资源。比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
• 缺点：没有面向对象易维护、易复用、易扩展。

面向对象：侧重具体的功能，让某个对象具有这样的功能。更加侧重于整体。

• 优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护 。
• 缺点：性能比面向过程低。

1.3、类和对象

面向对象编程的核心是对象，对象与类又是不可分割的，下面看一下二者之间的关系。

类：

对某类事物的普遍一致性特征、功能的抽象、描述和封装。是一类事物抽象的概念集合，表示的是一个共性的产物，是构造对象的模版或蓝图。类之中定义的是属性和行为（方法）。

对象：

对象是类的实例，是一个个体。使用 new 关键字或反射技术创建的某个类的实例。同一个类的所有对象，都具有相似的属性（比如人的年龄、性别）和行为（比如人的吃饭、睡觉），但是每个对象都保存着自己独特的状态，对象状态会随着程序的运行而发生改变，需要注意状态的变化必须通过调用方法来改变，这就是封装的基本原则。

2、三大基本特征

2.1、封装

封装是面向对象最基本的特征之一，是类和对象概念的主要特性。隐藏对象的属性和实现细节，仅对外暴露公共的访问方式。

通过封装，我们可以将现实世界中的数据和对数据进行操作的动作捆绑在一起形成类，然后再通过类定义对象，很好地实现了对现实世界事物的抽象和描述。

封装的优点：

1. 隐藏信息和细节，提高安全性
2. 良好的封装可以减少耦合性，提高复用性
3. 对类内部结构可以随意修改，只要保证公有接口始终返回正确的结果即可。
4. 可以对成员变量进行更精确的控制。

封装是通过权限修饰符实现的，在一个类中不同的权限修饰符修饰的属性和方法，对其他类的对象来说有不同的访问权限。访问权限修饰符有四类：public、protected、private、default(默认，在没有修饰符的情况下)。

访问修饰符权限

修饰符	本类	本包	子类	外部包非子类
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

2.2、继承

继承性主要描述的是类与类之间的关系，通过继承，从已有的类中派生出新的类，新类包含已有类的数据属性和行为，并能扩展新的能力，提高了程序的复用性、扩展性，也是 Java 语言多态特征的前提。

继承的原则：

1. Java 的继承机制是单继承，即一个类只能有一个直接父类。
2. 被继承的类叫父类（超类），继承父类的类叫子类（派生类）。
3. 如果子类和父类有同名成员变量和方法，子类可以使用 super 关键字调用父类的成员变量和方法，上述使用方式前提是成员在子类可见。
4. 在调用子类构造方法时，会隐式的调用父类的构造方法 super()。如果父类没有无参构造方法，为了避免编译错误，需要在子类构造方法中显式的调用父类的含参构造方法，并且只能放在代码的第一句。
5. 子类创建时调用父类构造方法：子类需要使用父类的成员变量和方法，所以就要调用父类构造方法来初始化，之后再进行子类成员变量和方法的初始化。因此，构造方法是无法覆盖（重写）的。
6. 当子类需要扩展父类的某个方法时，可以重写父类方法，但是子类方法访问权限必须大于或等于父类权限。

继承的优缺点：

优点：提高代码的复用性；提高代码的维护性；让类与类之间产生关系，是多态的前提。
缺点：增强了类与类之间的耦合性 。

2.3、多态

多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

多态优点：

• 消除类型之间的耦合关系
• 可替换性
• 可扩充性
• 接口性
• 灵活性
• 简化性

多态存在三个必要条件：

• 继承：在多态中必须存在有继承关系的子类和父类。
• 重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
• 向上转型（父类引用指向子类对象）：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

注意：

指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用） 

向上转型后概括为两点：

• 子类丢失自己独有的方法
• 如果子类重写了父类的方法，使用子类的方法，否则使用父类方法

重写示例： 

public class TestMain {
    public static void main(String[] args) {
        show(new Cat());  // 以 Cat 对象调用 show 方法
        show(new Dog());  // 以 Dog 对象调用 show 方法

        Animal a = new Cat();  // 向上转型
        a.eat();               // 调用的是 Cat 的 eat
        Cat c = (Cat)a;        // 向下转型
        c.work();        // 调用的是 Cat 的 work
    }

    public static void show(Animal a)  {
        a.eat();
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情
            Cat c = (Cat)a;
            c.work();
        } else if (a instanceof Dog) { // 狗做的事情
            Dog c = (Dog)a;
            c.work();
        }
    }
}

abstract class Animal {
    abstract void eat();
}

class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
    public void work() {
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
    public void work() {
        System.out.println("看家");
    }
}

 运行结果：

 

 向上转型示例：

public class TestMain {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));
    }
}

class A {
    public String show(D obj) {
        return ("A and D");
    }

    public String show(A obj) {
        return ("A and A");
    }
}

class B extends A{
    public String show(B obj){
        return ("B and B");
    }

    public String show(A obj){
        return ("B and A");
    }
}

class C extends B{

}

class D extends B{

}

运行结果：

  

3、补充：抽象

如果有人问起面向对象的四个特征时，除了封装、继承、多态外，可以把抽象加进去。

抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。比如，我们要设计一个学生成绩管理系统，考察学生这个对象时，我们只关心他的班级、学号、成绩等，而不用去关心他的身高、体重这些信息。抽象包括两个方面，一是过程抽象，二是数据抽象。过程抽象是指任何一个明确定义功能的操作都可被使用者看作单个的实体看待，尽管这个操作实际上可能由一系列更低级的操作来完成。数据抽象定义了数据类型和施加于该类型对象上的操作，并限定了对象的值只能通过使用这些操作修改和观察。

具体表现为抽象类、抽象方法。