接触过面向对象的人都知道面向对象有三大特征，分别是封装、继承和多态。这三者分别指的是什么，为何是这哥仨，使用他们有什么好处，咱们来梳理一下。java
隐藏对象的属性和实现细节，仅对外提供公共访问方式。安全
①将变化隔离。ide
②便于使用。this
③提升重用性。spa
④提升安全性。.net
Demo1:code
好比一个学生类：他具备姓名和年龄两个属性，可是为了提升安全性和重用性，便于使用，咱们将其封装起来。对象
public class Student {
private String name;
private int age;
public Student() {
super();
//TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
this.name= name;
this.age= age;
}
public String getName() {
returnname;
}
public void setName(String name) {
this.name= name;
}
public int getAge() {
returnage;
}
public void setAge(int age) {
this.age= age;
}
@Override
public String toString() {
return"Student [name=" + name + ", age=" + age + "]";
}
}
其中，类的成员变量都用private修饰，提升安全性。blog
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类便可。继承
父类又称基类，超类；子类又称派生类。
子类能够直接访问父类中的非私有的属性和行为。
关键字为 extends
提升了代码的复用性。
让类与类之间产生了关系，提供了多态的前提。
a.Java只支持单继承，不支持多继承。
由于若是能够多继承，就会出现调用不明确的问题。
b.Java支持多重继承（继承体系）
若是多个类之间有is a 的关系时候，能够定义为继承。
定义类（A,B）的时候：
A is a B 中A是子类。
B is a A 中B是子类
注意：不要为了去继承部分功能，而去使用继承。
Demo2：
class animal
{
private String name;
private int age;
public void setName()
{
this.name=name;
}
public String getName()
{
returnname;
}
public void setAge()
{
this.age=age;
}
public int getAge()
{
returnage;
}
public void run()
{
System.out.println("跑步");
}
public void eat()
{
System.out.println("吃饭");
}
}
class dog extends animal
{
publicvoid eat()
{
System.out.println("狗吃骨头！");
}
}
class car extends animal
{
public void eat()
{
System.out.println("猫吃鱼！");
}
}
class AnimalTest
{
public static void main(String[] args)
{
dog d = new dog();
d.eat();
d.run();
car c = new car();
c.eat();
c.run();
}
}
运行结果：
狗吃骨头！
跑步
猫吃鱼！
跑步
在同一个方法中，因为参数不一样而致使执行效果各异的现象就是多态。
拿生活中的例子来讲：
水(水,冰,水蒸气)
狗：狗是狗，狗是动物，狗是宠物，狗是食物
A:要有继承关系。
B:要有方法重写。
C:要有父类引用指向子类对象。
方法有重写，而变量没有
成员变量
编译看左边，运行看左边。
成员方法
编译看左边，运行看右边。
注意：多态有三种体现形式
类多态
抽象类多态
接口多态
提升代码的扩展性和可维护性。
父类引用不能使用子类特有功能。
基本类型：隐式转换(小到大)，强制转换(大到小)。
引用类型：向上转型(小到大)，向下转型(大到小)。
Demo3:
class Animal
{
public void sing()
{
System.out.println("动物在唱歌!");
}
}
class Dog extends Animal
{
public void sing()
{
System.out.println("狗在唱歌!");
}
}
class Cat extends Animal
{
public void sing()
{
System.out.println("猫在唱歌!");
}
public void eat()
{
System.out.println("猫在吃饭!");
}
}
public class PolyTest
{
public static void main(String[] args)
{
//向上类型转换
Cat cat = new Cat();
Animal animal = cat;
animal.sing();
//向下类型转换
Animal a = new Cat();
Cat c = (Cat)a;
c.sing();
c.eat();
//编译错误
//用父类引用调用父类不存在的方法
//Animal a1 = new Cat();
//a1.eat();
//编译错误
//向下类型转换时只能转向指向的对象类型
//Animal a2 = new Cat();
//Cat c2 = (Dog)a2;
}
}
运行结果：
猫在唱歌！
猫在唱歌！
猫在吃饭！
初看，觉不出来多态的好处，感受和继承挺像的，这些东西不用多态照样可以实现，这是由于目前咱们接触的都是小Demo，等待之后作项目的时候强调的是对修改关闭，对拓展开放。多态能在之后帮助咱们达到这些目标。例如以前写过一篇文章：《谈一谈：抽象工厂+反射+配置文件实现数据访问程序》，针对一些需求的修改，咱们仅仅修改一下配置文件便可，而不用对源代码动刀。固然这个例子跟接口的多态有关，因此后续笔者还会总结一下抽象类和接口，尝试让多态的优势更多的体现出来，敬请期待！
封装即隐藏对象的属性和实现细节，仅对外提供公共访问方式，保证了模块具备较好的独立性，使得程序维护修改较为容易。继承提升了代码的复用性，多态提升代码的扩展性和可维护性。三者共同达到了一个目的：使得对应用程序的修改带来的影响更加局部化，程序更加健壮，并且易维护、更新和升级。