java是一种面向对象的程序设计语言，在程序中使用对象来描述具体的事物，当多个事物具有共同的特点时，可以将事物的共同特点进行抽象，然后封装成一个包含事物共同特点的集合，在java中叫做封装成一个类，可以将面向对象的主要特点是（抽象）封装、继承和多态。
封装
所谓抽象，就是将一些具体的事物之间存在的共同之处抽取出来，然后形象化的描述，在java中抽象的过程就是将事物共同的静态属性和动态属性封装成类的过程，事物的静态属性可以抽象成变量，动态属性则可以封装成一个方法（函数），封装是面向对象的核心思想，封装指的的是将对象的属性和动作进行封装，对外隐藏本身的实现细节。例如：狗、猫，可以找他们之间的共同点，都有颜色这一属性，则可以封装一个颜色属性到类中；再者他们都要吃饭，则可以封装一个吃饭的方法到类中，不管是狗还是猫，我们只需要知道他们能吃饭就可以了，并不需要具体了解他们吃饭的具体步骤，这就是对外开放但是隐藏本身的实现细节。
类、方法、变量
定义类、变量和方法时都会用到权限修饰符：public、protected、default、private，被public修饰的变量和方法可以随便访问；被protected、private修饰的变量和方法只能在当前类中使用。
类中可以包含变量和方法，具体的实现代码必须要写在具体的方法中，变量又分为局部变量和成员变量，方法中声明的变量就是局部变量，类里边、方法外边声明的变量就是成员变量，变量的定义包含以下部分：修饰符、变量类型、变量名 ，代码如下：
public class Dog{
//变量的声明
//private 私有修饰符
//int 变量类型
//color 变量名
private int color;
}方法的定义包含以下部分：修饰符、返回值类型（构造方法除外）、方法名、方法体。类中的方法根据功能划分可分为两类，一类时构造方法、另一类是普通的方法，构造方法用来构造当前类的对象，初始化对象的属性，而普通的方法就是根据对象动态属性抽象过来的方法。代码如下：
public class Animal {
public String color;
/**
* 构造方法，没有返回值，方法名和类名相同，可用于初始化类中封装的变量
*/
public Animal(String color) {
//this.color中的color指的是当前类中的变量
//第二个color是局部变量color的值
//this关键字可用于表示当前类
this.color = color;
}
/**
* 普通方法，int是返回值类型，eat是方法名
*/
public int eat() {
//局部变量
int flag = 0;
System.out.println("Animal在吃饭。。。");
return flag;//返回值
}
}定义方法时可以调用其他的方法，方法可以被重载，一个类中不可以定义完全相同的两个方法，但是可以定义两个方法名相同但是参数列表不同的方法，这两个方法的关系就是重载，代码如下：
public class Animal {
/*
* 两个方法的方法名相同参数列表不同则两个方法重载，和返回值无关，方法可以重载多个
*/
public void eat() {
}
public int eat(int flag) {
return flag;
}
public void eat(String flag) {
}
}每一个类就相当于一个模板，可以根据这个模板创造出具体的对象，在java中使用new关键字来创建对象,使用 “.” 来调用类中公开的方法和变量代码如下：
class Animal {
public int flag;
public void eat() {
System.out.println("正在吃饭");
}
}
public class Test {
public static void main(String[] args) {
Animal animal = new Animal();//创建对象
animal.eat();//调用方法
}
}继承、抽象类、接口
当一个类被封装后，一般不鼓励二次封装，一般当类的功能不足以支持当前需求时，我们会考虑对此类进行扩展，java中可以使用继承来实现这一想法。例如这里有类A，类中有一个计算四边形周长的方法，但是现在想计算正方形的周长，虽然计算四边形周长的方法可以用于计算正方形，但是想实现的简单点，就可以再封装一个类B，然后B继承类A，在java中用关键字extends来表示继承，B extends A，这就叫做类B继承自类A，A是B的父类，B是类A的子类，然后可以在B中重新声明一个方法用来计算正方形的周长。子类可以使用父类所有公开的属性和方法，每一个类只能继承一个父类（例如：在血缘关系上，一个儿子只有一个父亲），所以java中是单继承。再如上边的计算四边形的方法，如果在子类中声明一个方法，此方法与父类中的方法完全相同，这就是方法的重写。代码如下：
public class Animal {
public int flag;
public void eat() {//这里已经声明了eat方法
System.out.println("正在吃饭");
}
}
-----------------------------------------------------------------------------------
//Dog类继承了Animal类，拥有了Animal类的公开的功能
public class Dog extends Animal{
@Override//这个注解的意思是重写方法
public void eat() {//重写父类方法
System.out.println("Dog在吃饭。。。");
}
}在写代码的过程中，声明了一个方法，但是不知如何实现，这时可以将方法体删掉，然后使用修饰符abstract 来修饰这个方法，这个方法就叫做抽象方法，如果一个类中存在抽象方法，那么这个类必须使用abstract修饰，以将此类标记成抽象类，如果一个类中的所有方法都是抽象的，那么这个类就可以声明成一个接口，使用interface 来声明接口。抽象类和接口都不可以实例化（就是指不可以使用new关键字来创建对象）。抽象类可以被继承，如果子类声明的不是抽象类，那么就必须重写继承的抽象父类中的所有抽象方法。接口可以被实现，使用implements 关键字进行接口的实现，实现接口的类如果不声明成抽象类，就必须重写实现接口中所有的方法，一个类不可以继承多个类，但是可以实现多个接口，这样就解决的java单继承的尴尬。代码如下：
//声明接口 interface
public interface Animal {
//声明一个方法
public abstract void run();
}
//声明接口 interface
interface Animal2 {
//声明一个方法
public abstract void eat();
}
------------------------------------------------------------------------------
//实现Animal,Animal2接口，重写接口中的方法，如果多个接口，则每一个接口中的方法都要实现
public class Dog implements Animal ,Animal2{
@Override
public void eat() {
System.out.println("dog eat ...");
}
@Override
public void run() {
// TODO Auto-generated method stub
}
}static、final
static关键字意为静态的意思，static可以修饰变量、方法、代码块，只需要记住一点：被static修饰的属性和方法是所有根据当前类创建的对象所共享的，一个对象做出修改，其他对象就会修改，在内存中只有一份。
final关键字意为最终之意，final可用来修饰类、方法、变量，被修饰的类不可被继承、被修饰的方法不能重写、被修饰的变量不能重新赋值。秩序记住一点，只要被final修饰，什么东西就都不能改了，保持最终的状态。
多态
最后说一下多态的理解，所谓多态就是多种状态，统一类的不同对象所表现的不同的状态，就是父类（接口）的引用指向子类（实现类）的对象，实现多态有以下几中方式 ：继承类、实现接口。例如封装一个动物类，类中有动物的颜色这一变量、动物吃饭方法，然后分别封装狗类和猫类，然后狗类和猫类都继承动物类，这时我声明一个动物类的变量，然后创建对象的时候，将此变量指向一个狗的对象，以为狗属于动物（狗类继承自动物类），这时动物就表现出了多态性，创建谁的对象，这个动物就会表现出谁的状态。代码实现如下：
public class Animal {
public String color;
public void eat() {
System.out.println("Animal在吃饭。。。");
}
}
-------------------------------------------------------------------------------------
public class Dog extends Animal{
@Override
public void eat() {
System.out.println("Dog在吃饭。。。");
}
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("Cat在吃饭。。。");
}
}
-------------------------------------------------------------------------------------
public class Test {
public static void main(String[] args) {
normal();//正常执行，不表现多态
poly(); //表现多态
}
/**
* 正常调用
* @author chaizepeng
*
*/
public static void normal() {
Animal animal = new Animal();
animal.eat();
Dog dog = new Dog();
dog.eat();
Cat cat = new Cat();
cat.eat();
}
/**
* 表现出多态性
* @author chaizepeng
*
*/
public static void poly() {
Animal animalDog = new Dog();
animalDog.eat();
Animal animalCat = new Cat();
animalCat.eat();
}
}