面向对象编程：继承与多态-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_40245464/article/details/104100798

这篇博客主要介绍了面向对象编程中的继承概念，包括构造方法、访问修饰符的作用和优先级，以及super和this关键字的使用。还涵盖了类之间的继承关系、构造器的重要性、权限控制以及代码实例，如子类重写父类方法等。同时，博客通过多道填空、判断、单选和多选题，以及代码阅读和编程实践，深入探讨了面向对象编程的实践应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

填空题

1.关于构造方法的描述：每一个类里至少有（一）个构造方法，构造方法又叫( 构造器 )

2.Java语言中访问修饰符从小到大依次为( private,default,protected,public )。

3.修饰的属性或方法只可以被本类、本包内的类使用，应选择的修饰符是( private )

4.在protected、public、 default、private这几个权限访问控制符中，访问权限最大的（ public ）访问权限最小的是( private )

5.修饰的属性或方法只可以被本类中使用，应选择的修饰符是( private )

6.面向对象中，继承需要使用到的关键字是( extends )

7.关于super关键字:在类里面使用super关键字，可以调用父类里的( 成员变量 )和( 成员方法 ) ( 构造方法 )

8.关于static关键字的使用: static修饰的方法称为( 静态方法 ), static修饰的属性称为( 静态成员变量 )

9.关于this关键字：在类里面使用this关键字，可以调用本类里的( 成员变量 或 成员方法 或 构造方法 )

10.子类继承了父类后，子类拥有父类的( 成员变量,成员方法 )

11.修饰的属性或方法只可以被本类中使用，应选择的修饰符是( private )

12哪种类成员修饰符修饰的变量只能在本类中被访问的是：( private )。

13.关于构造器说法：每个类中至少有( 1 )个构造器, 构造器是一个( 创建对象 )的途径，构造器名必须和( 类名 )相同。

14.对象的数据封装特性是：( 隐藏受保护的数据,提高安全性 )。

15.在Java语言中，( java.lang.* )包中的类是自动导入的。

16.编译Hello.java文件，需要使用的命令是( javac )

17.子类里使用( this )关键字，可以调用从父类里( 继承 )过来的方法。

18.java程序中，main方法格式为( public static void main(String[] args){} )。

19.在Java中导包的语句格式为( import 包名 )

20.第一版Java发布的时间是( 1995年 )

21.JRE和JVM和JDK直接的区别是( 名字不一样..... )

22继承使用的关键字是( extends )

23在Java中，使类中的方法不能被重写可以使用哪个关键字( private )

24子类里可以通过( this )关键字访问父类里非私有的方法和属性。

25所有Java类都从( Object ) 类继承

26( private )的访问权限是仅在本类内可用

27( static )修饰的方法称为静态方法。

二、判断题

1.自定义的类中，toString（）方法是默认重写的，不需要程序员重写 ×

2.Object类定义了toString和equals方法 √

3.构造方法不需要返回值 √

4.有一个类B，其构造方法的声明为: void B(int x) {} ×,构造方法不需要返回值

5.区分类中重载方法的依据是形参列表的类型和顺序 ×,类型和个数

6.在子类callFa方法中调用父类方法fly,代码是public void fly（）{super.fly()} ×,callFa方法

7.类实现接口的关键字是interface √

三、单选题

1.public class A {

public void run() {}

}

public class B extends A { }

public class Test {

public static void main(String[] args) {

A a = new A();

B b = new B();

} } 关于以上代码，下列描述错误的是：( C )

A a对象拥有run()方法。 B B类是A类的子类。C A类是B类的子类

D b对象拥有run()方法。

2.下列关于this关键字，说法错误的是：：( D )

A在类里面使用this关键字，可以调用本类里的构造器。

B在类里面使用this关键字，可以调用本类里的方法。

C在类里面使用this关键字，可以调用本类里的属性。

D不能通过this关键调用构造器。

3.以下对类的名称命名规范说法错误的是:( A )

A子类继承了此类后，此类里的方法不可以被修改

B类名可以数字开头,但命名规范中不提倡。

C类名中可以用大写或小写英文字母开头，推荐用大写字母。

D类名可以以“$”开头,但命名规范中不提倡。

四、多选题

1.以下对final修饰的类说法错误的是( )

A子类继承了此类后，此类里的属性不可以 A,B,D 被修改。

B此类可以被继承。C此类不可以被继承。

D子类继承了此类后，此类里的方法不可以被修改

2.在子类callFa方法中调用父类方法fly，代码错误的是（ BCD ）：

A public void callFa(){ super.fly()} B public static fly（）{super.callFa()}

Cpublic static void callFa(){super.fly()} D public void fly（）{super.fly()}

五、代码阅读题

1. 仔细阅读以下代码，计算结果：

public class Person {

public String school;

public static String team;

// 省略setter、getter方法

}

public class Test {

public static void main(String[] args) {

Person p1 = new Person();

Person p2 = new Person();

p1.setTeam("1111JavaA");

p2.setSchool("八维");

}

结果： p1.getTeam(); 取到的值为（ 1111JavaA ）, p2.getTeam( ); 取到的值为：( null), p2.getSchool(); 取到的值为：( 八维 )。

2. 有一个员工类Emp如下代码：

public class Emp {

private String name;

private int age;

public static int ncount = 81;

public Emp(String name, int age) {

this.name = name;

this.age = age;

}

结果：该类中有( 1 )个构造方法。

3. public class A {

public void run() {}

}

public class B extends A {

}

public class Test {

public static void main(String[] args) {

A a = new A();

B b = new B();

}

结果：关于以上代码，B类是A类的(子类),b对象拥有 run() 方法。

4. 阅读以下代码,分析代码,正确的输出结果是( 0,0,0,0,4 (中间是换行隔开) );

int[] s ;

int i ;

s = new int[5] ;

for(i = 0 ; i < 5 ; i++) {

s[i] = i ;

}

for(i = 4 ; i >= 0 ; i--) {

System.out.println("" + s[i]) ;

}

5. 阅读以下代码，分析代码，输出的结果是( null )

int a [] = new int [5] ;

System.out.println("" + a[3]) ;：

六、技能题（45分钟）

请用Myeclipse/Eclipse编写代码，完成以下题目。

1.案例：继承练习（15分钟）

需求：根据类与类之间继承关系实现案例。

思路：

创建一个交通工具类Transport作为父类

2.属性：类型type、颜色color、价格price；方法：启动start、停止stop 的方法

3.创建两个子类分别继承自Transport类

a公交车Bus：

Bus自己的属性：载客量、公交路线

Bus重写父类的启动（内容，公交车出站了）和停止（公交车到站了）的方法

b货车Freight:

Freight自己的属性：载货量、里程

Freight重写父类的启动（货车载着XXX吨东西出发了）和停止（货车形式了XXXX里程之后到达了目的地开始卸货）的方法

4.创建测试类，分别定义以上公交车类与货车类的对象，并赋值，及调用其启动与停止的方法。观查其不同。

2.定义动物超类Animal，属性： id name color age；该类具有属性序号id，名字name,颜色color。其中id为int类型，color为String类型，age为int类型。为该类进行合理的封装，其中id为只读属性，为该类添加有参构造方法。

定义Dog、Cat子类，继承自Animal类。重写父类中的printInfo()和eat()方法。

定义动物园类Zoo，在该类中创建2个子类对象并依次给对象赋值并打印（15分钟）

要求：

1.正确创建变量

2.正确封装，添加构造方法

3.正确给变量赋值

4.正确完成重写

3.定义一个父类Person类。有姓名、编号、类型三个属性。定义一个展示自己信息的方法。定义一个带参构造方法，为属性赋值。

定义子类worker，继承自Person类。重写父类中的speak( )和eat( )方法。

定义测试类TestPerson，创建2个Worker类对象，给对象赋值并打印（15分钟）

要求：

1. 父类中有属性，展示所有信息方法，构造方法。

2. 正确封装，添加构造方法

3. 正确给变量赋值

4. 正确完成重写

4.定义一个计算器类Calc。有属性：颜色、价格。定义一个展示该计算器信息的方法。定义子类手机类Phone，继承计算器类。子类中增加两个方法，打电话，接电话。

定义测试类TestCalc，创建2个Phone类对象，给对象赋值并打印（20分钟）

要求：

1. 正确创建变量

2. 正确封装，添加构造方法

3. 正确给变量赋值

5.定义一个银行类Bank有属性：用户编号、用户姓名、存钱金额。定义两个方法，存钱方法，取钱方法。

定义一个子类，中国银行CNBank。继承Bank银行类。子类中重写父类存钱方法和取钱方法。

存钱方法，参数为存钱的金额，判断存钱的金额必须为正整数且为10或者5 的倍数否则存钱失败。无论存钱成功或者失败都要求显示存钱的总金额。
取钱方法，有返回值，返回取钱的金额，并且每次取钱必须为2元的倍数，否则取钱失败，取钱成功后显示总金额。

定义测试类，实例化存钱罐类，并分别调用两个方法。（25分钟）

要求：

1. 按规定时间完成

2. 正确封装，子类重写父类方法

3. 逻辑清晰，代码注释

要求：代码规范，有注释，能正确运行出结果，将.java源文件打包后，以自己的名字命名提交。

Animal.java

package com.xiongluoluo;

/**
* Created by dell on 2020/1/24.
*/
public class Animal {
    /* 2.定义动物超类Animal，属性： id   name color age；该类具有属性序号id，名字name,颜色color。
        其中id为int类型，color为String类型，age为int类型。
        为该类进行合理的封装，其中id为只读属性，为该类添加有参构造方法。
        定义Dog、Cat子类，继承自Animal类。重写父类中的printInfo()和eat()方法。
        定义动物园类Zoo，在该类中创建2个子类对象并依次给对象赋值并打印（15分钟）
        要求：
            1.正确创建变量
            2.正确封装，添加构造方法
            3.正确给变量赋值
            4.正确完成重写*/
    final int id = 10086;
    String name;
    String color;
    int age;

    public Animal(){}
    public Animal(String name, String color, int age) {
        this.name = name;
        this.color = color;
        this.age = age;
    }
    public void printInfo(){
        System.out.println(id+"\t"+name+"\t"+color+"\t"+age);
    }
    public void eat(){

    }
}

Bank.java

package com.xiongluoluo;

/**
* Created by dell on 2020/1/28.
*/
public class Bank {
    /*5.定义一个银行类Bank有属性：用户编号、用户姓名、存钱金额。定义两个方法，存钱方法，取钱方法。
    定义一个子类，中国银行CNBank。继承Bank银行类。子类中重写父类存钱方法和   取钱方法。
    A）存钱方法，参数为存钱的金额，判断存钱的金额必须为正整数且为10或者5   的倍数否则存钱失败。
    无论存钱成功或者失败都要求显示存钱的总金额。
    B）取钱方法，有返回值，返回取钱的金额，并且每次取钱必须为2元的倍数，否   则取钱失败，取钱成功后显示总金额。
    定义测试类，实例化存钱罐类，并分别调用两个方法。（25分钟）*/
    public int id;
    public String name;
    public int fund;

    public void save(int money){
    }
    public int withdraw(int money){
       return money;
    }
}

Bus.java

package com.xiongluoluo;

/**
* Created by dell on 2020/1/24.
*/
public class Bus extends Transport {
    /*a公交车Bus：
    Bus自己的属性：载客量、公交路线
    Bus重写父类的启动（内容，公交车出站了）和停止（公交车到站了）的方法*/
    int capacity;//载客量
    String routes;//公交路线

    public void start(){
        System.out.println("公交车出站了");
    }

    public void stop(){
        System.out.println("公交车到站了");
    }

    public Bus(){}
    public Bus(int capacity, String routes) {
        this.capacity = capacity;
        this.routes = routes;
    }
}

Calc.java

package com.xiongluoluo;

/**
* Created by dell on 2020/1/28.
*/
public class Calc {
    /*4.定义一个计算器类Calc。有属性：颜色、价格。定义一个展示该计算器信息的方法。
    定义子类手机类Phone，继承计算器类。子类中增加两个方法，打电话，接电话。
    定义测试类TestCalc，创建2个Phone类对象，给对象赋值并打印（20分钟）
            l要求：
            1. 正确创建变量
            2. 正确封装，添加构造方法
            3. 正确给变量赋值 */
    public String color;
    public double price;

    public void show(){
        System.out.println("color:"+color+"\t"+"price:"+price);
    }

}

Cat.java

package com.xiongluoluo;

/**
* Created by dell on 2020/1/24.
*/
public class Cat extends Animal {
    /*定义Dog、Cat子类，继承自Animal类。重写父类中的printInfo()和eat()方法。
    定义动物园类Zoo，在该类中创建2个子类对象并依次给对象赋值并打印（15分钟）*/
    public Cat(){}
    public Cat(String name, String color, int age) {
        this.name = name;
        this.color = color;
        this.age = age;
    }
    public void printInfo(){
        System.out.println("小猫的信息:"+id+"\t"+name+"\t"+color+"\t"+age);
    }
    public void eat(){
        System.out.println("小猫在吃东西");
    }
}

CNBank.java

package com.xiongluoluo;

/**
* Created by dell on 2020/1/28.
*/
public class CNBank extends Bank {
    public CNBank(){}
    public CNBank(int id,String name,int fund){
        this.id = id;
        this.name = name;
        this.fund = fund;
    }
    public void save(int money){
        if(money>0 && (money%10==0||money%5==0)){
            System.out.println("存钱成功");
            System.out.println("存款总金额"+(this.fund+money));
        }else{
            System.out.println("存钱失败");
            System.out.println("存款总金额"+(this.fund+money));
        }
    }
    public int withdraw(int money){
        if(money>0 && money%2==0){
            System.out.println("取钱成功");
            System.out.println("存款总金额"+(this.fund-money));
            return money;
        }else{
            System.out.println("取钱成功");
            System.out.println("存款总金额"+(this.fund-money));
            return 0;
        }
    }
}

Dog.java

package com.xiongluoluo;

/**
* Created by dell on 2020/1/24.
*/
public class Dog extends Animal {
    /*定义Dog、Cat子类，继承自Animal类。重写父类中的printInfo()和eat()方法。
    定义动物园类Zoo，在该类中创建2个子类对象并依次给对象赋值并打印（15分钟）*/
    public Dog(){}
    public Dog(String name, String color, int age) {
        this.name = name;
        this.color = color;
        this.age = age;
    }
    public void printInfo(){
        System.out.println("狗狗的信息:"+id+"\t"+name+"\t"+color+"\t"+age);
    }
    public void eat(){
        System.out.println("狗狗在吃东西");
    }
}

Freight.java

package com.xiongluoluo;

/**
* Created by dell on 2020/1/24.
*/
public class Freight {
    /*b货车Freight:
    Freight自己的属性：载货量、里程
    Freight重写父类的启动（货车载着XXX吨东西出发了）和停止（货车形式了XXXX里程之后到达了目的地开始卸货）的方法*/
    double boatload;//载货量
   double mileage;//里程

    public void start(){
        System.out.println("货车载着"+boatload+"吨东西出发了");
    }

    public void stop(){
        System.out.println("货车行驶了"+mileage+"里程之后到达了目的地开始卸货");
    }

    public Freight(){}
    public Freight(double boatload, double mileage) {
        this.boatload = boatload;
        this.mileage = mileage;
    }
}

Person.java

package com.xiongluoluo;

/**
* Created by dell on 2020/1/28.
*/
public class Person {
    /*    3.定义一个父类Person类。有姓名、编号、类型三个属性。定义一个展示自己信息的方法。定义一个带参构造方法，为属性赋值。
    定义子类worker，继承自Person类。重写父类中的speak( )和eat( )方法。
    定义测试类TestPerson，创建2个Worker类对象，给对象赋值并打印（15分钟）
    要求：
            1. 父类中有属性，展示所有信息方法，构造方法。
            2. 正确封装，添加构造方法
            3. 正确给变量赋值
            4. 正确完成重写*/
    //姓名
    public String name;
    //编号
    public int id;
    //类型
    public String type;

    public Person(){}
    public Person(String name,int id,String type){
        this.name = name;
        this.id = id;
        this.type = type;
    }

    public void speak(){}
    public void eat(){}

    public void show(){
        System.out.println("姓名:"+name+"\t"+"编号:"+id+"\t"+"类型"+type);
    }
}

Phone.java

package com.xiongluoluo;

/**
* Created by dell on 2020/1/28.
*/
public class Phone extends Calc {
/*    定义子类手机类Phone，继承计算器类。子类中增加两个方法，打电话，接电话。*/

    public Phone(){}
    public Phone(String color,double price){
        this.color = color;
        this.price = price;
    }
    public void call(){
        System.out.println("打电话");
    }

    public void accept(){
        System.out.println("接电话");
    }
}

Transport.java

package com.xiongluoluo;

/**
* Created by dell on 2020/1/24.
*/
public class Transport {

    /* 1.案例：继承练习（15分钟）
    需求：根据类与类之间继承关系实现案例。
    思路：
        1、创建一个交通工具类Transport作为父类
        2.属性：类型type、颜色color、价格price；方法：启动start、停止stop     的方法
        3.创建两个子类分别继承自Transport类
        a公交车Bus：
        Bus自己的属性：载客量、公交路线
        Bus重写父类的启动（内容，公交车出站了）和停止（公交车到站了）的方法
        b货车Freight:
        Freight自己的属性：载货量、里程
        Freight重写父类的启动（货车载着XXX吨东西出发了）和停止   （货车形式了XXXX里程之后到达了目的地开始卸货）的方法
        4.创建测试类，分别定义以上公交车类与货车类的对象，并赋值，及调用其启动与停止的方法。观查其不同。*/
    String type;
    String color;
    double price;

    //启动start
    public void start(){

    }
    //停止stop
    public void stop(){

    }
}

Worker.java

package com.xiongluoluo;

/**
* Created by dell on 2020/1/28.
*/
public class Worker extends Person {
    /*定义子类worker，继承自Person类。重写父类中的speak( )和eat( )方法。*/
    public Worker(){}
    public Worker(String name,int id,String type){
        this.name = name;
        this.id = id;
        this.type = type;
    }
    public void speak(){
        System.out.println(name+"中的speak方法");
    }
    public void eat(){
        System.out.println(name+"中的speak方法");
    }

}

Zoo.java

package com.xiongluoluo;

import org.junit.jupiter.api.Test;

/**
* Created by dell on 2020/1/24.
*/
public class Zoo {
    @Test
    public void test(){
        Dog dog = new Dog("狗狗","白色",12);
        dog.eat();
        dog.printInfo();

        Cat cat = new Cat("猫猫","绿色",2);
        cat.eat();
        cat.printInfo();
    }
}

MyTest.java

package com.xiongluoluo;

import org.junit.jupiter.api.Test;

/**
* Created by dell on 2020/1/24.
*/
public class MyTest {
   /* 1.案例：继承练习（15分钟）
    需求：根据类与类之间继承关系实现案例。
    思路：
        1、创建一个交通工具类Transport作为父类
        2.属性：类型type、颜色color、价格price；方法：启动start、停止stop     的方法
        3.创建两个子类分别继承自Transport类
        a公交车Bus：
        Bus自己的属性：载客量、公交路线
        Bus重写父类的启动（内容，公交车出站了）和停止（公交车到站了）的方法
        b货车Freight:
        Freight自己的属性：载货量、里程
        Freight重写父类的启动（货车载着XXX吨东西出发了）和停止   （货车形式了XXXX里程之后到达了目的地开始卸货）的方法
        4.创建测试类，分别定义以上公交车类与货车类的对象，并赋值，及调用其启动与停止的方法。观查其不同。*/
    @Test
    public void testBus(){
        Bus bus = new Bus(33,"1-2-3");
        bus.start();
        bus.stop();

        Freight freight = new Freight(33,22);
        freight.start();
        freight.stop();
    }

   /* 2.定义动物超类Animal，属性： id   name color age；该类具有属性序号id，名   字name,颜色color。其中id为int类型，color为String类型，age为int类型。为    该类进行合理的封装，其中id为只读属性，为该类添加有参构造方法。
        定义Dog、Cat子类，继承自Animal类。重写父类中的printInfo()和eat()方法。
        定义动物园类Zoo，在该类中创建2个子类对象并依次给对象赋值并打印（15分钟）
        要求：
            1.正确创建变量
            2.正确封装，添加构造方法
            3.正确给变量赋值
            4.正确完成重写*/

    /*    3.定义一个父类Person类。有姓名、编号、类型三个属性。定义一个展示自己信息的方法。定义一个带参构造方法，为属性赋值。
    定义子类worker，继承自Person类。重写父类中的speak( )和eat( )方法。
    定义测试类TestPerson，创建2个Worker类对象，给对象赋值并打印（15分钟）
    要求：
            1. 父类中有属性，展示所有信息方法，构造方法。
            2. 正确封装，添加构造方法
            3. 正确给变量赋值
            4. 正确完成重写*/
    @Test
    public void testPerson(){
        Person worker1 = new Worker("小小怪下士",11,"果宝特攻");
        worker1.eat();
        worker1.speak();
        worker1.show();

        Person worker2 = new Worker("大大怪将军",12,"果宝特攻");
        worker2.eat();
        worker2.speak();
        worker2.show();
    }

/*4.定义一个计算器类Calc。有属性：颜色、价格。定义一个展示该计算器信息的方法。    定义子类手机类Phone，继承计算器类。子类中增加两个方法，打电话，接电话。
    定义测试类TestCalc，创建2个Phone类对象，给对象赋值并打印（20分钟）
            l要求：
            1. 正确创建变量
            2. 正确封装，添加构造方法
            3. 正确给变量赋值 */
    @Test
    public void testCalc(){
        Phone phone1 = new Phone("白色",3799);
        phone1.show();
        phone1.call();
        phone1.accept();

        Phone phone2 = new Phone("黑色",3368);
        phone2.show();
        phone2.call();
        phone2.accept();
    }

/*5.定义一个银行类Bank有属性：用户编号、用户姓名、存钱金额。定义两个方法，存钱方法，取钱方法。
    定义一个子类，中国银行CNBank。继承Bank银行类。子类中重写父类存钱方法和   取钱方法。
    A）存钱方法，参数为存钱的金额，判断存钱的金额必须为正整数且为10或者5   的倍数否则存钱失败。无论存钱成功或者失败都要求显示存钱的总金额。
    B）取钱方法，有返回值，返回取钱的金额，并且每次取钱必须为2元的倍数，否   则取钱失败，取钱成功后显示总金额。
    定义测试类，实例化存钱罐类，并分别调用两个方法。（25分钟）*/
    @Test
    public void testBank(){
        CNBank cnBank = new CNBank(1,"用户",2000);
        cnBank.save(22);
        cnBank.withdraw(10);
    }
}