Java面向对象 - 封装、继承和多态头歌习题

仅为个人答案 仅供参考 欢迎各位大神来纠错和提供其他不一样的代码！！！

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.setName("张三");

        p.setAge(18);

        // 调用Person类中的talk()方法

        p.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;

        }

    void talk() {

        System.out.println("我是：" + name + "，今年：" + 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 cat=new Cat("大花猫",6);

    cat.voice();

    cat.eat();

    cat.say();

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

        // 实例化一个Dog对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息

        /********* begin *********/

    Dog dog=new Dog("大黑狗",8);

    dog.voice();

    dog.eat();

    dog.say();

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

    }

}

class Animal {

    /********* begin *********/

    public String name;

    public int age;

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

}

class Cat extends Animal {

    // 定义Cat类的voice()和eat()方法

    /********* begin *********/

    public Cat(String name,int age){

        this.name=name;

        this.age=age;

    }

    public void voice(){

        System.out.println(name+"喵喵叫");

    }

    public void eat(){

        System.out.println(name+"吃鱼");

    }

    public void say(){

        System.out.println(name+age+"岁");

    }

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

}

class Dog extends Animal {

    // 定义Dog类的voice()和eat()方法

    /********* begin *********/

    public Dog(String name,int age){

        this.name=name;

        this.age=age;

    }

    public void voice(){

        System.out.println(name+"汪汪叫");

    }

    public void eat(){

        System.out.println(name+"吃骨头");

    }

    public void say(){

        System.out.println(name+age+"岁");

    }

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

}

3.

根据提示，在右侧编辑器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赋值，打印输出信息

        Student s=new Student("张三",18);

        /********* begin *********/

        s.school="哈佛大学";

        s.show();

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

    }

}

class Person {

    /********* begin *********/

    public String name;

    public int age;

    public Person(String name,int age){

        this.name=name;

        this.age=age;

    }

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

}

class Student extends Person {

    /********* begin *********/

    public Student(String name,int age){

        super(name,age);

}

    public String school;

    public void show(){

    System.out.println("姓名："+name+"，年龄："+age+"，学校："+school);

}

    /********* 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 *********/

    public String school;

    Student(String name,int age,String school){

        this.name=name;

        this.age=age;

        this.school=school;

    }

    public void talk(){

        System.out.println("我是：" + name + "，今年：" + age + "岁，我在" + 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 a=new Student("张三",20,"学生");

        a.talk();

        // 分别调用各自类中被复写的talk()方法 打印信息。    

        Worker b=new Worker("李四",30,"工人");

        b.talk();

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

       

    }

}

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

abstract class Person {

    /********* begin *********/

    public String name;

    public int age;

    public 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;

}

public 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;

}

public void talk(){

    System.out.println("工人——>姓名：" +name+ "，年龄：" + age + "，职业：" + occupation + "！");

}

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

}

6.

根据提示，在右侧编辑器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 {

    final int speedlimit = 90;

    void run() {

        System.out.println("speedlimit=120");

    }

}

class Bike2 {

    final void run() {

        System.out.println("running");

    }

}

class Honda extends Bike1 {

    void run() {

        System.out.println("running safely with 100kmph");

    }

}

final class Bike3 {

}

class Yamaha extends Bike1 {

    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 *********/

final  String name="张三";

final  int age=18;

final  String occupation="学生";

abstract 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 *********/

    Dog dog=new Dog();

    dog.eat();

    Cat cat=new Cat();

    cat.eat();

    Lion lion=new Lion();

    lion.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 *********/

}