第十一单元面向对象-多态

一、填空题

1. 权限访问控制符中，访问权限最小的是( private )

2. 面向对象三大特征是 ( 封装 )( 继承 ) ( 多态 )

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

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

5. java中byte数据类型的取值范围是( -128-127 )

6. 用( super )作为调用者来调用父类被覆盖的实例方法。

7. 变量的3要素是( 变量类型 )、( 变量名 )和( 变量类型 )。

8. 区分类中重载方法的依据是( 在同一个类中,方法名相同,方法参数的个数和类型不同的就是重载方法 )。

9. 在重写过程中，子类中定义了与父类中 ( 方法名,参数列表 )和( 返回值 )必须相同。

10. 对于while(循环条件){循环体}循环，在每次执行循环之前，都先对循环条件求值，如果循环条件为( false )则不运行循环体部分。

11. 定义float t = 9.0f;int q = 5;那么运行（t++）*（--q）的结果是( 36.0 )。

12. 包的命名规范是( 公司域名倒置 )。

13. protected修饰的属性有什么特点？( 可以在本类及其子类中访问 )。

14. super关键字的作用是( 访问父类中的成员变量,成员方法,构造方法 )。

15. 对类的命名规范都有哪些？( 首字母大写,不能以关键字开头,多个单词时,一般是驼峰式命名 )。

16. 面向对象中，静态需要使用到的关键字是( static )。

17. 定义main方法必须包含的关键字( public )、( static )、( void)。

18. 权限访问控制符中，访问权限最大的是( public )。

19. 子类继承了父类后，子类拥有父类的( 非private修饰的成员变量 )、( 非private修饰的成员方法 )。

20.子类里可以通过( super )关键字访问父类里所有的方法和属性

21.“子类重写父类的方法”这句话是有歧义的，正确的说法应该是“子类重写从父类( 继承 )过来的方法”

22.重载就是一个类中有多个同名但有不同( 参数 )的方法

23.在一个类中，方法中( 方法名 )相同才能称为重载。：

24.子类对象一定能交给( 父类 )对象直接引用..填父类和子类

25.( private )修饰的方法是不可以被子类重写

26.子类不能从父类继承的资源：( 父类的构造方法 ,被private修饰的方法及变量 )

子类继承了父类的所有属性和方法或子类拥有父类的所有属性和方法是对的，只不过父类的私有属性和方法，子类是无法直接访问到的。即只是拥有，但是无法使用。

子类不可以继承父类的构造方法，只可以调用父类的构造方法。子类中所有的构造函数都会默认访问父类中的空参数构造函数，这是因为子类的构造函数内第一行都有默认的super（）语句。super（）表示子类在初始化时调用父类的空参数的构造函数来完成初始化。一个类都会有默认的空参数的构造函数，若指定了带参构造函数，那么默认的空参数的构造函数，就不存在了。这时如果子类的构造函数有默认的super（）语句，那么就会出现错误，因为父类中没有空参数的构造函数。因此，在子类中默认super（）语句，在父类中无对应的构造函数，必须在子类的构造函数中通过this或super（参数）指定要访问的父类中的构造函数。

二、判断题

1.子类可以调用父类构造方法。 ✔

2.子类在重写继承过来的方法时，要求修饰符、返回类型、方法名称、参数列表必须和父类中的完全一样 ✖,修饰符可以不一样,但是要比父类中修饰符的范围大

3.重载方法修饰符、返回类型、名称一定要相同重载方法,名称要一样,参数的个数和类型不一样即可.跟别的没有关系

4.子类的对象使用重写这个方法时，将直接调用子类中的定义方法。 ✔

5.父类对象通过子类开辟空间后，可以对声明的对象使用强转，转化为子类对象。 ✔

6.子类只能继承父类的方法，而不能重写父类的方法 ✖

7.重写方法的访问控制修饰符不能比被重写方法更严格（比如一个在父类中声明为public的方法重写成一个protected的方法） ✔

8.多个同名方法访问控制符不同符合重载原则 ✖

三、单选题

1.阅读以下代码，分析代码，选项中正确的是（）

class Father{

protected int money = 100000;

public void out(){

System.out.println(money);

}

class Son extends Father{

protected int money = 100;

public void out(){

System.out.println(money);

}

public void out(int money){

System.out.println(super.money);

}

-----------------------

public static void main(String[] args) {

out(new Son());

}

private static void out(Father f){

f.out(20);//认真,这个方法里面用的是父类的引用

}：( D )

在多态中成员变量的访问特点

编译看左边，运行看左边
编译的时候，要看赋值号左边的引用的类型中，是否有该变量的定义，如果有，就编译成功，否则报错。
运行的时候，要看赋值号左边的引用数据类型中，真正如何给变量赋值，获取的是引用父类的赋值数据。

多态中的成员方法的访问特点

编译看左边，运行看右边
编译的时候，要看父类中是否存在该方法，如果存在，编译通过，否则编译报错。
运行的时候，要运行子类的重写的方法，如果没有重写的方法，执行父类的方法。

多态中静态方法的访问特点

编译看左边，运行看左边
编译的时候，检测父类是否有该方法
执行的时候，执行父类中的方法

A 输出结果：20 B 输出结果：100000 C 输出结果：100

D 程序报错，因为Father中没有定义带参数的out方法

2.阅读以下代码，分析代码，选项中正确的是（）

class Father{

protected int money = 100000;

public void out(){

System.out.println(money);

}

class Son extends Father{

public int money = 100;

public void out(){

System.out.println(this.money);

}

--------------------------------

static Father person;

public static void main(String[] args) {

person = new Son();

person.out();

}：( D )

A 程序报错，因为person是Father类型，赋值类型不匹配 B 输出结果：100000

C 输出结果：0 D输出结果：100

3.以下对转型描述有错误的一项是：( A )

A 父类对象一定能交给子类对象直接引用

B 父类对象如果是通过父类实例化的，不能强转成子类对象

C 父类对象如果是通过子类实例化的，可以通过此子类进行强转。

D 子类对象一定能交给父类对象直接引用。

四、多选题

1.以下描述符合重载原则的是（ B,C ）：

A 多个同名方法访问控制符不同 B 多个同名方法参数数量不同

C 多个同名方法参数数量相同，但参数类型不同 D 多个同名方法返回值类型不同

2.以下描述符合重写原则的是( A,C,D )

A “子类重写父类的方法”这句话是有歧义的，正确的说法应该是“子类重写从父类继承过来的方法”。

B 返回值相同，参数列表不同称为重写。

C类重写从父类里继承过来的方法，以方法已属于子类，此方法不满足子类的需要，所以要重写

D重写一定是发生在子类和父类之间。

五、代码阅读题

1、阅读以下代码，要正确为数组每个元素赋值.分析代码，①位置填(a.length)②位置填([i])。

int[] a = new int[4];

for(int i=0;i < __①__;i++){

a_②__ = i;

};

2、以下代码的输出结果是( false )。

public class Test {

public static void main(String[] args) {

T t1 = new T();

boolean b=new T().equals(t1);——代码标记

System.out.println(b);

}

3、阅读下面代码，分析代码，输出的结果是:( 1 )。

public static void main(String[] args) {

Father f = new Father();

Son s = new Son();

if (f.out().equals(s.out())) {

System.out.println(1);

} else {

System.out.println(2);

}

--------------------————————

class Father {

protected int money = 100000;

protected String out() {

return money + “ ”;

}

class Son extends Father {

protected int money = 100;

public String out() {

return super.out();//这里调用的是父类的方法,用的变量money也是父类的,认真

}

};

4、阅读以下代码，分析代码，输出的结果是( 4,3,2,3(中间是换行隔开) )。

int a = 0;
int b = 5;
for(int i=0;i<b;i++){
    b--;
    a++;
    for(int j=b;j>a;j--){
        System.out.println(j);
    }
};

5、public class Test{

public static void main(String[] args){

int i = 5;

do{

System.out.println(i);

}while (--i>4)

}

}执行后的输出是( 5 )。

六、技能题

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

(1) 创建一个工人类worker：工龄、工号、姓名、基本工资。定义输出所有信息的方法以及一个输出工资的方法（工资=基本工资）

创建一个部门经理类，继承工人Worker类，并重写其计算工资的方法（工资=基本工资+岗位级别*500+工龄*1000）

创建一个销售人员类，继承工人Worker类，并增加一个属性（销售金额）。并重写其计算工资的方法（工资=基本工资+销售金额*0.08）

创建测试类，分别定义以上三种类的对象，并赋值，调用其输出工资的方法进行测试。（25分钟）

要求：

1. 按规定时间完成

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

3. 逻辑清晰，代码注释

（2） 创建一个Person类。它有三个方法，走路、吃饭、睡觉

创建一个Teacher类，重写走路、吃饭、睡觉、方法并增加教学方法

创建一个Student类，重写走路、吃饭、睡觉方法并增加学习方法

使用父类调用三个方法。使用多态创建子类对象，并调用重写后的方法

要求：

1. 父类引用创建子类对象。

2. 功能代码模块中加入注释

3. 注意代码命名规范

（3） 案例题目描述:

创建一个基类Person，它有三个方法（跑步，睡觉，吃饭）。创建Person类的一个子类Man，覆写跑步，睡觉方法，并增加的抽烟方法。创建Person类的另一个子类Woman，覆写跑步，吃饭，并增加烫头方法。使用父类调用三个方法。使用Man子类转父类对象，调用覆写的方法。使用Woman子类转父类对象，再强制转为Woman对象，调用覆写的方法和自定义方法。

1.案例完成思路要求：

定义三个类，一个类是Person类，它有跑步，睡觉，吃饭三个方法。（10分）

第二个类是Man类，它继承了Person类，覆写了跑步，睡觉方法，并有一个抽烟方法。（10分）

第三个类是Woman类，它继承了Person，覆写了跑步，吃饭方法，并有一个烫头方法。（10分）

创建一个Person类对象的实例，调用本类的跑步，睡觉，吃饭方法（10分）

创建一个Man类对象的实例，并向上转型为Person类，调用覆写的跑步，睡觉方法。（10分）

创建一个Woman类对象的实例，并向上转型为Person类，再向下强制转型为Woman类对象，调用覆写的跑步，吃饭，和烫头方法。（20分）

1.其它要求：

(1)功能代码模块中加入注释（10分）。

(2)显示效果正确输出。（10分）

(3)在试卷下方画出此案例简单的流程图（10分）。

Manager.java

package com.xiongluoluo.Demo1;

/**
* Created by dell on 2020/1/28.
*/
public class Manager extends Worker {
/* 创建一个部门经理类，继承工人Worker类，
并重写其计算工资的方法（工资=基本工资+岗位级别*500+工龄*1000）*/
int grade;//岗位级别
public void printSalary(){
System.out.println("工资为:"+(basicSalary+grade*500+workAge*1000));
}
}

Saler.java

package com.xiongluoluo.Demo1;

/**
* Created by dell on 2020/1/28.
*/
public class Saler extends Worker {
/*   创建一个销售人员类，继承工人Worker类，并增加一个属性（销售金额）。
    并重写其计算工资的方法（工资=基本工资+销售金额*0.08））*/
double money;//销售金额
public void printSalary(){
     System.out.println("工资为:"+(basicSalary+money*0.08));
}
}

Worker.java

package com.xiongluoluo.Demo1;

/**
* Created by dell on 2020/1/28.
*/
public class Worker {
    /*创建一个工人类worker：工龄、工号、姓名、基本工资。
    定义输出所有信息的方法以及一个输出工资的方法（工资=基本工资）
    创建一个部门经理类，继承工人Worker类，并重写其计算工资的方法（工资=基本工资+岗位级别*500+工龄*1000）
    创建一个销售人员类，继承工人Worker类，并增加一个属性（销售金额）。
    并重写其计算工资的方法（工资=基本工资+销售金额*0.08）
    创建测试类，分别定义以上三种类的对象，并赋值，调用其输出工资的方法进行测试。（25分钟）*/
    int workAge;
    int id;
    String name;
    double basicSalary;
    public void printInfo(){
        System.out.println("工龄为:"+workAge+"\t"+"工号为:"+id+"\t"+"姓名为:"+name+"\t"+"基本工资为:"+basicSalary);
    }
    public void printSalary(){
        System.out.println("工资为:"+basicSalary);
    }
}

WorkerTest.java

package com.xiongluoluo.Demo1;

import org.junit.jupiter.api.Test;

/**
* Created by dell on 2020/1/28.
*/
public class WorkerTest {
    /*创建测试类，分别定义以上三种类的对象，并赋值，调用其输出工资的方法进行测试。（25分钟）*/
    @Test
    public void test(){
        Worker worker = new Worker();
        worker.name = "熊落落";
        worker.workAge = 2;
        worker.id = 1;
        worker.basicSalary = 10000;
        worker.printSalary();
        worker.printInfo();

Manager manager = new Manager();
        manager.name = "杨梦梦";
        manager.workAge = 2;
        manager.id = 2;
        manager.basicSalary = 10000;
        manager.grade = 2;
        manager.printSalary();
        manager.printInfo();

Saler saler = new Saler();
        saler.name = "李鹏鹏";
        saler.workAge = 2;
        saler.id = 3;
        saler.basicSalary = 10000;
        saler.money = 1000;
        saler.printSalary();
        worker.printInfo();

}
}

Person.java

package com.xiongluoluo.Demo2;

/**
* Created by dell on 2020/1/28.
*/
public class Person {
    /*创建一个Person类。它有三个方法，走路、吃饭、睡觉
    创建一个Teacher类，重写走路、吃饭、睡觉、方法并增加教学方法
    创建一个Student类，重写走路、吃饭、睡觉方法并增加学习方法
    使用父类调用三个方法。使用多态创建子类对象，并调用重写后的方法*/
    public void walk(){
        System.out.println("走路走路走路");
    }
    public void eat(){
        System.out.println("吃饭吃饭吃饭");
    }
    public void sleep(){
        System.out.println("睡觉睡觉睡觉");
    }
    public void run(){
        System.out.println("跑步跑步跑步");
    }
}

PersonTest.java

package com.xiongluoluo.Demo2;

import com.xiongluoluo.Demo3.Man;
import com.xiongluoluo.Demo3.Woman;
import org.junit.jupiter.api.Test;

/**
* Created by dell on 2020/1/28.
*/
public class PersonTest {
    @Test
    public void test(){
        /*使用父类调用三个方法。使用多态创建子类对象，并调用重写后的方法*/
        Person person = new Person();
        person.eat();
        person.sleep();
        person.walk();

Person teacher = new Teacher();
        teacher.eat();
        teacher.sleep();
        teacher.walk();

Person student = new Student();
        student.eat();
        student.sleep();
        student.walk();

}

@Test
    public void test2(){
       /* 创建一个Person类对象的实例，调用本类的跑步，睡觉，吃饭方法（10分）
        创建一个Man类对象的实例，并向上转型为Person类，调用覆写的跑步，睡觉方法。（10分）
        创建一个Woman类对象的实例，并向上转型为Person类，
        再向下强制转型为Woman类对象，调用覆写的跑步，吃饭，和烫头方法。*/
       Person person = new Person();
       person.run();
       person.sleep();
       person.eat();

Person man = new Man();
man.run();
man.sleep();

Person woman = new Woman();
        Woman woman1 = (Woman) woman;
        woman1.run();
        woman1.eat();
        woman1.perm();

}
}

Student.java

package com.xiongluoluo.Demo2;

/**
* Created by dell on 2020/1/28.
*/
public class Student extends Person {
    /*创建一个Student类，重写走路、吃饭、睡觉方法并增加学习方法*/
    public void walk(){
        System.out.println("Student走路走路走路");
    }
    public void eat(){
        System.out.println("Student吃饭吃饭吃饭");
    }
    public void sleep(){
        System.out.println("Student睡觉睡觉睡觉");
    }
    public void learn(){
        System.out.println("Student学习学习学习");
    }
}

Teacher.java

package com.xiongluoluo.Demo2;

/**
* Created by dell on 2020/1/28.
*/
public class Teacher extends Person {
   /* 创建一个Teacher类，重写走路、吃饭、睡觉、方法并增加教学方法*/
   public void walk(){
       System.out.println("Teacher走路走路走路");
   }
    public void eat(){
        System.out.println("Teacher吃饭吃饭吃饭");
    }
    public void sleep(){
        System.out.println("Teacher睡觉睡觉睡觉");
    }
    public void teach(){
        System.out.println("Teacher教学教学教学");
    }
}

Man.java

package com.xiongluoluo.Demo3;

import com.xiongluoluo.Demo2.Person;

/**
* Created by dell on 2020/1/28.
*/
public class Man extends Person {
   /* 案例题目描述:
    创建一个基类Person，它有三个方法（跑步，睡觉，吃饭）。
    创建Person类的一个子类Man，覆写跑步，睡觉方法，并增加的抽烟方法。创建Person类的另一个子类Woman，覆写跑步，吃饭，并增加烫头方法。
    使用父类调用三个方法。使用Man子类转父类对象，调用覆写的方法。使用Woman子类转父类对象，再强制转为Woman对象，调用覆写的方法和自定义方法。
            1.案例完成思路要求：
    定义三个类，一个类是Person类，它有跑步，睡觉，吃饭三个方法。（10分）
    第二个类是Man类，它继承了Person类，覆写了跑步，睡觉方法，并有一个抽烟方法。（10分）
    第三个类是Woman类，它继承了Person，覆写了跑步，吃饭方法，并有一个烫头方法。（10分）
    创建一个Person类对象的实例，调用本类的跑步，睡觉，吃饭方法（10分）
    创建一个Man类对象的实例，并向上转型为Person类，调用覆写的跑步，睡觉方法。（10分）
    创建一个Woman类对象的实例，并向上转型为Person类，再向下强制转型为Woman类对象，调用覆写的跑步，吃饭，和烫头方法。（20分）*/
   public void smoke(){
       System.out.println("抽烟抽烟抽烟");
   }
    public void sleep(){
        System.out.println("Man睡觉睡觉睡觉");
    }
    public void run(){
        System.out.println("Man跑步跑步跑步");
    }
}

Woman.java

package com.xiongluoluo.Demo3;

import com.xiongluoluo.Demo2.Person;

/**
* Created by dell on 2020/1/28.
*/
public class Woman extends Person {
/*第三个类是Woman类，它继承了Person，覆写了跑步，吃饭方法，并有一个烫头方法。（10分）*/

    public void run(){
        System.out.println("Woman跑步跑步跑步");
    }
    public void eat(){
        System.out.println("Woman吃饭吃饭吃饭");
    }
    public void perm(){
        System.out.println("烫头烫头烫头");
    }
}