面向对象作业01

1. 选择题

1.分析以下程序：
1 public class TestEquals{
2 public static void main(String[]args){
3 String str1=new String(“TEDU”);
4 String str2=new String(“tedu”);
5 if(str1．equals(str2)){
6 System.out.println(“Equal”);
7 }
8 }
9 }
该程序的执行结果是（ ）。
A.程序执行后无输出 B.程序执行后输出“Equal”
C.程序在第5行出现编译错误 D.程序执行后出现异常

解析：A

2.下列类的定义中，对Object的equals()方法重写正确的是（ ）；
A.class Cell{
public int equals(){
//…
}
}
B.class Cell{
public String equals(){
//…
}
}
C.class Cell{
public boolean equals(){
//…
}
}
D.class Cell{
public Object equals(){
//…
}
}

解析： C ,重写遵从两同两小一大原则， 两同：方法名相同，参数列表相同； 两小：①子类返回值类型 如果是 基本数据类型 必须相同， 若是 引用 类型必须小于父类返回值类型；② 子类抛出的异常必须小于父类； 一大： 子类访问权限小于或等于父类。

3.先阅读下面的程序片段：
String str1=new String(“TEDU”);
String str2=new String(“TEDU”);
StringBuffer str3=new StringBuffer(“TEDU”);
对于上述定义的变量，以下表达式的值为true的是（ ）。
A.str1 == str2; B.str1.equals(str2);
C.str1 == str3; D.str2==str3;

解析：B. 因为字符串Sting中 已经 重写父类（Object）中的equals,比较的是当前对象的属性值

4.定义如下变量，boolean isUse = false,则String.valueOf(isUse)
返回的类型是（ ）。
A.boolean B.String
C.int D.char

解析： B。 方法 valueOf([形参类型 形参名])将指定形参转换为字符串类型

5.String str1 = “TEDU”;String str2 = str1+“tedu”,创建了（ ）个对象
A.1 B.2 C.3 D.4

解析： C.① 首先在常量池中创建第一个字符串对象"TEDU"，②在常量池中创建第二个字符串对象"tedu". ③ 进行字符串拼接时 在常量池中创建第三个字符串对象 “TEDUtedu”.注意： str1 和 str2 只是变量引用名，存储在栈中。

6.下列程序输出结果是（ ）。
String str = “华创 is a very good company!”;
boolean bo1 = str.startsWith(“华创”)&&str.endsWith(“company”);
System.out.println(bo1);
A.true B.false C.编译错误 D.运行时异常

解析：B. boolean startsWith(String str) 和 boolean ends With(String str) 两方法分别是判断该对象是否以 形参字符串开头 和 结尾。题中缺少 " ! "号 ，所以返回false

7.阅读下列代码：
class Emp{
private int empNo;
private String ename;
public int getEmpNo() {
return empNo;
}
public void setEmpNo(int empNo) {
this.empNo = empNo;
}
public String getEname() {
return ename;
}
public void setEname(String ename) {
this.ename = ename;
}
public int hashCode() {
return empNo;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Emp other = (Emp) obj;
if (empNo != other.empNo)
return false;
return true;
}
public static void main(String[] args) {
Emp e1 = new Emp();
e1.setEmpNo(1001);
e1.setEname(“王鹏力”);
Emp e2 = new Emp();
e2.setEmpNo(1001);
e2.setEname(“Robin”);
System.out.println(e1==e2);
System.out.println(e1.equals(e2));
}
}
运行该类，输出结果是（ ）；
A.false false B.false true C.true false D.true true

解析： B。 注意题中重写后的 boolean equals(Object ob） 方法中 只比较EmpNo 是否不相等，不相等返回false；显然相等返回 true

8.在Java语言中，String类型的成员变量的默认初始值是（ ）。
A.undefined B."" C.0 D.null

解析：初始化无论怎么强调都不过分！Java为所有的成员变量提供了默认初始化：byte、short、 int、long–0 float–0.0f double–0.0 boolean–false char–’"u0000’，特别地对象类型的引用全被初始化为null。（注意！除了数组之外的局部变量是得不到这种优待的，需要你自己初始化。另外，默认初始化的值是你想要的吗？所以最好明确地对变量进行初始化，一般是在构造函数中。）

9.如下程序：
String str = “I can do it because I think I can”;
int index1 = str.indexOf(“can”);
int index2 = str.lastIndexOf(“can”);
int result = index1 + index2;
result结果是：（ ）。
A.2 B.30 C.32 D.-1

解析： B。 int indexOf(“字符串”)，返回形参字符串 在当前对象从左往右第一次出现的索引。lastIndexOf(“字符串”).返回形参字符串在当前对象从左往右最后一次出现的索引。

10.String str = “We are students”; 下面说法正确的是（ ）。
A.str的长度是15 B.str的长度是14
C.str.indexOf(“a”)返回的结果是3
D.str.lastIndexOf(“e”)返回的结果是3

11.以下for循环的执行次数是（ ）。
for（int x=0,y=0;(y!=0)&&(x<4);x++）;
A.无限次 B.一次也不执行
C.执行四次 执行三次

12.编译运行以下程序后，关于输出结果的说明正确的是（ ）
publicclass Conditional{
public static void main(String args[]){
int x=4;
System.out.println("value is "+ ((x>4) ? 99.9 : 9));
}
}
A.输出结果为：value is 99.99 输出结果为：value is 9
C.输出结果为：value is 9.0 编译错误

解析： C. 在进行比较时 ，JVM（java虚拟机）会自动统一类型。小类型转大类型。

13.阅读下列代码;
public class Test{
String s=“One World One Dream”;
public static void main(String args[]){
System.out.println(s);
}
}
其运行结果是（）
A.args
B.One World One Dream
C.s
D.编译错误

解析： 主方法是静态方法。无法从静态上下文中引用非静态变量

14.下面哪个是正确的（ ）
A.String temp [] = new String {“a”“b”“c”};
B.String temp [] = {“a”“b”“c”};
C.String temp = {“a”, “b”, “c”};
D.String temp [] = {“a”, “b”, “c”};

15.关于 Java 类中带参数的方法，下列选项中说法错误的是
A.使用带参数的方法分为两步：定义带参数的方法，调用带参数的方法
B.带参数方法的返回值不能为 void
C.带参数方法的参数个数可以为一个或多个
D.带参数方法的参数可以是任意的基本类型数据或引用类型数据

解析： 注意此题 强调的是带参数方法。则至少一个参数

16.下列说法错误的有()
A.数组是一种对象
B.数组属于一种原生类
C.int number=[]={31,23,33,43,35,63}
D.数组的大小可以任意改变
解析：BCD .Java中，数据类型分为基本数据类型（或叫做原生类、内置类型）和引用数据类型。原生类是指基本数据类型。

17.下列有关于变量的命名正确的是
A.可以由字母、数字、下划线、”$”组成;
B.首字母能以数字开头
C.首字母不能以数字开头
D.Java大小写敏感,命名变量时需要注意

解析： 不能与java 内置的关键字相同

18.从下列选项中选择正确的是（ ）
A.int k=new String(“aa”);
B.String str=new String(“bb”);
C.char c=74;// 74对应ASCALL 码值，为J。
D.long j=8888;

19.已知如下代码：
public class Test{
public static void main(String arg[] ){
int i = 5;
do{
System.out.print(i);
}while(–i>5);
System.out.print(“finished”);
}
}
执行后会输出（ ）
A.5
B.4
C.6
D.finished

20.下列关于循环说法错误的是（ ）
A.while 循环先判断后执行，do…while 先执行后判断
B.do…while 循环结束的条件是 while 后的条件成立
C.do…while 循环的循环体至少无条件执行一次
D.for 语句构成的循环可以用其他循环语句替换

21.java中main方法写法正确的是()
A.public static void main
B.public void main(String[] args)
C.public static void main(String[] args)
D.static void main(String[] args)

22.下列代码执行的结果是（）。
class Base {
void test() {
System.out.print(“Base.test()”);
}
}
class Child extends Base {
void test() {
System.out.print(“Child.test()”);
}
static public void main(String[] a) {
Child anObj = new Child();
Base baseObj = (Base)anObj;
baseObj.test();
}
}
A.Child.test()Base.test()
B.Base.test()Child.test()
C.Base.test()
D.Child.test()

解析：创建多态对象测试
向上造型：父类的引用 指向 子类的对象
口诀：编译看左，运行看右
编译看左 --能调用什么看父类有什么
运行看右 --运行的结果看子类是否进行重写，如果重写了就调用子类
重写之后的方法体，否则直接使用父类的方法体。

23.Java语言中，使用关键字哪个对当前对象的父类对象进行引用（）
A.super
B.this
C.new
D.extends

24.下面选项中哪两个可以在 A 的子类中使用（ ）
class A {
protected int method1 (int a, int b) {
return 0;
}
}
A.public int method1(int a, int b) { return 0; }
B.private int method1(int a, int b) { return 0; }
C.private int method1(int a, long b) { return 0; }
D.public short method1(int a, int b) { return 0; }

解析： C 是方法重载。D选项，重写要遵从两同两小一大原则。 两同：方法名相同，参数列表相同； 两小：①子类返回值类型 如果是 基本数据类型 必须相同， 若是 引用 类型必须小于父类返回值类型；② 子类抛出的异常必须小于父类； 一大： 子类访问权限小于或等于父类。

25.执行下列代码后,哪个结论是正确的（ ）
String[] s=new String[10];
A.s[9]为null;
B.s[10]为"";
C.s[0]为未定义
D.s.length为10

26.在JAVA 8.0版本之前，接口中可以定义( )。
A.静态方法
B.常量
C.构造方法
D.抽象方法

解析： ①Java8以前接口中只能有抽象方法，如果在接口中增加方法（抽象方法），子类中必须重写此方法，从java 8 开始，可以增加非抽象方法，此方法用default修饰 例如：public default void show(),这是接口的默认功能，实现类中可以自由选择是否重写。②增加静态方法，隶属于接口层级：例如：public static void test(){},可以通过接口名.的方式调用，省略对象的创建。注意：从Java9开始允许接口中可以有私有方法：例如 private void show(){} 这是新特性，只能是私有方法，且可以有方法体

27.下列哪一种叙述是正确的（ ）
A.abstract 修饰符可修饰字段、方法和类
B.抽象方法的 body 部分必须用一对大括号{ }包住
C.声明抽象方法，大括号可有可无
D.声明抽象方法不可写出大括号

解析： A答案，abstract 不能修饰字段（属性，成员变量），B 抽象方法没有方法体，连大括号都没有。

28.方法重载是（）
A.方法名相同，参数列表不同
B.方法名相同，参数列表相同
C.方法名不同，参数列表相同
D.方法名不同，参数列表不同

29.接口是 Java 面向对象的实现机制之一，以下说法正确的是（ ）
A.Java 支持多重继承，一个类可以实现多个接口
B.Java 只支持单重继承，但一个类可以实现多个接口
C.Java 只支持单重继承，一个类只可以实现一个接口
D.Java 支持多重继承，但一个类只可以实现一个接口

解析： 接口interface为了弥补Java中类不支持多继承的缺陷，提供接口，实现多继承机制

30.在JAVA中，已定义两个接口B和C,要定义一个实现这两个接口的类，以下语句正确的是（ ）。
A.interface A extend B,C
B.interface A implements B,C
C.class A implements B,C
D.class A implements B, implements C

31.在创建对象时，必须（ ）
A.先声明对象，然后才能使用对象
B.先声明对象，为对象分配内存空间，然后才能使用对象
C.先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象
D.上述说法都对

32.下列说法正确的有（ ）
A.class 中的 constructor 不可省略
B.constructor 必须与 class 同名，但方法不能与 class 同名
C.constructor 在一个对象被 new 时执行
D.一个 class 只能定义一个 constructor

33.不能用来修饰 interface 的有（ ）
A.private
B.public
C.protected
D.static

34.在Java中，如果父类中的某些方法不包含任何逻辑，并且需要有子类重写，应该使用（）关键字来申明父类的这些方法。
A.final
B.static
C.abstract
D.void

35.Java语言中，使用哪个关键字对当前对象的父类对象进行引用（）
A.super
B.this
C.new
D.extends

36.下列关于修饰符混用的说法，错误的是（ ）
A.abstract 不能与 final 并列修饰同一个类
B.abstract 类中可以有 private 的成员
C.abstract 方法可以放在 abstract 类或接口中
D.static 方法中能直接使用非 static 的属性

37.属性的可见性有（ ）
A.public
B.default
C.private
D.protected

38.下列变量命名哪个是合法的（）
A.class
B.$abc
C.1234
D._name

39.下面选项中哪两个可以在 A 的子类中使用（ ）
class A {
protected int method1 (int a, int b) {
return 0;
}
}
A.public int method1(int a, int b) { return 0; }
B.private int method1(int a, int b) { return 0; }
C.private int method1(int a, long b) { return 0; }
D.public short method1(int a, int b) { return 0; }

40.下述代码的执行结果是（ ）
class Super {
public int getLength() {
return 4;
}
}
public class Sub extends Super {
public long getLength() {
return 5;
}
public static void main (String[] args) {
Super sooper = new Super ();
Super sub = new Sub();
System.out.println(sooper.getLength() + “,” + sub.getLength());
}
}
A.4,4
B.4,5
C.5,4
D.代码不能被编译

解析： 子类重写父类方法必须遵循两同两小一大规则；两小，子类返回值类型若是基本数据类型，必须与父类返回值 类型相等。若是引用类型必须小于等于父类返回值类型； 子类抛出的异常必须小于父类； 两同： 方法名相同，参数列表相同； 一大，子类访问权限大于等于父类

二.填空题
1.对于long型变量，内存分配（8 ）个字节
2.在循环体中，如果想结束当前循环可以用（ continue ）语句
3.Java中一个类可有（ 1 ）个父类
4.构造方法（ 可以 ）重载，不能重写
5.子类（ 不能 ）访问父类的私有属性

三.判断题
1.抽象类中有构造函数？（ √ ）
2.封装的意思是为了对外隐藏内部细节实现（√ ）
3.抽象类中必须有抽象方法，否则不是抽象类（ ×）
4.在一个静态方法内部能发出对非静态方法的访问（× ）
5.final和abstract不能同时使用（ √）
6.一个类可以实现多个接口（√ ）
7.接口可以继承多个接口（ √ ）
8.super()和this()不能同时出现在一个方法里（ √ ）
9.return可以结束循环（ √ ）
10.抽象类必须实现接口的抽象方法（ × ）
11.抽象类必须实现接口的所有抽象方法（ ×）
12.final修饰的成员变量如果未初始化，可以在构造器中初始化（√ ）
13.构造方法可以重写（ ）
14.long a=100;和long a1=100L;意义相同（ × ）
15.switch case中的参数可以为char类型（ √ ）

四. 简答题
1.switch case中switch中传递的参数都可以为哪些类型的？

byte short char int, String ，enum 枚举

2.static和final关键字的用法

static 可修饰 属性，方法 ，类（静态内部类），静态代码块，静态导入
final 修饰 属性 不可变， 修饰 方法不可被重写，修饰 类 不能被继承

3.重写和重载的区别
重载： 两同一不同。 两同： 同一个类，同一个方法名。一不同： 参数列表不同。重载与返回值类型，访问权限修饰符，方法体无关。

重写： 两同两小一大。 ①两小，子类返回值类型若是基本数据类型，必须与父类返回值 类型相等。若是引用类型必须小于等于父类返回值类型； 子类抛出的异常必须小于父类；② 两同： 方法名相同，参数列表相同；③ 一大，子类访问权限大于等于父类
4.接口与抽象类的区别
抽象类和接口的主要区别（笔试简答）
定义抽象类的关键字是abstract ，而定义接口的关键字是interface
继承抽象类的关键字是extends , 而实现接口的关键字是implements
继承抽象类支持单继承，而实现接口支持多实现
抽象类中可以有构造方法，而接口中不可以有构造方法
抽象类中可以有成员方法，成员属性，抽象方法，构造方法，而接口中只能有常量，私有方法，抽象方法。默认方法
java8 以前的版本，抽象类中增加方法时子类可以不用重写，而接口中增加方法时实现类需要重写
从Java8开始增加新特性， 接口中允许出现非抽象方法和静态方法，但非抽象方法需要使用default关键字修饰。
从Java 9 开始增加新特性，接口中允许出现私有方法
五.编程题
1.统计9这个字符在目标字符串中出现的次数（目标字符串 李荣lir999ong4567899）

法一：
      //1.统计9这个字符在目标字符串中出现的次数（目标字符串 李荣lir999ong4567899）
        String str = "李荣lir999ong4567899";
        int sum = 0;
        int index = 0;
        while((index = str.indexOf("9",index)) != -1){
            sum++;
            index++;
        }

import java.util.Arrays;
public class calculate {
    public static void main(String[] args){
        String str = "李荣 lir999ong456899";
        char[] c = new char[str.length()];
        for (int i = 0; i < str.length(); i++){
            c[i] = str.charAt(i);
        }
        System.out.println(Arrays.toString(c));
        int count = 0;
        for (int i = 0; i < c.length;i++){
            if ('9' == c[i]){
                count += 1;
            }
        }
        System.out.println(count);
    }
}

2.生成一个6个元素的随机int数组，然后用冒牌排序将这个数组由小到大进行排序

/**
 * @author yyc
 */
import java.util.Random;
import java.util.Arrays;
public class HomeWork {
    public static void main(String[] args){
        Random random = new Random();
        int[] arrNum = new int[6];
        for (int i = 0; i < arrNum.length; i++){
            arrNum[i] = random.nextInt(100)+1;
            for (int j = 0; j < i; j++){ //控制不生成重复数字
                if (arrNum[i] == arrNum[j]) { //若两相同，则i--重新生成
                    i--;
                }
            }
        }
        //冒泡排序
        for (int i = 0; i < arrNum.length - 1; i++){
            for (int j = 0; j < arrNum.length - 1 - i; j++){
                if (arrNum[j] > arrNum[j+1]) {
                    int temp = arrNum[j];
                    arrNum[j] = arrNum[j + 1];
                    arrNum[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrNum));
    }
}