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

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

---

封装

封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。
封装，一种将抽象性函式接口的实作细节部份包装、隐藏起来的方法。
封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据，必须通过严格的接口控制。
封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。
好处：
1，将变化隔离
2，便于使用
3，提高重用性
4，提高安全性
封装原则：
1，将不需要对外提供的内容都隐藏起来。
2，把属性都隐藏，提供公共方法对其访问。

实例

下面是一个Java封装类的例子

public class EncapsulationTest {

    private String name;
    private String sex;
    private int age;
    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;
    }
}

上面的实例中public方法是外部类访问该类成员变量的入口，这些方法被称为getter和setter方法。
因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。
下面这个例子用来说明怎么访问EncapsulationTest类的变量：

public class RunEncapsulation {

    public static void main(String[] args) {
        EncapsulationTest encap=new EncapsulationTest();
        encap.setName("Jack");
        encap.setSex("男");
        encap.setAge(20);

        System.out.println("Name:"+encap.getName()+
                " Sex:"+encap.getSex()+" Age:"+encap.getAge());

    }
}

以上代码编译运行结果如下

Name:Jack Sex:男 Age:20

---

继承

继承可以理解为一个对象从另一个对象获取属性的过程。
如果类A是类B的父类，而类B是类C的父类，我们也称C是A的子类，类C是从类A继承而来的。在Java中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类
继承中最常使用的两个关键字是extends和implements。
通过使用这两个关键字，我们能实现一个对象获取另一个对象的属性。
所有Java的类均是由java.lang.Object类继承而来的，所以Object是所有类的祖先类，而除了Object外，所有类必须有一个父类。
通过extends关键字可以申明一个类是继承另外一个类而来的，一般形式如下：

public class Person{
    String name;
    int age;
}

public class Student extends Person{
    void study(){
        System.out.println(name+"...student study..."+age);
    }
}

public class Worker extends Person{
    void work(){
        System.out.println(naem+"....work...."+age);
    }
}

上面例子说明
●Person类是Student类的父类
●Person类是Worker类的父类
●Student类和Worker类是Person类的子类
Java中支持单继承。不直接支持多继承，但对C++中国的多继承机制进行改良。
单继承：一个子类只能有一个直接父类。
多继承：一个子类可以有多个父类（Java中不允许，进行改良），不直接支持，因为多个父类中有相同成员，会产生调用不确定性。在Java中是通过“多实现”的方式体现。
Java支持多层继承。
比如C继承B，B继承A，就会出现继承体系。

对于上面所说Java中不直接支持多继承，因为会出现调用的不确定性，所以Java将多继承机制进行改良，在Java中变成了多实现。
一个类可以实现多个接口。

/*
接口的出现避免了单继承的局限性
 */

interface CC{
    void show();
}
interface MM{
    void method();
}
interface QQ extends CC,MM{     //接口与接口之间是继承关系，而且接口可以多继承
    void function();
}
class WW implements QQ{
    //覆盖3个方法
    public void show();
    public void method();
    public void function();
}

什么时候定义继承呢？
当类与类之间存在着所属关系的时候，就定义继承。

---

多态

封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。

继承是为了重用父类代码。两个类若存在 IS-A 的关系就可以使用继承。，同时继承也为实现多态做了铺垫。那么什么是多态呢？多态的实现机制又是什么？

多态是同一个行为具有多个不同表现形式或形态的能力。
多态性是对象多种表现形式的体现。
比如：在电脑中，我们按下F1键这个动作：
●在Chrome浏览器界面下弹出的是Chrome帮助;
●在Word下弹出的是Word帮助;
●在Windows下弹出的是Windows帮助和支持
实例：

abstract class Animal{
    abstract void eat();
}
class Dog extends Animal{

    void eat() {
        System.out.println("啃骨头");
    }
    public void lookHome(){
        System.out.println("看家");
    }
}
class Cat extends Animal{
    void eat(){
        System.out.println("吃鱼");
    }
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}

public class TestDemo {

    public static void main(String[] args) {
        Dog dog=new Dog();
        method(dog);
        Cat cat=new Cat();
        method(cat);
    }
    public static void method(Animal a){
        a.eat();
    }
}

多态在代码中的体现：
父类或者接口的引用指向其子类的对象。

多态的好处：
●提高了代码的扩展性，前期定义的代码可以使用后期的内容。

多态的前提：
●必须有关系，继承，实现。
●要有覆盖。

多态的弊端：
●前期定义的内容不能使用（调用）后期子类的特有内容。

比如：

Aniaml a = new Cat();   //自动类型提升，猫对象提升了动物类型，但是特有功能无法访问。作用就是限制对特有功能的访问。专业讲:向上转型
a.eat();

//如果还想用具体动物猫的特有功能，你可以将对象进行向下转型
Cat c = (Cat)a; //向下转型的目的是为了使用子类中的特有方法
c.eat();
c.catchMouse();

注意：对于转型，自始至终都是子类对象在做着类型的变化。

多态的特点：
成员函数：
●编译时：要查看引用变量所属的类中是否有所调用的成员。
●在运行时，要查看对象所属的类中是否有所调用的成员。
成员变量：
●只看引用变量所属的类。