【Java 5班第2次考试】
Java 5班第2次考试
一、选择题（每题1分 共15分）
1、关于继承的说法正确的是（ A ）
A)子类将继承父类所有的属性和方法
B)子类将继承父类的非私有属性和方法
C)子类只继承父类public方法和属性
D)子类只继承父类的方法，而不继承属性
2、重写与重载的关系是（ A ）
A)重写只有发生在父类与子类之间，而重载可以发生在同一个类中
B)重写方法可以不同名，而重载方法必须同名
C) final修饰的方法可以被重写，但不能被重载
D)重写与重载是同一回事
3、构造函数何时被调用（ A ）
A、创建对象时 B、类定义时
C、使用对象的方法时 D、使用对象的属性时
4、在以下Java程序的方法中，两个方法之间属于方法重载的是（AC ）（多选）
A) public int f1(){} B) public void f1(int a){}
public intf1(int a){} public int f1(inta){}
C) public void f1(){} D) public int f1(int b){}
public intf1(int a){} public intf1(int a){}
5、在Java语言中，下列关于类的继承的描述，正确的是（B ）
A)一个类可以同时继承多个父类。
B)一个类可以具有多个子类。
C)子类可以使用父类的所有方法。
D)子类一定比父类有更多的方法。
6、下列选项中关于Java中super关键字的说法正确的是（ AB ）(多选)
A) super关键字是在子类对象内部指代其父类对象的引用。
B) super关键字不仅可以指代子类的直接父类，还可以指代父类的父类。
C)子类通过super关键字只能调用父类的方法，而不能调用父类的属性。
D)子类通过super关键字只能调用父类的属性，而不能调用父类的方法。
7、关于对象成员占用内存的说法哪个正确？（ B ）
A)同一个类的对象共用同一段内存
B)同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间
C)对象的方法不占用内存
D)以上都不对
8、在Java中，关于final关键字的说法正确的是（ C ）
A)如果修饰局部变量，必须初始化
B)如果修饰类，则该方法只能被一个子类继承
C)如果修饰方法，则该方法不能在子类中被重写
D)如果修饰方法，则该方法所在的类不能被继承
9、（多选）以下关于接口的说法中，正确的是（A D ）
A）接口中全部方法都是抽象方法，所有方法必须是public访问权限。
B）接口中属性都使用public static final 修饰，没有赋值将使用默认值。
C）接口可以有构造方法。
D）一个类只能有一个父类，但可以同时实现多个接口。
10、关于java中的静态方法，以下说法中正确的是（A、C ）（多选）
A)静态方法中不能直接调用非静态方法
B)非静态方法不能直接调用静态方法
C)静态方法可以用类名直接调用
D)静态方法里可以使用this
11、（多选）关于abstract方法描述正确的是：（ A、C ）
A）抽象类无法实例化 B）可以出现在非抽象类中
C）是没有方法体的方法 D）抽象类中的方法都是抽象方法
12、下列选项中关于Java中this关键字的说法正确的是 （A、C 、D ）
A）this()必须放在构造方法首行
B）一个构造方法里面可以同时使用this()和super()
C）this可以用来表示对象
D）this可以处理方法中成员变量和参数重名的情况
13、以下关于对象转型描述正确的是 （ D ）
A）申明父类创建子类对象称作向下转型
B）向下转型前可以不用做向上转型
C）向下转型后，不能调用子类独有的方法
D）向下转型又叫强制转型
14、class A{
void fun1(){
System.out.println(“A==== fun1()”)
}
void fun2(){
this.fun1()
}
}
class B extends A{
void fun1(){
System.out.println(“B==== fun1()”)
}
}
public static void main(String [] args){
A a=new B();
B b=(B)a;
b.fun2();
}
程序运行结果是：( A )
A）B==== fun1() B）A==== fun1()
C）报错 D）无内容
15、下列关于访问权限描述错误的是（ A、D ）（多选）
A）可以用protected修饰类
B）public修饰的属性可以被任意地方访问
C）default只能被同一个包内的类访问
D）父类的private属性可以被子类访问
二、判断题（每题1分 共10分）
1、声明为final的方法不能在子类中重写。（对 ）
2、Java语言中的类可以继承，一个类通过关键字extends可以继承另一个类。（ 对 ）
3、java中一个子类可以有多个直接父类，并可以为一个类定义多个子类。（ 错 ）
4、在程序中可对用final修饰的变量的值进行更改。（ 错）
5、一个子类可以重新定义从父类那里继承来的同名方法，但是允许它们有不同类型的返回值。（ 错or对 ）
6、子类的成员变量能与其父类的成员变量同名。（ 对 ）
7、if语句和else语句必须成对出现。（ 错 ）
8、在编写JAVA程序时候，假如不为类的成员变量定义初始值，JAVA会给他默认值。（ 对 ）
9、局部变量的作用域是整个类。（ 错 ）
10、栈内存存放基本类型的数据和对象的引用，即存放变量。（对 ）
三、填空题（每空1分 共10分）
1、java中，所有的类型的父类为___Object___________。
2、重写方法必须和被重写方法具有___相同的返回类型 ___、___方法名 ___和_ 参数列表 ___
3、如果子类构造方法中既没有（看到）调用父类构造方法，而父类中又没有无参数的构造方法，则_报错_（给父类添加一个无参方法）__________________
4、如果想让一个类的所有实例共享数据，就要使用_静态变量__ __，他的关键字是_static__ __。
5、多态存在的三个必要条件：_要有继承__ __、_要有重写 __、 父类引用指向其子类对象
四、程序阅读题（每题4分 共20分）
1、public interfaceOnSwitchChangedListener {
public voidonSwitchChanged(int status);
}
public class D {
OnSwitchChangedListenerchangedListener;
public voidhuidiao(Demo demo, int s) throws One {
if(changedListener != null) {
thrownew One("数据必须来自接口");
}
changedListener= demo;
changedListener.onSwitchChanged(s);
}
}
public class Demo implements OnSwitchChangedListener {
public voidheh(int s) throws One {
newD().huidiao(this, s);
}
@Override
public voidonSwitchChanged(int status) {
System.out.println("数字是" + status);
}
}
public class One extends Exception {
privatestatic final long serialVersionUID = 1L;
publicOne(String message) {
super(message);
}
}
public class Start {
public staticvoid main(String[] args) {
Demo demo= new Demo();
try {
demo.heh(5);
} catch(One e) {
e.printStackTrace();
}
}
}
输出结果是 ___数字是5__________________
2、class Person{
String name ="person";
public voidshout(){
System.out.print(name);
}
}
class Student extends Person{
String name ="student";
String school= "school";
}
public class Test{
public staticvoid main(String[] args){
Person p =new Student();
p.shout();
}
}
输出结果是 ___person___________________
3、编译并运行下面的Java代码
class StaticStuff {
static int x=10；
static { x+=5；}
public static void main（String args[ ]）{
System.out.println(“x=” + x);
}
static { x/=3;}
}
执行结果为：_______x= 5____________________________________________.
4、class shape {
shape(){
System.out.println("shape()");
}
public static void main(String[] args){
new rectangle();
}
}
class Polygonextends shape{
Polygon(){
System.out.println("Polygon()");
}
}
class rectangleextends Polygon {
rectangle(){
System.out.println("rectangle()");
}
}
输出结果为： shape()
Polygon()
rectangle()
5、public class Test {
public static void main(String[] args) {
Child c = new Child();
}
}
class Father {
public Father() {
System.out.println("父类无参构造函数");
}
public Father(String name) {
System.out.println("父类有参构造函数");
}
}
class Childextends Father {
public Child() {
this("dd");
System.out.println("子类无参构造函数");
}
public Child(String name) {
super("dd");
System.out.println("子类有参构造函数");
}
}
输出结果为： 父类有参构造函数
子类有参构造函数
子类无参构造函数
五、上机题（共45分）
1、 （10分）按要求编程：
（1）定义一个Animal类，有color和weight属性，并为其定义两个构造方法（使用this关键字），为动物类编写两个方法分别为breathe和findFood，方法参数、返回值以及方法体可以任意写。
（2）定义一个Frog类，要求青蛙类继承了动物类，在青蛙类重新定义呼吸方法，并添加一个swim方法，实例化一个青蛙q1，并调用呼吸、觅食、以及游泳方法。
package com.share.test_3_27;
public class ShangJi1 {
/*（1）定义一个Animal类，有color和weight属性，并为其定义两个构造方法（使用this关键字），
* 为动物类编写两个方法分别为breathe和findFood，方法参数、返回值以及方法体可以任意写。
（2）定义一个Frog类，要求青蛙类继承了动物类，在青蛙类重新定义呼吸方法，并添加一个swim方法，
实例化一个青蛙q1，并调用呼吸、觅食、以及游泳方法。*/
public static void main(String[] args) {
Frog q1 = new Frog("青色", 500);
q1.breathe();
q1.findFood();
q1.swim();
}
}
class Frog extends Animal{
public Frog(String color,double weight){
super(color,weight);
}
@Override
public void breathe() {
// TODO Auto-generated method stub
System.out.println("青蛙呼吸");
}
public void swim(){
System.out.println("青蛙游泳");
}
}
class Animal {
public String color;
public double weight;
public Animal(String color){
this.color = color;
}
public Animal(String color,double weight){
this(color);
this.weight = weight;
}
public void breathe(){
System.out.println("huxi");
}
public void findFood(){
System.out.println("觅食");
}
}
2、(10分)为“无名粉店”写一个类：class WuMingFen 要求：
1）有三个属性：粉的口味:String theFen 粉的份量(两)：int quantity
是否带汤：boolean likeSoup
2）写一个构造方法，以便于简化初始化过程，如：
WuMingFen f1 = new WuMingFen("牛肉",3,true);
3）重载构造方法，使得初始化过程可以多样化：
WuMingFen f2 = new WuMingFen("牛肉",2);
4）如何使得下列语句构造出来的粉对象是酸辣粉、2两、带汤的？
WuMingFen f3 = new WuMingFen();
5）写一个普通方法：check()，用于查看粉是否符合要求。即：将对象的三个属性打印在控制台上。
package com.share.test_3_27;
public class ShangJi2 {
/*(10分)为“无名粉店”写一个类：class WuMingFen 要求：
1）有三个属性：粉的口味:String theFen 粉的份量(两)：int quantity
是否带汤：boolean likeSoup
2）写一个构造方法，以便于简化初始化过程，如：
WuMingFen f1 = new WuMingFen("牛肉",3,true);
3）重载构造方法，使得初始化过程可以多样化：
WuMingFen f2 = new WuMingFen("牛肉",2);
4）如何使得下列语句构造出来的粉对象是酸辣粉、2两、带汤的？
WuMingFen f3 = new WuMingFen();
5）写一个普通方法：check()，用于查看粉是否符合要求。即：将对象的三个属性打印在控制台上。*/
public static void main(String[] args) {
WuMingFen f1 = new WuMingFen("牛肉",3,true);
WuMingFen f2 = new WuMingFen("牛肉",2);
WuMingFen f3 = new WuMingFen();
f1.check();
f2.check();
f3.check();
}
}
class WuMingFen{
public String thefen;
public int quantity;
public boolean likesoup;
public WuMingFen(String thefen, int quantity, boolean likesoup) {
this.thefen = thefen;
this.quantity = quantity;
this.likesoup = likesoup;
}
public WuMingFen(String thefen,int quantity){
this.thefen = thefen;
this.quantity = quantity;
this.likesoup = true;
}
public WuMingFen(){
this.thefen = "酸辣粉";
this.quantity = 2;
this.likesoup = true;
}
public void check(){
System.out.println("粉的口味："+thefen);
System.out.println("粉的分量："+quantity);
System.out.println("是否带汤："+(likesoup?"带汤":"不带汤"));
}
}3、（10分）
现将一个二维数组：int a[][] = { { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10 },
{ 11, 12, 13, 14, 15 }, { 16, 17,18, 19, 20 } };
显示为下面这种格式。
01 02 0304 05
10 09 0807 06
11 12 1314 15
20 19 1817 16
package com.share.test_3_27;
public class ShangJi3 {
public static void main(String[] args) {
int a[][] = { { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10 }, { 11, 12, 13, 14, 15 }, { 16, 17, 18, 19, 20 } };
for (int i = 0; i < a.length; i++) {
if (i % 2 == 0) {
show1(a[i]);
} else {
show2(a[i]);
}
}
}
/**
* 将数组中的元素顺序输出
*
* @param a
*/
public static void show1(int a[]) {
for (int i = 0; i < a.length; i++) {
if (a[i] < 10) {
System.out.print("0");
}
System.out.print(a[i] + " ");
}
System.out.println();
}
/**
* 将数组中的元素倒序输出
*/
public static void show2(int a[]) {
for (int i = a.length - 1; i >= 0; i--) {
if (a[i] < 10) {
System.out.print("0");
}
System.out.print(a[i] + " ");
}
System.out.println();
}
}
4、已知有十六支男子足球队参加2008 北京奥运会。写一个程序，把这16 支球队随机分为4 个组。（使用随机数）(15分)
2008 北京奥运会男足参赛国家：
科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚、日本，美国，中国，
新西兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利
package com.share.test_3_27;
import java.util.ArrayList;
import java.util.List;
public class ShangJi4 {
public static void main(String[] args) {
String s = "科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚，日本，美国，中国，新西兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利";
String name[] = s.split("，");
List list = new ArrayList();
for (String string : name) {
list.add(string);
}
while (list.size() > 0) {
int num = (int)(Math.random()*list.size());//随机数的范围在不断缩小
if(list.size()==16){
System.out.println("\nA组：");
}else if(list.size()==12){
System.out.println("\nB组：");
}else if(list.size()==8){
System.out.println("\nC组：");
}else if(list.size()==4){
System.out.println("\nD组：");
}
System.out.print(list.remove(num) + "\t");
}
}
}
