输出结果：
name：张三；age：15；score：90
..............................
name：张三；age：15；score：90

2.1 在Java中只允许单继承（一个子类只允许有一个父类），子类不能直接访问父类的私有成员
示例2：

?public class ExtendsDemo2 {
?public static void main(String[] args){
?PetWorker petWorker=new PetWorker();
?petWorker.setAge(20);
?petWorker.setWork("teacher");
?petWorker.tell();
?}
}
/**
?* 创建类People
?* @author Admin
?*
?*/
class People{
? ? private int age;
? ? public int getAge() {
? ? ? ? return age;
? ? }
? ? public void setAge(int age) {
? ? ? ? this.age = age;
? ? }
}
/**
?* 创建Worker类，单继承People类
?* @author Admin
?*
?*/
class Worker extends People{
? ? private String work;
? ? public String getWork() {
? ? ? ? return work;
? ? }
? ? public void setWork(String work) {
? ? ? ? this.work = work;
? ? }
}
/**
?* 创建PetWorker类，单继承Worker类
?* @author Admin
?*
?*/
class PetWorker extends Worker{
? ? public void tell() {
? ? ? ? System.out.println("age:"+getAge()+";work:"+getWork());
? ? }
}

输出结果：
age:20;work:teacher

2.2 Java方法重写
? 定义：方法名称相同，返回值类型相同，参数也相同，其实质就是子类定义了和父类同名的方法。
? 重写限制：被子类重写的方法不能拥有比父类方法更严格的访问权限。private? 子类调用父类中的方法：super.方法名(参数)
public class ExtendsDemo1 {
? ? public static void main(String[] args) {? ?
? ? B b=new B();
? ? b.tell();
? ? }
}
?
class A{
? ? public void tell(){
? ? ? System.out.println("父类中的tell方法");
? ? }
}
?
class B extends A{
? ? public void tell() {
? ? super.tell();
? ? System.out.println("我重写了tell方法");
? ? }
? ? void say(){
? ? super.tell();
? ? }
}

输出结果：
? 父类中的tell方法
? 我重写了tell方法
? 父类中的tell方法

2.3 抽象类与接口
? final能申明类、方法和属性，使用final申明的类不能被继承，使用final申明的方法不能被重写，使用final申明的变量变成常量（定义时要赋值），常量是不可以修改的。
? 抽象类：包含一个抽象方法的类就是抽象类。
定义：
abstract? class ClassName{
? ? 属性
? ? 方法
? ? 抽象方法
}
（1）抽象方法：申明而未实现的方法，抽象方法必须使用abstract关键字申明，只有方法名和参数，没有方法体。
（2）抽象类被子类继承，子类（若不是抽象类）必须重写抽象类中的所有抽象方法。
（3）抽象类不能实例化，要通过其子类进行实例化。
public class AbstractClassDemo1 {
? ? public static void main(String[] args) {
? ? ? ? StuClass stuClass=new StuClass();
? ? ? ? stuClass.tell();
? ? ? ? stuClass.say();
? ? }
}
?
abstract class AbsClass{
? ? int age;
? ? public void tell(){
? ? ? ? System.out.println("父类中的tell方法");
? ? }
? ? public abstract void say();
}
?
class StuClass extends AbsClass{
? ? @Override
? ? public void say() {
? ? ? ? System.out.println("子类实现父类抽象类中的say抽象方法");
? ? }
}

?

? 接口可以理解为一种特殊的类（没有构造方法），里面全部是由全局常量和公共的抽象方法组成，接口的实现必须通过子类，使用关键字implements，而且子类可以多实现接口。一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口。接口定义如下：
[修饰符] interface 接口名 [extends 父接口名列表]{
? ? [public] [static] [final] 全局常量;
? ? [public] [abstract] 抽象方法;
}
样例：