面向对象_3

最新推荐文章于 2022-12-18 23:28:24 发布

故意的是吧

最新推荐文章于 2022-12-18 23:28:24 发布

阅读量339

点赞数

分类专栏： JAVA 文章标签：抽象类接口

JAVA 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

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

篮球教练吃窝头

我是篮球教练史蒂芬森

我会教篮球了

故意的是吧

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象_3

1:final关键字(掌握)(1)是最终的意思，可以修饰类，方法，变量。(2)特点：A:它修饰的类，不能被继承。B:它修饰的方法，不能被重写。C:它修饰的变量，是一个常量。(3)面试相关：A:局部变量a:基本类型值不能发生改变b:引用类型地址值不能发生改变，但是对象的内容是可以改变的B:初始化时机a:只能初
复制链接

扫一扫