多态性（polymorphism），封装性（encapsulation），内聚（cohesion）以及耦合（coupling）的基本概念

Java的三大特性：多态、封装、继承。

Java程序设计尊崇的思想：高内聚、低耦合。

多态性：Java官方给出的定义：

　　The dictionary definition of polymorphism refers to a principle in biology in which an organism or species can have many different forms or stages. This principle can also be applied to object-oriented programming and languages like the Java language. Subclasses of a class can define their own unique behaviors and yet share some of the same functionality of the parent class.

　　它的大义是说：多态性的本义是指生物学中的一个定律，一个生物体或者物种可以有不同的形式或者阶段。这个定律同样适用于面向对象编程和像Java一样的语言，一个类的子类可以定义自己独特的行为并且共享一些父类中共同的功能。

　　我们再来理解一下它的定义，“一个类的子类可以定义自己独特的行为并且共享一些父类中共同的功能”，我们就可以联想到它的实现方法：继承和接口实现，单一继承，多重实现，这样我们就把三大特性联系起来了，我们联系生活中的一些实例巩固和实践我们的定义，比如书，书有很多种，但他有一些共同的特性，比如书名、作者、前言、目录等和公共方法，比如读，我们就可以放在父类中，子类通过继承直接使用，但是不同的书有不同的读法和它自己的一些独有的属性，比如数学书，独特的属性：数学公式，自然读数学书跟读哲学书的方法就不一样，我们来看一个例子。

公共父类：Book.java

/**
 * @Description: 书（父类）
 * @author: vioking
 * @date: 2017-7-12
 */
public class Book {

    private String title;//书名
    private String author;//作者
    private String bookType;//类型

    //默认构造方法
    public Book() {
    }

    public Book(String title, String author, String bookType) {
        this.title = title;
        this.author = author;
        this.bookType=bookType;
    }

    /**
     * 公共方法
     */
    public void read(){

        System.out.println("公共父类的方法");
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getBookType() {
        return bookType;
    }

    public void setBookType(String bookType) {
        this.bookType = bookType;
    }
}

子类：MathBook.java

/**
 * @Description: 数学书子类
 * @author: vioking
 */
public class MathBook extends Book{


    private String formula;//数学公式

    //重写父类的方法
    public void read(){

        System.out.println("数学书子类"+"
书名:"+getTitle()+"
作者:"+getAuthor()+"
类型:"+getBookType()+"
公式："+getFormula());
    }

    public String getFormula() {
        return formula;
    }

    public void setFormula(String formula) {
        this.formula = formula;
    }
}

子类：PhilosophyBook.java

/**
 * @Description: 哲学书子类
 * @return: ${return_type}
 * @author: vioking
 */
public class PhilosophyBook extends Book {

    private String idea;//观点

    public void read(){

        System.out.println("哲学书子类"+"
书名:"+getTitle()+"
作者:"+getAuthor()+"
类型:"+getBookType()+"
公式："+getIdea());
    }

    public String getIdea() {
        return idea;
    }

    public void setIdea(String idea) {
        this.idea = idea;
    }
}

测试方法：BookMain.java

/**
 * @Description: 主方法
 * @author: vioking
 */
public class BookMain {

    public static void main(String[] args) {
        MathBook mathBook = new MathBook();//封装的父类属性
        mathBook.setTitle("离散数学结构(第6版)");//封装的父类属性
        mathBook.setAuthor("科曼(Bernard Kolman)");//封装的父类属性
        mathBook.setBookType("数学书");//封装的父类属性
        mathBook.setFormula("((p→q)∧(q→r))→(p→r)");//独有的子类属性
        mathBook.read();//覆写的父类方法

        PhilosophyBook philosophyBook = new PhilosophyBook();
        philosophyBook.setTitle("马克思主义哲学");
        philosophyBook.setAuthor("马克思");
        philosophyBook.setBookType("哲学书");
        philosophyBook.setIdea("社会大分工的结果使大多数人重复简单而单一的工作");
        philosophyBook.read();
    }
}

运行结果：

这就是通过继承实现多态的一种方法，通过实现接口实现多态的原理基本差不多，就不赘述了。

封装性：

　　Encapsulation is one of the four fundamental OOP concepts. The other three are inheritance, polymorphism, and abstraction.

Encapsulation in Java is a mechanism of wrapping the data (variables) and code acting on the data (methods) together as a single unit. In encapsulation, the variables of a class will be hidden from other classes, and can be accessed only through the methods of their current class. Therefore, it is also known as data hiding.

　　Java中的封装是将数据（变量）和作为数据（方法）的代码作为一个单元进行包装的机制。在封装中，类的变量将从其他类隐藏，只能通过其当前类的方法进行访问。因此，它也被称为数据隐藏。

　　上例中的book.java就实现了简单的封装，它的类变量是私有的private，但是提供了公共的public方法以便其它类访问。

　　高内聚、低耦合

　　模块与模块间应该尽可能的避免发生联系，假如某一模块因为某种原因需要改动，但是这一模块的改动需要改动整个项目，这样一来就会延长开发周期，甚至出现不必要的bug，得不偿失。

　　同样，一个模块间的功能尽可能的发生多的联系，这样就能减少冗余，过多逻辑的判断，从而提高项目的可维护性和高执行效率。

　　以上是我对多态、封装、内聚和耦合的一点理解，如果错误，还请斧正，谢谢。

参考资料：

^{【1】. http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html}

^{【2】.http://www.tutorialspoint.com/java/java_encapsulation.htm}