面向对象-封装、继承、多态《笔记一》

Java面向对象 - 封装、继承和多态

面向对象的三个基本特征是：封装、继承和多态。

前言

封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）。封装和继承的目的都是：代码重用。而多态则是为了实现另一个目的 —— 接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

本实训主要学习面向对象三大基本特性：封装、继承和多态。

1.什么是封装，如何使用封装

1.1什么是封装

封装：就是隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装时的权限控制符区别如下:

1.2封装的意义

对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。使用封装有四大好处：

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

封装把一个对象的属性私有化，同时提供一些可以被外界访问属性的方法，如果不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。

1.3实现Java封装的步骤

(1)、修改属性的可见性来限制对属性的访问（一般限制为private），例如：

public class Person {
 private String name;
 private int age;
}

这段代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。

(2)、对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

/*
*封装演示
*/
public class Person {
    /*
     * 对属性的封装 一个人的姓名、性别和年龄都是这个人的私有属性
     */
    private String name;
    private String sex;
    private int age;
    /*
     * setter()、getter()是该对象对外开放的接口
     */
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

封装可以使我们容易地修改类的内部实现，而无需修改使用了该类的客户代码，就可以对成员变量进行更精确的控制。

public void setAge(int age) {
    if (age > 120) {
        System.out.println("ERROR：error age input...."); // 提示错误信息
    } else {
        this.age = age;
    }
}
public String getSexName() {
    if ("0".equals(sex)) {
        sexName = "女";
    } else if ("1".equals(sex)) {
        sexName = "男";
    } else {
        sexName = "人妖";
    }
    return sexName;
}

2.什么是继承，怎样使用继承

2.1继承的基本概念

所谓继承：是指可以让某个类型的对象获得另一个类型的对象的属性的方法。

兔子和羊属于食草动物类，狮子和豹属于食肉动物类。
食草动物和食肉动物又是属于动物类。
所以继承需要符合的关系是：is-a，父类更通用，子类更具体。
虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。

在讲解继承的基本概念之前，读者可以先想一想这样一个问题：现在假设有一个Person类，里面有name与age两个属性，而另外一个Student类，需要有name、age、school三个属性，如图所示，从这里可以发现Person中已经存在有name和age两个属性，所以不希望在Student类中再重新声明这两个属性，这个时候就需要考虑是不是可以将Person类中的内容继续保留到Student类中，也就是引出了接下来所要介绍的类的继承概念。

在这里希望Student类能够将 Person类的内容继承下来后继续使用：>

Java类的继承，可用下面的语法来表示：

class 父类 // 定义父类
{
    ...
}
class 子类 extends 父类 // 用extends关键字实现类的继承
{
    ...
}

范例：

public class TestPersonStudentDemo {
    public static void main(String[] args) {
        Student s = new Student();
        // 访问Person类中的name属性
        s.name = "张三";
        // 访问Person类中的age属性
        s.age = 18;
        // 访问Student类中的school属性
        s.school = "哈佛大学";
        System.out.println("姓名：" + s.name + "，年龄：" + s.age + "，学校：" + s.school);
    }
}
class Person {
    String name;
    int age;
}
class Student extends Person {
    String school;
}

输出结果：

姓名：张三，年龄：18，学校：哈佛大学

由上面的程序可以发现，在Student类中虽然并未定义name与age属性，但在程序外部却依然可以调用name或age，这是因为Student类直接继承自Person类，也就是说Student类直接继承了Person类中的属性，所以Student类的对象才可以访问到父类中的成员。

2.2继承的特性

• 子类拥有父类非private的属性和方法；
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展；
• 子类可以用自己的方式实现父类的方法；
• 在Java中只允许单继承，而不允许多重继承，也就是说一个子类只能有一个父类，但是Java中却允许多层继承，多层继承就是，例如类C继承类B，类B继承类A，所以按照关系就是类A是类B的父类，类B是类C的父类，这是Java继承区别于C++继承的一个特性；
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。

2.2.1多重继承：

class A{
    ...
}
class B{
    ...
}
class C extends A,B{
    ...
}

由上面可以发现类C同时继承了类A与类B，也就是说类C同时继承了两个父类，这在Java中是不允许的。

2.2.2多层继承：

class A{
    ...
}
class B extends A{
    ...
}
class C extends B{
    ...
}

由上面可以发现类B继承了类A，而类C又继承了类B，也就是说类B是类A的子类，而类C则是类A的孙子类。

2.3子类对象的实例化过程

既然子类可以继承直接父类中的方法与属性，那父类中的构造方法呢？请看下面的范例：

public class TestPersonStudentDemo1 {
    public static void main(String[] args) {
        Student s = new Student();
    }
}
class Person {
    String name;
    int age;
    // 父类的构造方法
    public Person() {
        System.out.println("1.public Person(){}");
    }
}
class Student extends Person {
    String school;
    // 子类的构造方法
    public Student() {
        System.out.println("2.public Student(){}");
    }
}

输出结果：

1.public Person(){}
2.public Student(){}

从程序输出结果中可以发现，虽然程序第3行实例化的是子类的对象，但是程序却先去调用父类中的无参构造方法，之后再调用了子类本身的构造方法。 所以由此可以得出结论，子类对象在实例化时会默认先去调用父类中的无参构造方法，之后再调用本类中的相应构造方法。实际上在本范例中，在子类构造方法的第一行默认隐含了一个super()语句，上面的程序如果改写成下面的形式，也是可以的：

class Student extends Person{
    String school ;
    // 子类的构造方法
    public Student(){
        super() ; //实际上在程序的这里隐含了这样一条语句
        System.out.println("2.public Student(){}");
    }
}

继承条件下构造方法调用规则如下：

• 如果子类的构造方法中没有通过super显示调用父类的有参构造方法，也没有通过this显示调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下写不写super()语句效果都是一样；
• 如果子类的构造方法中通过super显示调用父类的有参构造方法，那将执行父类相应构造方法，而不执行父类无参构造方法；
• 如果子类的构造方法中通过this显示调用自身的其他构造方法，在相应构造方法中应用以上两条规则；
• 特别注意的是，如果存在多级继承关系，在创建一个子类对象时，以上规则会多次向更高一级父类应用，一直到执行顶级父类Object类的无参构造方法为止。

3.什么是多态，怎么使用多态

3.1什么是多态

所谓多态：就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。
多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

多态性是对象多种表现形式的体现。
现实中，比如我们按下F1键这个动作：

• 如果当前在Flash界面下弹出的就是AS 3的帮助文档；
• 如果当前在Word下弹出的就是Word帮助；
• 在Windows下弹出的就是Windows帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

3.2多态的实现条件

多态的三个条件:

• 继承的存在(继承是多态的基础，没有继承就没有多态)；
• 子类重写父类的方法(多态下调用子类重写的方法)；
• 父类引用变量指向子类对象(子类到父类的类型转换)。

子类转换成父类时的规则:

• 将一个父类的引用指向一个子类的对象，称为向上转型(upcasting)，自动进行类型转换。此时通过父类引用调用的方法是子类覆盖或继承父类的方法，不是父类的方法。 此时通过父类引用变量无法调用子类特有的方法；
• 如果父类要调用子类的特有方法就得将一个指向子类对象的父类引用赋给一个子类的引用，称为向下转型，此时必须进行强制类型转换。

以下是一个多态实例的演示，详细说明请看注释：

public class TestAnimalDemo {
    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("看家");
    }
}

输出结果：

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

可以用 instanceof 判断一个类是否实现了某个接口，也可以用它来判断一个实例对象是否属于一个类。instanceof 的语法格式为:

对象 instanceof 类(或接口)

它的返回值是布尔型的，或真(true)、或假(false)。

3.3多态的实现形式

在Java中有两种形式可以实现多态：继承和接口。

• 基于继承实现的多态

基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。

基于继承实现的多态可以总结如下：

对于引用子类的父类类型，在处理该引用时，它适用于继承该父类的所有子类，子类对象的不同，对方法的实现也就不同，执行相同动作产生的行为也就不同。

如果父类是抽象类，那么子类必须要实现父类中所有的抽象方法，这样该父类所有的子类一定存在统一的对外接口，但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的统一接口来处理该层次的方法。

• 基于接口实现的多态

继承是通过重写父类的同一方法的几个不同子类来体现的，那么就可能是通过实现接口并覆盖接口中同一方法的几不同的类体现的。

在接口的多态中，指向接口的引用必须是指定实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。

继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。

数据来源EduCoder