面向对象的特性之封装和继承

前言

谨记录面向对象学习中的知识点，内容易懂，可用于复习基础。如有错误，欢迎指正~

封装

面向对象编程强调要把一批同类的对象实例共有的属性和行为封装在一个类里面，体现了封装性。

• 我们程序设计要追求"高内聚，低耦合"。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

• 封装（数据的隐藏）

  • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

package com.oop.Test04;
//类 private:私有
public class Student {
    //属性私有
    //姓名
    private String name;
    //学号
    private int id;
    //性别
    private char sex;
    //年龄
    private int age;
//提供一些可以操作这个属性的方法！
//提供一些public的get、set方法
    //get获得这个数据
    public String getName(){
        return this.name;
    }
    //set给这个数据设置值
    public void setName(String name){
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 120 || age < 0){
            age = 3;
        }
        this.age = age;
    }
}

继承

面向对象编程强调，一个类可以继承另外一个类的“资产”，成为另外一个类的子类，体现了继承性。

当我们需要创建一个新类，如果存在现成的类，包含新类的部分属性和方法，新类可以从现成的类中派生，重用现成类的属性和方法。新派生的类就是子类，现成的类称为父类。

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

extends的意思是"扩展"。子类是父类的扩展。

Java中类只有单继承，没有多继承。

• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
• 子类和父类之间，从意义上讲应该具有"is a"的关系。
• 通过继承，子类可以重用父类的代码，需要说明的是子类是不继承父类的构造方法的，但是可以在子类的构造方法中调用父类的构造方法。
• 通过继承，可以从现有的类中派生新的子类，还可以从新的类中继续派生出新的类，从而形成类的层次结构。

我们看一下Java的类的层次结构：

声明子类的语法格式如下：

class 子类名 extends 父类名{
  
}

下面我们看一个例子：

package com.oop.Rew;

class Bicycle {

    // the Bicycle class has three fields
    public int cadence;//起落架
    public int gear;//齿轮
    public int speed;

    // the Bicycle class has one constructor
    public Bicycle(int startCadence, int startSpeed, int startGear) {
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;
    }

    // the Bicycle class has four methods
    public void setCadence(int newValue) {
        cadence = newValue;
    }

    public void setGear(int newValue) {
        gear = newValue;
    }

    public void applyBrake(int decrement) {
        speed -= decrement;
    }

    public void speedUp(int increment) {
        speed += increment;
    }

    public void printDescription() {
        System.out.println("\nBike is " + "in gear " + this.gear
                + " with a cadence of " + this.cadence +
                "   and travelling at a speed of " + this.speed + ". ");
    }
}
//子类是山地自行车，从自行车中派生，并增加了自己的属性和方法
class MountainBike extends Bicycle {
    private String suspension; //悬架

    public MountainBike(
            int startCadence,
            int startSpeed,
            int startGear,
            String suspensionType) {
        super(startCadence,  //子类的构造方法中调用了父类的构造方法
                startSpeed,
                startGear);
        this.setSuspension(suspensionType);
    }

    public String getSuspension() {
        return this.suspension;
    }

    public void setSuspension(String suspensionType) {
        this.suspension = suspensionType;
    }

    public void printDescription() {
        super.printDescription();//子类的显示输出中调用了父类相应的方法
        System.out.println("The " + "MountainBike has a" +
                getSuspension() + " suspension.");
    }
}

public class Example02 {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Bicycle bike01, bike02;

        bike01 = new Bicycle(20, 10, 1);
        bike02 = new MountainBike(20, 10, 5, "Dual");

        bike01.printDescription();
        bike02.printDescription();
    }

}

总结

封装的意义：
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.提高了系统的可维护性
关于继承的注意点：
在继承中，子类继承父类所有的公有（public）和保护（protected）成员。如果子类和父类在同一个包中，子类也继承父类的包友好成员。子类可以使用、重写、隐藏其父类的成员。子类也可以增加新的成员。 子类不能继承其父类的私有成员。