详解：面向对象的三大特性

1.1 封装
封装就是把同一类事物的属性和方法归到同一类中，方便使用。
封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据，必须通过严格的方法控制。
封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
适当的封装可以让程序更容易理解与维护，也加强了程序的安全性。

封装的优点
1. 良好的封装能够减少耦合。
2. 类内部的结构可以自由修改。
3. 可以对成员变量进行更精确的控制。
4. 隐藏信息，实现细节

最佳实践：
为了实现良好的封装，通常将类的成员变量声明为private，在通过public方法来对这个变量来访问。对一个变量的操作，一般有读取和赋值2个操作，，我们分别定义2个方法来实现这2个操作，一个是getXX（XX表示要访问的成员变量的名字）用来读取这个成员变量，另一个是setXX（）用来对这个变量赋值。
1.2 继承
Java继承是面向对象的最显著的一个特征，是面向对象的一块基石。
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
继承的特性：
子类拥有父类非private的属性，方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java的继承是单继承。

继承关键字：
extends
implements
super 与 this 关键字
final关键字
构造器

参考代码：SuperClass

package com.cto.demo.basic;

/**
 * 子类不能继承父类的构造器（构造方法或者构造函数），但是父类的构造器带有参数的，
 * 则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。
 * 
 * 如果父类有无参构造器，则在子类的构造器中用super调用父类构造器不是必须的，
 * 如果没有使用super关键字，系统会自动调用父类的无参构造器。
 *
 */
class SuperClass {
    private int num;

    SuperClass() {
        System.out.println("SuperClass()父类默认构造函数被调用");
    }

    SuperClass(int num) {
        System.out.println("SuperClass(int num)父类有参构造函数被调用");
        this.num = num;
    }
}

class SubClass extends SuperClass {
    private int num;

    SubClass() {
        super(300); // 显示调用父类构造函数
        System.out.println("SubClass子类默认构造函数被调用");
    }

    public SubClass(int num) {
        super();
        System.out.println("子类有参构造函数被调用SubClass(int num):" + num);
        this.num = num;
    }
}

public class TestSuperSub {
    public static void main(String args[]) {
        SubClass subC = new SubClass();
        SubClass subC2 = new SubClass(100);
    }
}

1.3 多态
封装和继承几乎都是为多态而准备的。
多态是同一个行为具有多个不同表现形式或形态的能力。
多态是同一个接口，使用不同的实例而执行不同操作。
多态是面向对象编程语言的重要特性，它允许基类的指针或引用指向派生类的对象，而在具体访问时实现方法的动态绑定。

多态存在的三个必要条件：
继承
重写
父类引用指向子类对象

参考代码：Polymorphic

“`
package com.cto.demo.basic;

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

    System.out.println("======================");
    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();

void sleep(){
    System.out.println("sleep==============");
}

}

class Cat extends Animal {
public String name = “cat name”;
public void eat() {
System.out.println(name);
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("看家");
}

}“`

详解：面向对象的三大特性

猜你喜欢