java的三个特性：封装、继承、多态

在讨论这三个特性之前，我们必须先弄明白类和对象的含义。

对象

对象是事物存在的实体。
由两部分组成，属性和方法。

类

类是同一类事物的统称，是对象的载体。
类完成了对对象的封装。

面向对象程序设计的特点（java的特性）

封装性

用类将对象的属性和行为封装起来，对客户隐藏其实现细节，这就是封装的思想。
目的
1.保证类内部数据结构的完整性。
2.避免外部操作对内部数据的影响，提高程序的可维护性。

public class Package {// 封装意，用来展示类和对象的封装关系
    public static void main(String[] args) {
        Bird sparrow = new Bird();// sparrow对象，是Bird类的一个实例化对象。
        /*
         * 通过sparrow对象把Bird封装的属性和方法输出 1.属性wings、foots、mouth
         */
        System.out.println("我是麻雀，我有 " + sparrow.wings()+ "," + 
         sparrow.foots + "," + sparrow.mouth);
        // 2.方法fly（）、eat（）
        System.out.println("我的技能如下：");
        sparrow.fly();
        sparrow.eat();
    }
}
class Bird {
    /*
     * 以鸟类为例，属性包括一对翅膀，两只脚和一张嘴
     * 
     */
    private String wings = "一对翅膀";//用private修饰后，不能直接访问
    String foots = "两只脚";
    String mouth = "一张嘴";

    // 动作包括飞行、进食。
    public void fly() {
        System.out.println("我能飞得更高");
    }
    public void eat() {
        System.out.println("我会吃的很饱");
    }
    public String wings(){//通过wings()方法访问被private修饰的wings属性
        return wings;
    }
}

我用Bird类将鸟类相同的属性和共同具有的方法封装起来，如果想具体的指出某一只鸟（如代码中以麻雀sparrow为例）时就通过new实例化对象，实例化之后，无需再给这个实例一一赋值，它会自动的含有我在Bird中已经封装好的属性和方法。通过“对象名”.属性（或方法）即可直接调用。
其中我将wings属性用private修饰，会发现它不能在Package类中被直接使用了，而需要调用我在Bird类中专门写的wings（）方法才能获得该值，这种方式能够有效的保护类内部结构的完整性，避免外部操作对类的内部数据的修改。

        sparrow.foots="三只脚";
        Bird swallow = new Bird();//
        System.out.println(swallow.foots);

我们再在Package类的最后添加如上代码，会发现新创建的Bird类对象swallow的foots属性依旧是“两只脚”，没有因为sparrow.foots的改变而发生改变，这就是封装能够保护类内部数据的实证。

---

继承性

继承是类与类之间的一种关联关系。
主要目的是复用已经存在的类。
其中被继承的类被称作父类、超类、基类。继承者则被称作子类。
子类的实例都是父类的实例，这是下面多态性出现的关键。
要注意的是java中类之间是单继承的，不支持多继承，即类至多有一个父类。但是java中的接口是支持多继承的，一个接口可以继承多个接口。

---

多态性

多态性在我理解就是向上转型的结果，将子类对象赋值给父类对象。
想要理解多态，必须搞明白向上转型的过程。
下面以一段代码为例。

public class Polymorphism {// 类名为多态意
    public static void main(String[] args) {
        BaseClass polymorphism=new SubClass();//向上转型，实现多态的方式
        /*
         * 向上转型后，polymorphism的
         * 编译类型为BaseClass类，
         * 运行时类型为SubClass类
         */
        polymorphism.method();
        System.out.println(polymorphism.a);
        /*
         * 输出为this is SubClass 
         * 5
         * 属性是BaseClass的属性，方法是SubClass的方法
         * 因此，属性不具有多态性；方法具有多态性。
         */
    }
}

class BaseClass {// 基类
    int a = 5;

    public void method() {
        System.out.println("this is BaseClass " );
    }
}

class SubClass extends BaseClass {// 子类
    int a = 10;//和父类一样声明并初始化一个属性a

    @Override
    public void method() {//重写父类BaseClass的method方法
        System.out.println("this is SubClass " );
    }
}

代码段中有三个类，分别是Polymorphism类、BaseClass类和SubClass。
其中Polymorphism类使我们的主类，BaseClass和SubClass是我们实现多态过程中的父类和子类。
上述代码中，BaseClass polymorphism=new SubClass();是向上转型的关键。
将子类对象赋值给父类对象，polymorphism产生了编译时类型和运行时类型不一致的情况，这种不一致就造就了多态性，运行子类和父类都有的方法method（）时发现调用了子类重写后的方法，而通过polymorphism.a访问属性时则调用了父类的a属性，因此，方法局有多态性，而属性不具有多态性。
继承是出现多态的一种可能，将类赋值给接口也可能出现多态现象。
要想出现多态，必须满足以下三个条件:
1.要有继承。
2.要有重写。
3.要有子类对象赋值给父类对象。

多态最重要的作用就是消除类之间的耦合性。比如我写一个方法，它的参数是是一个父类对象，那么他可以指向很多他的子类，而如果不用多态，我们就得重写方法内容。

---

如有不妥，敬请指正。