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

作为一门面向对象语言，继承和多态是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关键子。
接口中的方法都是公有的。