1:final关键字(掌握)

(1)是最终的意思,可以修饰类,方法,变量。

(2)特点:

A:它修饰的类,不能被继承。

B:它修饰的方法,不能被重写。

C:它修饰的变量,是一个常量。

(3)面试相关:

A:局部变量

a:基本类型 值不能发生改变

b:引用类型 地址值不能发生改变,但是对象的内容是可以改变的

B:初始化时机

a:只能初始化一次。

b:常见的给值

定义的时候。(推荐)

构造方法中。

2:多态(掌握)

(1)同一个对象在不同时刻体现出来的不同状态。

(2)多态的前提:

A:有继承或者实现关系。

B:有方法重写。

C:有父类或者父接口引用指向子类对象。

多态的分类:

a:具体类多态

class Fu {}

class Zi extends Fu {}

Fu f = new Zi();

b:抽象类多态

abstract class Fu {}

class Zi extends Fu {}

Fu f = new Zi();

c:接口多态

interface Fu {}

class Zi implements Fu {}

Fu f = new Zi();

(3)多态中的成员访问特点

A:成员变量

编译看左边,运行看左边

B:构造方法

子类的构造都会默认访问父类构造

C:成员方法

编译看左边,运行看右边

D:静态方法

编译看左边,运行看左边

为什么?

因为成员方法有重写。

(4)多态的好处:

A:提高代码的维护性(继承体现)

B:提高代码的扩展性(多态体现)

(5)多态的弊端:

父不能使用子的特有功能。

现象:

子可以当作父使用,父不能当作子使用。

(6)多态中的转型

A:向上转型

从子到父

B:向下转型

从父到子

(7)孔子装爹的案例帮助大家理解多态

(8)多态的练习

A:猫狗案例

B:老师和学生案例


3:抽象类(掌握)

(1)把多个共性的东西提取到一个类中,这是继承的做法。

  但是呢,这多个共性的东西,在有些时候,方法声明一样,但是方法体。

  也就是说,方法声明一样,但是每个具体的对象在具体实现的时候内容不一样。

  所以,我们在定义这些共性的方法的时候,就不能给出具体的方法体。

  而一个没有具体的方法体的方法是抽象的方法。

  在一个类中如果有抽象方法,该类必须定义为抽象类。

(2)抽象类的特点

A:抽象类和抽象方法必须用关键字abstract修饰

B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类

C:抽象类不能实例化

D:抽象类的子类

a:是一个抽象类。

b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。

(3)抽象类的成员特点:

A:成员变量

有变量,有常量

B:构造方法

有构造方法

C:成员方法

有抽象, 强制要求子类做的事情

有非抽象  子类继承的事情,提高代码的复用性

(4)抽象类的练习

A:猫狗案例练习

B:老师案例练习

C:学生案例练习

D:员工案例练习

(5)抽象类的几个小问题

A:抽象类有构造方法,不能实例化,那么构造方法有什么用?

用于子类访问父类数据的初始化

B:一个类如果没有抽象方法,却定义为了抽象类,有什么用?

为了不让创建对象

C:abstract不能和哪些关键字共存

a:final冲突

b:private 冲突

c:static 无意义


4:接口(掌握)

(1)回顾猫狗案例,它们仅仅提供一些基本功能。

  比如:猫钻火圈,狗跳高等功能,不是动物本身就具备的,

  是在后面的培养中训练出来的,这种额外的功能,java提供了接口表示。

(2)接口的特点:

A:接口用关键字interface修饰

interface 接口名 {}

B:类实现接口用implements修饰

class 类名 implements 接口名 {}

C:接口不能实例化

D:接口的实现类

a:是一个抽象类。

b:是一个具体类,这个类必须重写接口中的所有抽象方法。

(3)接口的成员特点:

A:成员变量

只能是常量

默认修饰符:public static final

B:构造方法

没有构造方法

C:成员方法

只能是抽象的

默认修饰符:public abstract

(4)类与类,类与接口,接口与接口

A:类与类

继承关系,只能单继承,可以多层继承

B:类与接口

实现关系,可以单实现,也可以多实现。

还可以在继承一个类的同时,实现多个接口

C:接口与接口

继承关系,可以单继承,也可以多继承

(5)抽象类和接口的区别(自己补齐)?

A:成员区别

抽象类:

接口:

B:关系区别:

类与类:

类与接口:

接口与接口:

C:设计理念不同

抽象类:is a,抽象类中定义的是共×××。

接口:like a,接口中定义的是扩展功能。

(6)练习:

A:猫狗案例,加入跳高功能

B:老师和学生案例,加入抽烟功能0


#####################################################################################


1:final关键字可以干什么?有什么特点?

最终的意思。可以修饰类,方法,变量。

它修饰类,类不能被继承

它修饰方法,方法不能被重写

它修饰变量,变量是常量


2:final关键字的面试题?

A:修饰局部变量

基本类型:值不能改变

引用类型:地址值不能改变

B:初始化时机

定义的时候

构造方法中

3:多态是什么,前提是什么?

同一个对象在不同时刻表现出来的不同的状态

A:有继承或者实现关系

B:有方法的重写

C:有父类或者父接口引用指向子类对象


4:多态中成员访问的特点?

成员变量

编译看左边,运行看左边

成员方法

编译看左边,运行看右边

静态方法

编译看左边,运行看左边


5:多态的好处及弊端?如何解决多态的弊端?

好处:

维护性和扩展性

弊端:父类不能使用子类特有功能

如何解决呢?

A:创建子类对象。(在内存中会多了一个对象)

B:向下转型


6:什么是向上转型?什么是向下转型?

子 - 父

父 - 子


多态的问题理解:

class 孔子爹 {

public int age = 40;

public void teach() {

System.out.println("讲解JavaSE");

}

}

class 孔子 extends 孔子爹 {

public int age = 20;

public void teach() {

System.out.println("讲解论语");

}

public void playGame() {

System.out.println("英雄联盟");

}

}

//Java培训特别火,很多人来请孔子爹去讲课,这一天孔子爹被请走了

//但是还有人来请,就剩孔子在家,价格还挺高。孔子一想,我是不是可以考虑去呢?

//然后就穿上爹的衣服,带上爹的眼睛,粘上爹的胡子。就开始装爹

//向上转型

孔子爹 k爹 = new 孔子();

//到人家那里去了

System.out.println(k爹.age); //40

k爹.teach(); //讲解论语

//k爹.playGame(); //这是儿子才能做的

//讲完了,下班回家了

//脱下爹的装备,换上自己的装备

//向下转型

孔子 k = (孔子) k爹; 

System.out.println(k.age); //20

k.teach(); //讲解论语

k.playGame(); //英雄联盟


8:抽象类概述及其特点?

抽象类:继承的时候,提取了多个方法,而有些方法不是每个子类都是一模一样的实现,

       这个时候,就应该把这样的方法不提供具体实现,而不提供具体实现的方法是一个抽象方法。

在一个类中,如果有抽象方法,该类必须定义为抽象类。

特点:

A:抽象类或者抽象方法由abstract修饰

B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类

C:抽象类不能实例化

D:抽象类的子类

a:是抽象类

b:是具体类,就要重写所有抽象方法

9:抽象类成员特点?

A:成员变量

有变量,有常量

B:构造方法

有。用于子类访问父类数据的初始化

C:成员方法

有抽象方法,有非抽象方法


10:抽象类练习?


11:抽象类的小问题

A:一个类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?

B:abstract不能和哪些关键字共存

final

static

private


12:接口的概述及其特点?

接口:某个继承体系需要扩展功能的时候,就应该实现接口。

特点:

A:接口用interface修饰

B:类实现接口用implements修饰

C:接口不能实例化

D:接口的实现

a:抽象类

b:具体类,重写接口中的所有抽象方法


13:接口的成员特点?

A:成员变量 静态常量

B:成员方法 抽象的


14:抽象类和接口的区别?

A:成员区别

    

    抽象类:

成员变量:可以变量,也可以常量

构造方法:有

成员方法:可以抽象,也可以非抽象

接口:

成员变量:只可以常量

成员方法:只可以抽象

B:关系区别

    类与类

继承,单继承

类与接口

实现,单实现,多实现

接口与接口

继承,单继承,多继承

C:设计理念区别

"is a"

"like a"

    抽象类 被继承体现的是:”is a”的关系。抽象类中定义的是该继承体系的共×××。

接口 被实现体现的是:”like a”的关系。接口中定义的是该继承体系的扩展功能。

15:接口的练习?


16:案例

猫狗案例,加入跳高的额外功能

老师和学生案例,加入抽烟的额外功能

教练和运动员案例(学生分析然后讲解)


抽象类练习:

//定义抽象类
abstract class Animal{
	private String name;
	private int age;
	public Animal(){}
	public Animal(String name,int age ){
		this.name=name;
		this.age=age;
	}
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name=name;
	}
	public int getAge(){
		return age;
	}
	public void setAge(int age){
		this.age=age;
	}	
	//定义抽象方法
	public abstract  void show();
}
class Dog extends Animal{
	public Dog(){}
	public Dog(String name,int age){
		super(name,age);		
	}
	public  void show(){
		System.out.println("小狗吃骨头");
	}
}
class Cat extends Animal{
	public Cat(){}
	public Cat(String name,int age){
		super(name,age);
	}
	public void show(){
		System.out.println("小猫吃鱼");
	}
}
public class Test {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Animal d=new Dog("旺财",3);
		Animal c=new Cat("咪咪",2);
		d.show();
		System.out.println(d.getName()+"-----"+d.getAge());
		c.show();
		Animal d2=new Dog();
		d2.setAge(4);
		d2.setName("德福");
		System.out.println(d2.getName()+"-----"+d2.getAge());
		d2.show();
		Animal c2=new Cat();
		c2.setAge(3);
		c2.setName("花花");
		System.out.println(c2.getName()+"-----"+c2.getAge());
		c2.show();
	}
}

输出:

小狗吃骨头

旺财-----3

小猫吃鱼

德福-----4

小狗吃骨头

花花-----3

小猫吃鱼


Test2

//定义抽象类
abstract class Teacher{
	private String name;
	private int age;
	public Teacher(){}
	public Teacher(String name,int age){
		this.name=name;
		this.age=age;
	}
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name=name;
	}
	public int getAge(){
		return age;
	}
	public void setAge(int age){
		this.age=age;
	}
	public abstract void teach();
}
class LowTeacher extends Teacher{
	public LowTeacher(){}
	public LowTeacher(String name,int age){
		super(name,age);
	}
	public void teach(){
		System.out.println("教你看书");
	}
}
class HighTeacher extends Teacher{
	public HighTeacher(){}
	public HighTeacher(String name,int age){
		super(name,age);
	}
	public void teach(){
		System.out.println("教你找书");
	}
}
public class Test {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Teacher t=new LowTeacher("二狗子",35);
		Teacher t2=new LowTeacher();
		t2.setName("大壮");
		t2.setAge(34);
		System.out.println(t.getName()+"-----"+t.getAge());
		t.teach();
		System.out.println(t2.getName()+"-----"+t2.getAge());
		t2.teach();
		Teacher t3=new HighTeacher("小牛",29);
		System.out.println(t3.getName()+"-----"+t3.getAge());
		t3.teach();
	}
}

输出:

二狗子-----35

教你看书

大壮-----34

教你看书

小牛-----29

教你找书


Test3

//定义抽象类
abstract class Student{
	//私有变量,姓名,年龄,班级
	private String name;
	private int age;
	private String grade;
	//空构造函数
	public Student(){}
	//带参构造函数
	public Student(String name,int age,String grade){
		this.name=name;
		this.age=age;
		this.grade=grade;
	}
	// getter(),setter()
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name=name;
	}
	public int getAge(){
		return age;
	}
	public void setAge(int age){
		this.age=age;
	}
	public String getGrade(){
		return grade;
	}
	public void setGrade(String grade){
		this.grade=grade;
	}
	//两个抽象方法
	public abstract void study();
	public abstract void eat();
}
//子类继承父类
class Ystu extends Student{
	public Ystu(){}
	public Ystu(String name,int age,String grade){
		//super关键字继承父类变量成员
		super(name,age,grade);
	}
	//重写两个抽象方法
	public void study(){
		System.out.println("低档学生学123");
	}
	public void eat(){
		System.out.println("低档学生吃炒饭");
	}
}
class Ostu extends Student{
	public Ostu(){}
	public Ostu(String name,int age,String grade){
		super(name,age,grade);
	}
	public void study(){
		System.out.println("高档学生学ABC");
	}
	public void eat(){
		System.out.println("高档学生吃白菜帮子");
	}
}
public class Test {
	public static void main(String[] args) {
		Student s=new Ystu("小明",12,"六年级");
		Student s2=new Ystu();
		s2.setName("小红");
		s2.setAge(11);
		s2.setGrade("五年级");
		System.out.println(s.getName()+"\t"+s.getAge()+"\t"+s.getGrade());
		s.study();
		s.eat();
		System.out.println(s2.getName()+"\t"+s2.getAge()+"\t"+s2.getGrade());
		s2.study();
		s2.eat();		
		Student s3=new Ostu("大黄",19,"大一");
		System.out.println(s3.getName()+"\t"+s3.getAge()+"\t"+s3.getGrade());
		s3.study();
		s3.eat();
	}
}

输出:

小明    12    六年级

低档学生学123

低档学生吃炒饭

小红    11    五年级

低档学生学123

低档学生吃炒饭

大黄    19    大一

高档学生学ABC

高档学生吃白菜帮子


Test4

假如我们在开发一个系统时需要对员工类进行设计,员工包含3个属性:姓名、工号以及工资。

经理也是员工,除了含有员工的属性外,另为还有一个奖金属性。

请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问

//定义抽象类
abstract class Employee{
	private String name;
	private int number;
	private int salary;
	
	public Employee(){}
	public Employee(String name,int number,int salary){
		this.name=name;
		this.number=number;
		this.salary=salary;
	}
	/*public Employee(String name,int number,int salary,int bonus){
		this.name=name;
		this.number=number;
		this.salary=salary;
		this.bonus=bonus;
	}*/
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name=name;
	}
	public int getNumber(){
		return number;
	}
	public void setNumber(int number){
		this.number=number;
	}
	public int getSalary(){
		return salary;
	}
	public void setSalary(int salary){
		this.salary=salary;
	}
	
	//抽象方法
	public abstract void show();
}
//普通员工类
class Worker extends Employee{
	public Worker(){}
	public Worker(String name,int number,int salary){
		super(name,number,salary);
	}
	public void show(){
		System.out.println("我叫"+this.getName()+",工号是"+this.getNumber()+",工资是"+this.getSalary()+",我没有奖金");		
	}
}
//经理类
class Manager extends Employee{
	//增加一个奖金的变量
	private int bonus;
	public Manager(){}
	public Manager(String name,int number,int salary,int bonus){
		super(name,number,salary);
		this.bonus=bonus;
	}
	public int getBonus(){
		return bonus;
	}
	public void setBonus(int bonus){
		this.bonus=bonus;
	}
	public void show(){
		System.out.println("我叫"+this.getName()+",工号是"+this.getNumber()+",工资是"+this.getSalary()+",我每个月奖金"+this.getBonus());		
	}
}
public class Test {
	public static void main(String[] args) {
		//员工类对象
		Employee e=new Worker();
		e.setName("屌丝");
		e.setNumber(748);
		e.setSalary(3500);
		e.show();
		//经理类对象
		//由于bonus变量在子类中,只能用子类创建对象调用getBonus()方法
		//或者将bonus变量放在父类中
		Manager e2=new Manager();
		e2.setName("Stephen");
		e2.setNumber(13);
		e2.setSalary(8000);
		e2.setBonus(3000);
		e2.show();
		Manager m=new Manager("武大郎",19,5000,2000);
		m.show();
	}
}

输出:

我叫屌丝,工号是748,工资是3500,我没有奖金

我叫Stephen,工号是13,工资是8000,我每个月奖金3000

我叫武大郎,工号是19,工资是5000,我每个月奖金2000


接口练习:

猫狗加入跳高功能:

//跳高的接口
interface Jump{
	//跳高方法
	public abstract void jump();
}
//抽象类
abstract class Animal{
	private String name;
	private int age;
	public Animal(){}
	public Animal(String name,int age){
		this.name=name;
		this.age=age;
	}
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name=name;
	}
	public int getAge(){
		return age;
	}
	public void setAge(int age){
		this.age=age;
	}
	//吃饭的抽象方法
	public abstract void eat();
	//睡觉的普通方法
	public void sleep(){
		System.out.println("小动物该睡觉了");
	}
}
//普通小猫类
class Cat extends Animal{
	public Cat(){}
	public Cat(String name,int age){
		super(name,age);
	}
	public void eat(){
		System.out.println("小猫吃鱼");
	}
	public void sleep(){
		System.out.println("小猫该睡觉了");
	}
}
//跳高小猫类,继承猫类和跳高接口
class CatJump extends Cat implements Jump{
	public CatJump(){}
	public CatJump(String name,int age){
		super(name,age);
	}
	//重写接口抽象方法
	public void jump(){
		System.out.println("小猫会跳高了");
	}
}
//普通小狗类
class Dog extends Animal{
	public Dog(){}
	public Dog(String name,int age){
		super(name,age);
	}
	public void eat(){
		System.out.println("小狗吃骨头");
	}
	public void sleep(){
		System.out.println("小狗该睡觉了");
	}
}
//跳高小狗类
class DogJump extends Dog implements Jump{
	public DogJump(){}
	public DogJump(String name,int age){
		super(name,age);
	}
	public void jump(){
		System.out.println("小狗会跳高了");
	}
}
public class ZuoYe {
	public static void main(String[] args) {
		//定义跳高猫
		CatJump cj=new CatJump();
		cj.setName("咪咪");
		cj.setAge(3);
		System.out.println(cj.getName()+"\t"+cj.getAge());
		cj.eat();
		cj.sleep();
		cj.jump();
		System.out.println("+++++++++++++++++++++++");
		DogJump dj=new DogJump("旺财",4);
		System.out.println(dj.getName()+"\t"+dj.getAge());
		dj.eat();
		dj.sleep();
		dj.jump();
	}		
}

输出:

咪咪    3

小猫吃鱼

小猫该睡觉了

小猫会跳高了

+++++++++++++++++++++++

旺财    4

小狗吃骨头

小狗该睡觉了

小狗会跳高了


老师学生案例,加入装逼功能

//定义装逼的接口
interface Zhuangbi{
	public abstract void zhuangbi();
}
//定义抽象类
abstract class Person{
	private String name;
	private int age;
	private String number;
	public Person(){}
	public Person(String name,int age,String number){
		this.name=name;
		this.age=age;
		this.number=number;
	}
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name=name;
	}
	public int getAge(){
		return age;
	}
	public void setAge(int age){
		this.age=age;
	}
	public String getNumber(){
		return number;
	}
	public void setNumber(String number){
		this.number=number;
	}
	//定义抽象方法
	public abstract void work();
	//定义普通方法
	public void eat(){
		System.out.println("吃饭");
	}
}
//定义普通老师类
class Teacher extends Person{
	public Teacher(){}
	public Teacher(String name,int age,String number){
		super(name,age,number);
	}
	public void work(){
		System.out.println("老师教书");
	}
	public void eat(){
		System.out.println("老师吃屎");
	}
}
//定义装逼老师类
class TeacherZhuangbi extends Teacher implements Zhuangbi{
	public TeacherZhuangbi(){}
	public TeacherZhuangbi(String name,int age,String number){
		super(name,age,number);
	}
	public void zhuangbi(){
		System.out.println("老师学会装逼了!");
	}
}
//定义普通学生类
class Student extends Person{
	public Student(){}
	public Student(String name,int age,String number){
		super(name,age,number);
	}
	public void work(){
		System.out.println("学生学习");
	}
	public void eat(){
		System.out.println("学生吃×××毛啊");
	}
}
//装逼学生类
class StudentZhuangbi extends Student implements Zhuangbi{
	public StudentZhuangbi(){}
	public StudentZhuangbi(String name ,int age,String number){
		super(name,age,number);
	}
	public void zhuangbi(){
		System.out.println("学生还学会装逼了?");
	}
}
public class ZuoYe {
	public static void main(String[] args) {
		TeacherZhuangbi tz=new TeacherZhuangbi();
		tz.setName("牛师傅");
		tz.setAge(48);
		tz.setNumber("009");
		System.out.println(tz.getName()+"\t"+tz.getAge()+"\t"+tz.getNumber());
		tz.work();
		tz.eat();
		tz.zhuangbi();
		System.out.println("+++++++++++++++++++++++++");
		StudentZhuangbi sz=new StudentZhuangbi("小瘪三",15,"213");
		System.out.println(sz.getName()+"\t"+sz.getAge()+"\t"+sz.getNumber());
		sz.work();
		sz.eat();
		sz.zhuangbi();
	}		
}

输出:

牛师傅    48    009

老师教书

老师吃屎

老师学会装逼了!

+++++++++++++++++++++++++

小瘪三    15    213

学生学习

学生吃×××毛啊

学生还学会装逼了?

/*
 * 乒乓球运动员和篮球运动员
 * 乒乓球教练和篮球教练
 * 乒乓球相关的人都要学英语
 * 	此例将学英语和教设置为接口,运动员和教练分四个类
 * 另一种将英语设置为接口,
 * 				人
 * 		运动员                  教练
 * 乒乓         篮球              乒乓            篮球
 * */
//定义英语接口
interface English{
	public abstract void english();
}
//定义教练接口
interface Teach{
	public abstract void teach();
}
//定义抽象类 人
abstract class Person{
	private String name;
	private int age;
	private String number;
	public Person(){}
	public Person(String name,int age,String number){
		this.name=name;
		this.age=age;
		this.number=number;
	}
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name=name;
	}
	public int getAge(){
		return age;
	}
	public void setAge(int age){
		this.age=age;
	}
	public String getNumber(){
		return number;
	}
	public void setNumber(String number){
		this.number=number;
	}
	public abstract void eat();
	public void show(){
		System.out.println("我是人");
	}
}
//乒乓球运动员
class PingPangSporter extends Person implements English{
	public PingPangSporter(){}
	public PingPangSporter(String name,int age,String number){
		super(name,age,number);
	}
	public void eat(){
		System.out.println("乒乓球运动员吃胡萝卜");
	}
	public void show(){
		System.out.println("我是乒乓球运动员");
	}
	public void english(){
		System.out.println("我学会英语了");
	}
}
//乒乓球教练 继承人类,实现双接口: 教 和英语
class PingPangTeacher extends Person implements Teach,English{
	public PingPangTeacher(){}
	public PingPangTeacher(String name,int age,String number){
		super(name,age,number);
	}
	public void eat(){
		System.out.println("乒乓球教练吃白菜帮子");
	}
	public void show(){
		System.out.println("我是乒乓球教练张怡宁");
	}
	public void english(){
		System.out.println("我学会英语了");
	}
	public void teach(){
		System.out.println("我会教乒乓球了");
	}
}
//篮球运动员
class BasketballSporter extends Person{
	public BasketballSporter(){}
	public BasketballSporter(String name,int age,String number){
		super(name,age,number);
	}
	public void eat(){
		System.out.println("篮球运动员吃榨菜");
	}
	public void show(){
		System.out.println("我是篮球运动员");
	}
}
//篮球教练 继承  人  类,  实现单接口: 教
class BasketballTeacher extends Person implements Teach{
	public BasketballTeacher(){}
	public BasketballTeacher(String name,int age,String number){
		super(name,age,number);
	}
	public void eat(){
		System.out.println("篮球教练吃窝头");
	}
	public void show(){
		System.out.println("我是篮球教练史蒂芬森");
	}
	public void teach(){
		System.out.println("我会教篮球了");
	}
}

public class ZuoYe {
	public static void main(String[] args) {
		PingPangSporter ps=new PingPangSporter();
		ps.setName("福原爱");
		ps.setAge(25);
		ps.setNumber("0102");
		System.out.println(ps.getName()+"\t"+ps.getAge()+"\t"+ps.getNumber());
		ps.eat();
		ps.show();
		ps.english();
		System.out.println("+++++++++++++++++++++++++++");
		PingPangTeacher pt=new PingPangTeacher();
		pt.setName("张怡宁");
		pt.setAge(29);
		pt.setNumber("0106");
		System.out.println(pt.getName()+"\t"+pt.getAge()+"\t"+pt.getNumber());
		pt.eat();
		pt.show();
		pt.teach();
		pt.english();
		System.out.println("+++++++++++++++++++++++++++");
		BasketballSporter bs=new BasketballSporter("脑残乔",29,"01004");
		System.out.println(bs.getName()+"\t"+bs.getAge()+"\t"+bs.getNumber());
		bs.eat();
		bs.show();
		System.out.println("+++++++++++++++++++++++++++");
		BasketballTeacher bt=new BasketballTeacher("史蒂芬森",28,"01009");
		System.out.println(bt.getName()+"\t"+bt.getAge()+"\t"+bt.getNumber());
		bt.eat();
		bt.show();
		bt.teach();		
	}		
}

输出:

福原爱    25    0102

乒乓球运动员吃胡萝卜

我是乒乓球运动员

我学会英语了

+++++++++++++++++++++++++++

张怡宁    29    0106

乒乓球教练吃白菜帮子

我是乒乓球教练张怡宁

我会教乒乓球了

我学会英语了

+++++++++++++++++++++++++++

脑残乔    29    01004

篮球运动员吃榨菜

我是篮球运动员

+++++++++++++++++++++++++++

史蒂芬森   28    01009

篮球教练吃窝头

我是篮球教练史蒂芬森

我会教篮球了