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

作为一门面向对象语言，继承和多态是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变量不可访问    }   }输出结果：22shenrewrite...

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

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 bonewalk alonewalk alonewalk 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关键子。
接口中的方法都是公有的。