未来工作室月末考核总结

2018级未来工作室第二次考核

一、 选择题（每道题3分，共30分）

1. 下列 javaDoc 注释正确的是（D ）

A、 /* 我爱北京天安门 */

B、 //我爱北京天安门 */

C、 /** 我爱北京天安门 */

D、 /* 我爱北京天安门 **/

Java注释三种格式

单行注释 //

多行注释 /*

语句 */

文档注释 /** */

2. 在 Java语言中，下列关于类的继承的描述，正确的是（A ）

A、 一个类可以继承多个父类

B、 一个类可以具有多个子类

C、 子类可以使用父类的所有方法

D、 子类一定比父类有更多的成员方法

JAVA语言不支持多重继承，一个类只能有一个直接父类。子类继承父类的成员变量和成员方法，同时可以修改父类的成员变量或重写父类的方法，还可以添加新的成员变量或成员方法。

3. 下面说法中错误的是(D  )

A、 静态代码块类一加载只执行一次 , 以后再创建对象的时候不执行

B、 局部代码块的作用是为了限制变量的生命周期

C、 构造代码块在每创建一次对象就执行一次

D、 以上都不对

类初始化时，静态代码块类一加载只执行一次。Static{}，普通代码块{}。局部变量（方法内的变量），成员变量（类中的变量）。构造器（有参，无参），如果不定义有参的构造器，系统默认有一个无参的构造器，如果定义了，则需要再次定义无参构造器。

4. 下列关于修饰符混用的说法，错误的是（D ）

A、 abstract不能与final并列修饰同一个类

B、 abstract类中不可以有private的成员

C、 abstract方法必须在abstract类中

D、 static方法中能处理非static的属性

 

5. 我国最高山峰是珠穆朗玛峰，8848米。现在我有一张足够大的纸，它的厚度是0.001米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度为（B ）

A、 20

B、 22

C、 24

D、 26

6. 分析选项中关于Java中this关键字的说法正确的是（D ）

A、 this关键字是在对象内部指代自身的引用

B、 this关键字可以在类中的任何位置使用

C、 this关键字和类关联,而不是和特定的对象关联

D、 同一个类的不同对象共用一个this

在某一构造方法中调用另一构造方法时，必须使用this关键字调用，this关键字必须写在构造方法内的第一行位置

7. 下列关于字符串的描叙中错误的是（A ）

A、 字符串是对象

B、 String 对象存储字符串的效率比 StringBuffer 低

C、 可以使用 StringBuffer sb="这里是字符串"; ，声明并初始化 StringBuffer 对象 sb

D、 String 类提供了许多用来操作字符串的方法：连接，提取，查询等

StringBuffer sBuffer = new StringBuffer("字符串内容");

String sb="这里是字符串";

8. 下列选项中关于 Java中封装的说法错误的是（A ）

A、 封装就是将属性私有化，提供共有的方法访问私有属性

B、 属性的访问方法包括 setter 方法和 getter 方法

C、 setter 方法用于赋值， getter 方法用于取值

D、 包含属性的类都必须封装属性，否则无法通过编译

封装：将属性私有化（private），然后使用get，set方法去取值和赋值。

9. 在Java中,下面对于构造函数（构造器）的描述错误的是（B ）

A、 类不一定要显式定义构造函数

B、 构造函数的返回类型是void

C、 如果构造函数不带任何参数,那么构造函数的名称和类名可以不同

D、 一个类可以定义多个构造函数

构造方法的名称必须与它所在的类名完全相同，构造方法无返回值，构造方法名前不能用修饰符void来修饰，因为一个类的构造方法的返回值类型就是该类本身

10. 匹配一个以155开头和1379结尾的11位电话号码，以下选项正则表达式正确的是（B ）

A、 ^（155）[0-9]{4}(1379)$

B、 ^155(.){4}(1379)$

C、 ^（155）{0-9}{4}(1379)$

D、 ^155[\\w]{4}(1379)$

正则表达式

二、 简答/填空题（共25分）

1. abstract 与哪些关键字不能共存为什么？（6分）

与final，private不能共存

abstract类是创建格式相同的子类，代表抽象；

final代表最终，两者相冲突

private代表私有的，不能被其他类所访问

final：首先abstract修饰的类，该类中的方法子类继承之后需要重写的，可是final修饰的类不能比继承，也就没子类，方法更不能得到重写，相互冲突；不能共存

private：私有的意思，方法子类是不能被继承到的，那么方法就没有被重写，可是abstract是要求方法重写的也相互冲突；不能共存

static：static能被实例化可直接调用，abstract是不能被实例化的，冲突，不能共存。所谓实例化就是创建对象理解为new对象就可以了；

2. 给定 java 代码如下所示，在 A 处增加一个方法，是对 cal 方法的重载（6分）

    public class Test {

        public void cal(int x, int y, int z) {

        }

    1.public int cal(int x,int y,float z){}

    2.public void cal(int x,int z){}       

方法的重载中参数的类型是关键，仅仅是参数的变量名不同是不行的，参数的列表必须不同，即：或者参数个数不同，或者参数类型不同，或者参数的顺序不同

    }

3. 用Calendar类来获取系统时间的年份________。（6分）

Calendar calendar=Calendar.getInstance();

int year = calendar.get(Calendar.YEAR); 

4. 美国数学家维纳(N.Wiener)智力早熟，11岁就上了大学。他曾在1935~1936年应邀来中国清华大学讲学。一次，他参加某个重要会议，年轻的脸孔引人注目。于是有人询问他的年龄，他回答说：“我年龄的立方是个4位数。我年龄的4次方是个6位数。这10个数字正好包含了从0到9这10个数字，每个都恰好出现1次。”请问他的年龄是___19_____。（7分）

package PREV_55;

public class Test {
    public static void main(String[] args) {
        char[] a, b;
        int[] c = new int[10];
        for (int i = 11; i <= 99; i++) {
            a = String.valueOf(i * i * i).toCharArray();
            b = String.valueOf(i * i * i * i).toCharArray();

            int g = i*i*i;
            int h = i*i*i*i;
            if (g >= 1000 && g <= 9999) {
                if (h >= 100000 && h <= 999999) {
                    for (int j = 0; j < 4; j++) {
                        c[j] = a[j] - '0';
                    }
                    for (int k = 0; k < 6; k++) {
                        c[k + 4] = b[k] - '0';
                    }
                    int[] e = new Test().sort(c);
                    boolean f = new Test().judge(e);
                    if(f) {
                        System.out.println(i);
                        break;
                    }
                }
            }

        }
    }

    public int[] sort(int[] a) {
        int t;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length - 1; j++) {
                if (a[j] > a[j + 1]) {
                    t = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = t;
                }
            }
        }
        return a;
    }
    
    public boolean judge(int[] a) {
        int[] b = {0,1,2,3,4,5,6,7,8,9};
        for(int i = 0;i<b.length;i++) {
            if(b[i] != a[i]) {
                return false;
            }
        }
        return true;
    }

}

三、 编程题（共45分）

1. 给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字（10分）

package PREV_55;

public class Test {
    public static void main(String[] args) {
        char[] a, b;
        int[] c = new int[10];
        for (int i = 11; i <= 99; i++) {
            a = String.valueOf(i * i * i).toCharArray();
            b = String.valueOf(i * i * i * i).toCharArray();

            int g = i*i*i;
            int h = i*i*i*i;
            if (g >= 1000 && g <= 9999) {
                if (h >= 100000 && h <= 999999) {
                    for (int j = 0; j < 4; j++) {
                        c[j] = a[j] - '0';
                    }
                    for (int k = 0; k < 6; k++) {
                        c[k + 4] = b[k] - '0';
                    }
                    int[] e = new Test().sort(c);
                    boolean f = new Test().judge(e);
                    if(f) {
                        System.out.println(i);
                        break;
                    }
                }
            }

        }
    }

    public int[] sort(int[] a) {
        int t;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length - 1; j++) {
                if (a[j] > a[j + 1]) {
                    t = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = t;
                }
            }
        }
        return a;
    }
    
    public boolean judge(int[] a) {
        int[] b = {0,1,2,3,4,5,6,7,8,9};
        for(int i = 0;i<b.length;i++) {
            if(b[i] != a[i]) {
                return false;
            }
        }
        return true;
    }

}

2. 有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问前20个月每个月的兔子总数为多少？（9分）

 

public class Test2 {
    
        public static void main(String[] args) {
            System.out.println("斐波那契数列：" );
            //方法一：变量
            int a=1 , b=1 , c=0;
            System.out.print( a +" " + b + " ");
            for(int i=2; i<20; i++){
                c = a + b;
                a = b;
                b = c;
                System.out.print(c + " ");
            }
            System.out.println();

    }

}

3. 按题目编程实现下列功能。（26分）

要求：按照题目所给变量名称、类型和方法名称进行编程，禁止修改；

    （1） 图书馆接口（Library）

        成员方法：

            borrow( )，借阅图书

            revert( )，归还图书

    （2） 图书类（Book）

        成员变量：

            图书名称（name)         String类型

            出版社(publisher)           String类型

        构造方法：

            通过形参初始化图书名称（name）和出版社（publisher）

        普通方法：

            1）设置getter和setter方法用于获取和设置类中name变量的值；

            2）重写equals方法，当且仅当书名（name)和出版社(publisher) 均相等时，即为同一本书。

            3）重写toString方法，返回书名（name)和出版社(publisher)的信息，样式如下：“书名：Java程序设计，出版社：清华大学出版社”

    （3） 馆藏图书类（CollectionBook），继承自Book类，实现Library接口

        成员变量：

            图书编号（bId）         String类型         

            是否借阅（isBorrow）    boolean类型     图书状态为已借阅时，值为true

        构造方法：

            调用父类构造方法初始化书名（name)和出版社(publisher)信息，然后初始化图书编号（bId）和线路图书书库（stacks）。

        普通方法：

            1）实现接口中的borrow方法

                如果图书状态为已借阅，则输出“对不起，该图书已借阅”，否则，修改该图书状态为已借阅，输出“借阅成功”

            2）实现接口中的revert方法

                如果图书状态是可借阅状态，输出“该图书已归还”，否则，修改图书借阅状态为未借阅，并输出“还书成功”；

    （4）通过main函数测试。

        1）创建两个CollecitonBook对象book1和book2，分别输出book1和book2，并调用其equals方法判断两个对象是否相等；

        2）通过键盘输入整数，输入0，则对book1进行借阅，输入1，则对book1进行归还操作。

package PREV_55;

import java.util.Scanner;

public class Answer2 {
    public static void main(String[] args) {
        CollectionBook book1 = new CollectionBook("Java1234","人民邮电","1",true);
        CollectionBook book2 = new CollectionBook("Java5678","人民邮电","2",false);
        System.out.println(book1.equals(book2));
        Scanner scanner = new Scanner(System.in);
        int a = Integer.parseInt(scanner.nextLine());
        if(a == 0) {
            book1.borrow();
        }else if(a == 1) {
            book1.revert();
        }
    }
}

interface Library{
    void borrow();
    void revert();
}

class Book{
    private String name;
    private String publisher;
    
    public Book(String name, String publisher) {
        this.name = name;
        this.publisher = publisher;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPublisher() {
        return publisher;
    }

    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((publisher == null) ? 0 : publisher.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Book other = (Book) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (publisher == null) {
            if (other.publisher != null)
                return false;
        } else if (!publisher.equals(other.publisher))
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "书名："+name+",出版社:"+publisher;
    }        
}

class CollectionBook extends Book implements Library{
    private String bId;
    private boolean isBorrow;
    
    public CollectionBook(String name, String publisher, String bId, boolean isBorrow) {
        super(name, publisher);
        this.bId = bId;
        this.isBorrow = isBorrow;
    }

    @Override
    public void borrow() {
        if(isBorrow) {
            System.out.println("对不起，该图书已借阅");
        }else {
            System.out.println("借阅成功");
        }
        
    }

    @Override
    public void revert() {
        if(isBorrow) {
            System.out.println("还书成功");
        }else {
            System.out.println("该图书已归还");
        }
        
    }    
}