Educoder–Java面向对象（第二章）- 封装、继承和多态【笔记+参考代码】_根据提示,在右侧编辑器begin-end处补充代码:声明一个名为person的类,里面有name与

Educoder–Java面向对象（第二章）- 封装、继承和多态【笔记+参考代码】

第一关

编程要求
根据提示，在右侧编辑器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 p1=new Person();
		// 给p中的属性赋值
		String name=p1.getName();
		name="张三";
		p1.setName(name);
		int age=p1.getAge();
		age=18;
		p1.setAge(age);
		// 调用Person类中的talk()方法
		p1.talk();
		/********* end *********/
	}
}
// 在这里定义Person类
class Person {
	/********* begin *********/
	private String name;
	private int 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 void talk(){
		System.out.println("我是："+name+"，今年："+age+"岁");
	}
	/********* end *********/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

第二关

编程要求
根据提示，在右侧编辑器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("大花猫",6);
		c.voice();
		c.eat();
		c.show();
		/********* end *********/
		// 实例化一个Dog对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
		/********* begin *********/
		Dog d=new Dog("大黑狗",8);
		d.voice();
		d.eat();
		d.show();
		/********* end *********/
	}
}
class Animal {
	/********* begin *********/
	String name;
	int age;
	/********* end *********/
}
class Cat extends Animal {
	// 定义Cat类的voice()和eat()方法
	/********* begin *********/
    Cat(String name,int age){
		this.name=name;
		this.age=age;
	}
	void voice(){
		System.out.println(name+"喵喵叫");
	}
	void eat(){
		System.out.println(name+"吃鱼");
	}
	void show(){
		System.out.println(name+age+"岁");
	}
	/********* end *********/
}
class Dog extends Animal {
	// 定义Dog类的voice()和eat()方法
	/********* begin *********/
    Dog(String name,int age){
		this.name=name;
		this.age=age;
	}
	void voice(){
		System.out.println(name+"汪汪叫");
	}
	void eat(){
		System.out.println(name+"吃骨头");
	}
	void show(){
		System.out.println(name+age+"岁");
	}
	/********* end *********/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

第三关

编程要求
根据提示，在右侧编辑器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("张三",18);
		s.school="哈佛大学";
		s.print();
		/********* 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 *********/
	Student(String name,int age){
		super(name,age);
	}
	String school;
	void print(){
		System.out.println("姓名："+name+"，年龄："+age+"，学校："+school);
	}
	/********* end *********/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

第四关

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

声明一个名为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 *********/
	public String name;
	public int age;
	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;
	}
	void talk(){
		System.out.println("我是："+name+"，今年："+age+"岁，我在"+school+"上学");
	}
	/********* end *********/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

第五关

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

声明一个名为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,"学生");
		Worker w=new Worker("李四",30,"工人");
		s.talk();
		w.talk();
		// 分别调用各自类中被复写的talk()方法 打印信息。
		/********* end *********/
	}
}

// 声明一个名为Person的抽象类，在Person中声明了三个属性name age occupation和一个抽象方法——talk()。
abstract class Person {
	/********* begin *********/
	String name;
	int age;
	String occupation;
	abstract 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("学生——>姓名："+name+"，年龄："+age+"，职业："+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("工人——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
	}
	/********* end *********/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

第六关

编程要求
根据提示，在右侧编辑器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 类
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");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

第七关

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

声明一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();
		System.out.println(s.talk());
		/********* end *********/
	}
}

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

// Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
class Student implements Person {
	/********* begin *********/
	public String talk() {
        return "学生——>姓名：" + this.name + "，年龄：" + this.age + "，职业："
                + this.occupation + "！";
	}
	/********* end *********/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

第八关

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

声明一个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 Dog();
		a.eat();
		Animal b=new Cat();
		b.eat();
		Animal c=new Lion();
		c.eat();
		/********* end *********/
	}
}

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

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

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

// Lion类继承Animal类 复写eat()方法
class Lion extends Animal {
	/********* begin *********/
	public void eat(){
		System.out.println("eating meat...");
	}
	/********* end *********/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49