湖北师范大学-Java面向对象 - 封装、继承和多态

目录

第1关：什么是封装，如何使用封装

第2关：什么是继承，怎样使用继承

第3关：super关键字的使用

第4关：方法的重写与重载

第5关：抽象类

第6关：final关键字的理解与使用

第7关：接口

第8关：什么是多态，怎么使用多态

---

第1关：什么是封装，如何使用封装

编程要求
根据提示，在右侧编辑器Begin-End处补充代码：

声明一个Person类，私有化属性name和age，并将字段封装起来；

在Person类中定义一个talk()方法，打印姓名和年龄信息；

在main方法中声明并实例化一Person对象p，给p中的属性赋值，调用talk()方法打印  我是：张三，今年：18岁。

测试说明
测试输入： 无
预期输出：
我是：张三，今年：18岁

开始你的任务吧，祝你成功！

package case1;

public class TestPersonDemo {
	public static void main(String[] args) {
		/********* begin *********/
		// 声明并实例化一Person对象p
Person p=new Person();
		// 给p中的属性赋值
p.set("张三",18);
		// 调用Person类中的talk()方法
p.talk();
		/********* end *********/

	}
}

// 在这里定义Person类
class Person {
	/********* begin *********/
private String name;
private int age;
public void set(String name,int age){
    this.name=name;
    this.age=age;
}

void talk(){
    System.out.println("我是："+this.name+"，今年："+this.age+"岁");
}
	/********* end *********/
}

第2关：什么是继承，怎样使用继承

编程要求
根据提示，在右侧编辑器Begin-End处补充代码：

声明一个Animal类，将属性name和age封装起来，提供对外的公共访问方法；

声明一个Cat类和Dog类，都继承Animal类，分别定义各自的voice方法和eat方法；

在main方法中分别实例化一个Cat对象和Dog对象，设置各自的属性并调用这两个方法，再打印出名字和年龄信息；

具体具体输出要求请看测试说明。

测试说明
测试输入：无
预期输出： 
大花猫喵喵叫
大花猫吃鱼
大花猫6岁
大黑狗汪汪叫
大黑狗吃骨头
大黑狗8岁

开始你的任务吧，祝你成功！

package case2;

public class extendsTest {
	public static void main(String args[]) {
		// 实例化一个Cat对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
		/********* begin *********/
       
Cat c=new Cat();
c.name="大花猫";
c.age=6;
c.voice();
c.eat();
System.out.println(c.name+c.age+"岁");
		/********* end *********/

		// 实例化一个Dog对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
		/********* begin *********/
Dog d=new Dog();
d.name="大黑狗";
d.age=8;
d.voice();
d.eat();
System.out.println(d.name+d.age+"岁");
		/********* end *********/

	}
}

class Animal {
	/********* begin *********/
public String name;
public int age;


	/********* end *********/

}

class Cat extends Animal {
	// 定义Cat类的voice()和eat()方法
	/********* begin *********/
   
public void voice(){
    System.out.println(name+"喵喵叫");
}
public void eat(){
    System.out.println(name+"吃鱼");
}
	/********* end *********/
}

class Dog extends Animal {
	// 定义Dog类的voice()和eat()方法
	/********* begin *********/
public void voice(){
    System.out.println(name+"汪汪叫");
}
public void eat(){
    System.out.println(name+"吃骨头");
}
	/********* end *********/
}

第3关：super关键字的使用

编程要求
根据提示，在右侧编辑器Begin-End处补充代码：

声明一个名为Person的类，里面有name与age两个属性，并声明一个含有两个参数的构造方法；

声明一个名为Student的类，此类继承自Person类，添加一个属性school，在子类的构造方法中调用父类中有两个参数的构造方法；

实例化一个Student类的对象s，为Student对象s中的school赋值，打印输出姓名：张三，年龄：18，学校：哈佛大学。

测试说明
测试输入：无
预期输出：
姓名：张三，年龄：18，学校：哈佛大学

开始你的任务吧，祝你成功！

package case3;

public class superTest {
	public static void main(String[] args) {
		// 实例化一个Student类的对象s，为Student对象s中的school赋值，打印输出信息
		/********* begin *********/
Student s=new Student();
s.school="哈佛大学";
System.out.println("，学校："+s.school);
		/********* end *********/
	}
}

class Person {
	/********* begin *********/
String name;
int age;
Person(String name,int age){
this.name=name;
this.age=age;
}
	/********* end *********/
}

class Student extends Person {
	/********* begin *********/
String school;
Student(){
    super("张三",18);
System.out.print("姓名："+name+"，年龄："+age);
}
	/********* end *********/
}

第4关：方法的重写与重载

编程要求
根据提示，在右侧编辑器补充代码。

声明一个名为Person的类，里面声明name与age两个属性，定义talk()方法返回姓名和年龄信息；

声明一个名为Student的类，此类继承自Person类，添加school属性，声明带三个参数的构造方法，复写talk()方法，在该方法中调用父类的talk()方法，返回姓名、年龄和学校信息；

实例化子类对象s，调用talk()方法打印我是：张三，今年：18岁，我在哈佛大学上学。

测试说明
测试输入： 无
预期输出：
我是：张三，今年：18岁，我在哈佛大学上学

开始你的任务吧，祝你成功！

package case4;

public class overridingTest {
	public static void main(String[] args) {
		// 实例化子类对象s，调用talk()方法打印信息
		/********* begin *********/
Student s=new Student("张三",18,"哈佛大学");
s.talk();
		/********* end *********/
		
	}
}

class Person {
	/********* begin *********/
String name;
int age;
public void talk(){
    System.out.println("我是："+name+"，今年："+age+"岁");
}
	/********* end *********/
}

class Student extends Person {
	/********* begin *********/
String school;
Student(String name,int age,String school){
    this.name=name;
    this.age=age;
    this.school=school;
}
public void talk(){
    System.out.println("我是："+this.name+"，今年："+this.age+"岁，我在"+this.school+"上学");
}
	/********* end *********/
}

第5关：抽象类

编程要求
根据提示，在右侧编辑器补充代码：

声明一个名为Person的抽象类，在Person类中声明了三个属性name、age和occupation和一个抽象方法talk()；

声明一个Student类和一个Worker类，都继承自Person类，添加带有三个参数的构造方法；

分别实例化Student类与Worker类的对象，分别调用各自类中被复写的talk()方法打印输出信息；

具体输出要求请看测试说明。

测试说明
测试输入： 无
预期输出：
学生——>姓名：张三，年龄：20，职业：学生！
工人——>姓名：李四，年龄：30，职业：工人！

开始你的任务吧，祝你成功！

package case5;

public class abstractTest {
	public static void main(String[] args) {
		/********* begin *********/
		// 分别实例化Student类与Worker类的对象，并调用各自构造方法初始化类属性。
		Student s=new Student("张三",20,"学生");
        s.talk();
        Worker w=new Worker("李四",30,"工人");
        w.talk();
		// 分别调用各自类中被复写的talk()方法 打印信息。
		
		/********* end *********/
		
	}
}

// 声明一个名为Person的抽象类，在Person中声明了三个属性name age occupation和一个抽象方法——talk()。
abstract class Person {
	/********* begin *********/
String name;
int age;
String occupation;
void talk(){}
	/********* end *********/
}

// Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Student extends Person {
	/********* begin *********/
Student(String name,int age,String occupation){
    this.name=name;
    this.age=age;
    this.occupation=occupation;
}
void talk(){
    System.out.println("学生——>姓名："+this.name+"，年龄："+this.age+"，职业："+this.occupation+"！");
}
	/********* end *********/
}

// Worker类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Worker extends Person {
	/********* begin *********/
Worker(String name,int age,String occupation){
    this.name=name;
    this.age=age;
    this.occupation=occupation;
}
void talk(){
    System.out.println("工人——>姓名："+this.name+"，年龄："+this.age+"，职业："+this.occupation+"！");
}
	/********* end *********/

}

第6关：final关键字的理解与使用

编程要求
根据提示，在右侧编辑器Begin-End处补充代码:

仔细阅读代码，在右侧编辑器中调整代码使程序能正确编译运行;

具体输出要求请看测试说明。

测试说明
测试输入：无
预期输出：
speedlimit=120
running safely with 100kmph
running safely with 100kmph

开始你的任务吧，祝你成功！

package case6;

public class finalTest {
	public static void main(String args[]) {
		Bike1 obj = new Bike1();
		obj.run();

		Honda honda = new Honda();
		honda.run();

		Yamaha yamaha = new Yamaha();
		yamaha.run();
	}
}
//不可以修改 final 变量的值
// final方法,不可以重写
//// 不可以扩展 final 类
    //请在此添加你的代码
    /********** Begin *********/
	class Bike1 {
	 int speedlimit = 90;

	void run() {
		speedlimit = 120; 
		System.out.println("speedlimit=120");
	}

}

class Bike2 {
	 void run() {
		System.out.println("running");
	}
}

class Honda extends Bike2 {
	void run() { 
		System.out.println("running safely with 100kmph");
	}

}

 class Bike3 {
}

class Yamaha extends Bike3 { 
	void run() {
		System.out.println("running safely with 100kmph");
	}

}
    /********** End **********/

第7关：接口

编程要求
根据提示，在右侧编辑器补充代码：

声明一Person接口，并在里面声明三个常量：name、age、occupation，并分别赋值；

声明一Student类，此类实现Person接口，并复写Person中的talk()方法；

实例化一Student的对象s，并调用talk()方法，打印信息；

具体输出要求请看测试说明。

测试说明
测试输入：无
预期输出：
学生——>姓名：张三，年龄：18，职业：学生！

开始你的任务吧，祝你成功！

package case7;

public class interfaceTest {
	public static void main(String[] args) {
		// 实例化一Student的对象s，并调用talk()方法，打印信息
		/********* begin *********/
Student s=new Student();
s.talk();
		/********* end *********/

	}
}

// 声明一个Person接口，并在里面声明三个常量：name、age和occupation，并分别赋值，声明一抽象方法talk()
interface Person {
	/********* begin *********/
String name="张三";
int age=18;
String occupation="学生";
void talk();
	/********* end *********/
}

// Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
class Student implements Person {
	/********* begin *********/
public void talk(){
    System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
}
	/********* end *********/
}

第8关：什么是多态，怎么使用多态

编程要求
根据提示，在右侧编辑器补充代码：

声明一个Animal类，此类中定义eat()方法；

声明Dog类、Cat类、Lion类，均继承自Animal类，并复写了eat()方法；

运用多态方式实例化子类对象并调用eat()方法打印输出信息；

具体输出要求请看测试说明。

测试说明
测试输入：无
预期输出：
eating bread...
eating rat...
eating meat...

开始你的任务吧，祝你成功！

package case8;

public class TestPolymorphism {
	public static void main(String[] args) {
		// 以多态方式分别实例化子类对象并调用eat()方法
		/********* begin *********/
Animal a=new Cat();
a.eat();
Animal b=new Dog();
b.eat();
Animal c=new Lion();
c.eat();		/********* end *********/
	}
}

// Animal类中定义eat()方法
class Animal {
	/********* begin *********/
public void eat(){}
	/********* end *********/
}

// Dog类继承Animal类 复写eat()方法
class Dog extends Animal {
	/********* begin *********/
public void eat(){
    System.out.println("eating rat...");
}
	/********* end *********/
}

// Cat类继承Animal类 复写eat()方法
class Cat extends Animal {
	/********* begin *********/
public void eat(){
    System.out.println("eating bread...");
}
	/********* end *********/
}

// Lion类继承Animal类 复写eat()方法
class Lion extends Animal {
	/********* begin *********/
public void eat(){
    System.out.println("eating meat...");
}
	/********* end *********/
}