前言：Java作为面对对象编程，相对于C语言来说，拥有三大特性，封装,继承,多态，那么这三个特性到底有什么意义？
java之父——詹姆斯·高斯林
首先是封装
对于某个对象，Java隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读取和修改的访问级别。
那么这是什么意思呢，就是说对于一个对象，不去直接修改他的属性，而是有相应的方法，当你想要操作的时候，只需调用方法即可。
这样可以把对象的数据和行为相结合，形成一个有机的整体，我们称之为类。
以下面的一段代码为例:
public class Admin {
private String id; //编号
private String name; //姓名
private String password; //密码
private String extend; //权限
void setID(String id) {
this.id=id;
}
void setName(String name) {
this.name=name;
}
void setPassword(String password) {
this.password=password;
}
void setExtend(String extend) {
this.extend=extend;
}
String getID() {
return this.id;
}
String getName() {
return this.name;
}
String getPassword() {
return this.password;
}
String getExtend() {
return this.extend;
}
void say() {
System.out.print("Chinese");
}
}
对于Admin类来说，他有4个属性，这4个属性都是私有的，其他的成员不能直接访问，其他的成员想要修改或者对Admin的属性赋值，就需要使用Admin类的方法。
可以看到每个属性都有相对应的get和set方法，当想要获取属性的值的时候，调用get方法，当想要修改属性值时，可以调用set方法。
上面是对象的数据，还有对象的行为，可以看上面代码的最后一个方法，say函数是一个人说什么语言，对应的是这个对象的行为。
对于想要实现的操作，一个类已经将其封装好，你只需调用方法即可，这正是面对对象编程的精髓。
通过封装使一部分成员充当类与外部的接口，而将其他的成员隐蔽起来，这样就达到了对成员访问权限的合理控制，使不同类之间的相互影响减少到最低限度，进而增强数据的安全性和简化程序的编写工作。
结论：封装能够提高代码的可复用性和安全性，所以在写代码时应尽量提高代码的封装程度。
继承
听这名字肯定就有一些想法，继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。
这样可以使代码的复用变的十分简单，我可以定义一个子类，拥有父类的所有属性和方法。同时，子类也可以重新定义方法，追加属性和方法，可以很大程度的减少工作量。
以一下代码为例：
现在有一个父类Animal：
public class Animal {
public void getColor() {
System.out.println("Animal:color");
}
public void getName() {
System.out.println("Animal:name");
}
}
有两个子类Dog：
public class Dog extends Animal{
public void getColor() {
System.out.println("Dogcolor");
}
public void getName() {
System.out.println("dogname");
}
public void bark() {
System.out.println("狗叫汪汪");
}
public void set() {
this.getColor(); //调用子类方法
super.getColor(); //调用父类方法
this.bark();
}
}
Cat:
public class Cat extends Animal{
public void getColor() {
System.out.println("catcolor");
}
public void getName() {
System.out.println("catname");
}
public void jump() {
System.out.println("猫会跳");
}
public void set() {
this.getColor(); //调用子类方法
super.getColor(); //调用父类方法
this.jump();
}
}
调用Dog类的set方法后的运行结果
调用Cat类的set方法后的运行结果：
从程序中可以看出，可以使用super关键字来实现对父类方法的实现。
一个父类可以拥有多个子类，而一个子类只能拥有一个父类，这是显而易见的。
而一个子类可以拥有其他子类，对于他的子类来说，他就是父类。
比如，现在有一个Cat的子类BlackCat：
public class BlackCat extends Cat{
public void getColor() {
System.out.println("黑色");
}
public void set() {
this.getColor();
super.getColor();
}
}
运行结果：
继承的特性：
1.子类拥有父类非 private的属性、方法。
2.子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。这一点从代码中也可以看出来，Dog类有Bark方法，Cat类有Jump方法。
3.子类可以用自己的方式实现父类的方法。可以用this关键字实现本身方法，用super关键字实现父类方法。
4.ava 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
5.提高了类之间的耦合性（缺点）。
多态
多态，顾名思义就是多种状态的意思。简单来说就是同一个接口使用不同的实例来执行不同操作抽象一点：猫和狗都会叫，但是它们叫的声音不一样。
多态的存在必须满足一下条件：
1.继承（extends或implements）
2.重写（override）
3.父类引用子类对象
多态的优点：
- 消除类型之间的耦合关系
- 可替换性
- 可扩充性
- 接口性
- 灵活性
- 简化性
以下面的代码为例：
public class Animal {
String color;
String name;
public void Call() {
System.out.println("动物叫");
}
public void getName() {
System.out.println("动物名");
}
}
class Cat extends Animal{
public void Call() {
System.out.println("喵喵喵");
}
}
class Dog extends Animal{
public void Call() {
System.out.println("汪汪汪");
}
public static void main(String []args) {
Animal dog = new Dog();
Animal cat = new Cat();
dog.getName();
dog.Call();
cat.Call();
}
}
运行结果：
可以看到同样的行为Call在不同的对象Dog和Cat有着不同的表达。以上就是我对多态的简单理解。
原文作者：张宜强
