继承、多态、封装、抽象类与接口

作为一门面向对象语言，继承和多态是Java重要的特性。继承封装了一些公共特性，实现代码复用，减少代码冗余；多态可以动态调整对象的调用，降低对象之间的依存关系；接口是一种规范，可以通过接口实现多继承的功能。
一、继承
利用继承，人们可以基于已存在的类构造一个新类。继承已存在的类就是复用（继承）这些类的方法和域。在此基础上，还可以添加一些新的方法和域，以满足新的需求。这是Java程序设计中的一项核心技术。[java核心技术]
新建一个人物父类

public class Person {

    private int age;
    private String name;

    public Person(int age, String name){
        this.age = age;
        this.name = name;
    }

    public void info(){
        System.out.println(age);
        System.out.println(name);
    }

}

Teacher子类继承Person父类，关键字extends表示继承，extends表明正在构造的新类派生于一个已存在的类。已存在的类被称为超类（superclass）、基类（base class）或父类（parent class）；新类被称为子类（subclass）、派生类（derived class）或孩子类（child class）。

public class Teacher extends Person {

    //默认实现无参构造并可以不写，如果父类存在带参构造，则需要显式实现此构造
    public Teacher(int age, String name) {
        super(22, "shen");
        // TODO Auto-generated constructor stub
        super.info();
    }

    //重写父类方法
    @Override
    public void info(){
        System.out.println("rewrite...");
    }

    public static void main(String[] args) {
        Teacher t = new Teacher(20, "tutu");
        t.info();//子类拥有所有父类的成员变量，但private的成员变量没有访问权限
        //t.age//private变量不可访问

    }   
}
输出结果：
22
shen
rewrite...

二、多态
实现多态有三个条件：要有继承、要有重写、父类引用指向子类对象。
父类：

public class Animal {
    public void eat(){
        System.out.println("eat food");

    }

    public void walk(){
        System.out.println("walk alone");
    }
}

子类：

public class Dog extends Animal {
    //重写父类方法
    @Override
    public void eat(){
        System.out.println("eat bone");
    }

    public void walk(String dog1){
        dog1 = "tom";
        System.out.println("walk with " + dog1);
    }

    public static void main(String[] args) {

        Animal dog = new Dog();//向上转型，父类引用指向子类对象
        dog.eat();
        dog.walk();
        //dog.walk("jane");//只能调用父类存在的方法

        Dog dd = (Dog)dog;//向下转型
        dd.walk();
        dd.walk("jane");
    }
}

输出结果：
eat bone
walk alone
walk alone
walk with tom

多态可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
三、封装
在面向对象程式设计方法中，封装指一种将抽象性函式接口的实作细节部份包装、隐藏起来的方法。通常都使用getter和setter方法来实现，其他类要访问本类的私有成员变量都需要通过getter和setter方法。
例
实体类：

public class Person {

    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

测试类：

public class Test {

    public static void main(String[] args) {

        Person t = new Person();
        t.setAge(20);
        t.setName("shen");

        System.out.println("Age:" + t.getAge() + " name:" + t.getName());
    }

}
输出：
Age:20 name:shen

四、抽象与接口
1、我们知道，在面向对象世界中，所有的对象都是通过类来描述的，但是并不是所有的类都是来描述对象的。如果一个类没有足够的信息来描述一个具体的对象，而需要其他具体的类来支撑它，那么这样的类我们称它为抽象类。
例：

public abstract class Animal {

    private String name;
    private float weight;

    public Animal(String name, float weight){
        this.name = name;
        this.weight = weight;
    }

    abstract void run();//抽象类不一定有抽象方法，但包含抽象方法的类一定要被声明为抽象类

    public void eat(){

    }
}

继承：

public class Cat extends Animal{

    public Cat(String name, float weight) {
        super(name, weight);
        // TODO Auto-generated constructor stub
    }

    //覆盖抽象方法
    @Override
    void run() {
        // TODO Auto-generated method stub
        System.out.println("run fast");
    }

    public static void main(String[] args) {

        //Animal cat = new Animal("tom", 20f);//错误,抽象类不能实例化
        Cat cat = new Cat("tom", 20f);
        cat.run();
    }

}

另注：
如果一个类包含抽象方法，那么该类必须是抽象类。
任何子类必须重写父类的抽象方法，或者声明自身为抽象类。
2、接口
接口是抽象方法的集合。接口并不是类，一个类通过继承接口的方式，从而来继承接口的抽象方法。
实现接口必须覆盖全部抽象方法，跟抽象类相似。但是java中不能通过extends实现多继承，可以通过实现多个接口来达到多继承的目的。

public interface Person {
    public void eat();
    public void say();
}

实现：

public class Student implements Person {
    @Override
    public void eat() {
        // TODO Auto-generated method stub

    }
    @Override
    public void say() {
        // TODO Auto-generated method stub

    }
}

注：
接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键子。
接口中的方法都是公有的。