【强训】Day09

努力经营当下，直至未来明朗！

---

普通小孩也要热爱生活！

一、选择

1. 下面程序的输出是:()

String x="fmn";
x.toUpperCase();
String y=x.replace('f','F');
y=y+"wxy";
System.out.println(y);

A FmNwxy
B fmnwxy
C wxyfmn
D Fmnwxy

2. 关于 JAVA 堆,下面说法错误的是()

A 所有类的实例和数组都是在堆上分配内存的
B 对象所占的堆内存是由自动内存管理系统回收
C 堆内存由存活和死亡的对象,空闲碎片区组成
D 数组是分配在栈中的

3. JAVA语言的下面几种数组复制方法中，哪个效率最高？

A for循环逐一复制
B System.arraycopy
C Arrays.copyOf
D 使用clone方法

4. （）仅包含方法定义和常量值。

A 接口
B 变量
C 单元
D 成员

5. ☆对文件名为Test.java的java代码描述正确的是()

class Person {
    String name = "No name";
    public Person(String nm) {
        name = nm;
    }
}
class Employee extends Person {
    String empID = "0000";
    public Employee(String id) {
        empID = id;
    }
}
public class Test11 {
    public static void main(String args[]) {
        Employee e = new Employee("123");
        System.out.println(e.empID);
    }
}

A 输出：0000
B 输出：123
C 编译报错
D 输出：No name

6. 有关下述Java代码描述正确的选项是____。

public class TestClass {
    private static void testMethod(){
        System.out.println("testMethod");
    }
    public static void main(String[] args) {
        ((TestClass)null).testMethod();
    }
}

A 编译不通过
B 编译通过，运行异常，报NullPointerException
C 编译通过，运行异常，报IllegalArgumentException
D 编译通过，运行异常，报NoSuchMethodException
E 编译通过，运行异常，报Exception
F 运行正常，输出testMethod

7. 下列java程序的输出结果为____。

public class Example {
    String str = new String("hello");
    char[] ch = {'a', 'b'};

    public static void main(String args[]) {
        Example ex = new Example();
        ex.change(ex.str, ex.ch);
        System.out.print(ex.str + " and ");
        System.out.print(ex.ch);
    }

    public void change(String str, char ch[]) {
        str = "test ok";
        ch[0] = 'c';
    }
}

A hello and ab
B hello and cb
C hello and a
D test ok and ab
E test ok and cb
F test ok and c

8. 在jdk1.5之后，下列 java 程序输出结果为______。

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));

A true,false
B true,true
C false,true
D false,false
E 对于不同的环境结果不同
F 程序无法执行

---

二、编程

1. 另类加法

另类加法
给定两个int A和B。编写一个函数返回A+B的值，但不得使用+或其他算数运算符。

---

2. 走方格的方案数

走方格的方案数
请计算n*m的棋盘格子（n为横向的格子数，m为竖向的格子数）从棋盘左上角出发沿着边缘线从左上角走到右下角，总共有多少种走法。要求不能走回头路，即：只能往右和往下走，不能往左和往上走。

注：沿棋盘格之间的边缘线行走。

数据范围： 1 <= m, n <= 8

---

答案

1. 选择

1. ① 注意toUpperCase()返回的是String类型，也就是说需要使用String来接收，本身的字符串不变！
   ② String.replace(old, new); old被new替代
   ③ String是不可变的，相当于final修饰的常量字符串

so：
① x.toUpperCase()因为没有String类型来接收，而本身的字符串x是不变的！所以x依旧是fmn
② x.replace(‘f’,‘F’);是将x中的f字母替换为F字母，不改变原来的x，而是将替换后的字符串赋值给y，即y为Fmn
③ 进行字符串的拼接

故：选D

2. ① 栈数据是可以共享的，存取速度较快，仅次于寄存器；而堆数据是在运行时才分配内存的，存取速度比较慢。
   ② 堆是由垃圾回收来负责的。
   ③ 栈由线程栈和本地方法栈（每个线程都有自己的线程栈），而堆只有一个。
   ④ 方法区和堆是所有线程共享的数据区。
   ⑤ 堆分为新生代和老年代
   ⑥ JVM中只有一个堆区，被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身。
   ⑦ 数组名是对象引用，存放在栈中；数组的内容是对象本身，而数组对象保存在堆里面。
   
   参考：JVM内存划分

故：选D

3. 其实可以自己写代码进行试验

① for循环效率最低
② System.arraycopy()查看源码发现是native方法，也就是说是原生态方法，是使用c/c++语言来实现的，效率比较高

③ Arrays.copyOf()查看源码发现：其调用的是System.arraycopy()，则其效率一定是低于System.arraycopy的。

④ clone方法返回的是Object类，其需要强制类型转换，一般来说是效率最低的。

故：选B

4. 接口是要被继承or实现的，方法需要后续进行重写。

选A

5. ① 子类的构造方法总是先调用父类的构造方法，如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类不带参数的构造方法。
   ② 而父类没有无参的构造方法，所以子类需要在自己的构造方法中显示的调用父类的构造方法。

发现：父类中已经存在了有参数的构造方法，此时无参构造方法就需要自己构造，or在子类构造方法中显式地调用父类有参的构造方法。

故：选C

6. ① 此处表示的是类对方法的调用，不是对象对方法的调用。
   ② 法是static静态方法，直接使用"类.方法"即可，因为静态方法使用不依赖对象是否被创建。
   ③ 注意：null可以被强制类型转换成任意类型（不是任意类型对象），于是可以通过它来执行静态方法。
   ④ 非静态的方法用"对象.方法"的方式，必须依赖对象被创建后才能使用，若将testMethod()方法前的static去掉，则会报 空指针异常 。

故：选F

7. 一定要注意指向改变和内容改变！（画图！）
   

故：选B

8. 本题考察的是自动拆箱/装箱（只在jdk1.5之后存在）。

① 基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
② 两个Integer类型进行“==”比较，如果其值在**-128至127且值相同，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关。
③ 两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
④ 基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱**，基本型转换为其封装类型，再进行③中的比较
⑤ 基本型不能调用equals，其用于引用对象调用

故：选B

---

2. 编程

1. 另类加法

1）思路：

① 二进制按位异或^：相当于对应位相加，不考虑进位（因为只要是相同的，要么是0，要么是2然后进位）
② 按位与& 且 左移一位：考虑进位（但是如果不需要进位的0 1组合就会计算错误，此时就需要异或^计算）
③ 直到进位为0才结束循环！！

2）代码：

import java.util.*;

public class UnusualAdd {
     public int addAB(int A, int B) {
        // write code here
        if(A == 0) {
            return B;
        }

        int carry = 0; // 进位
        int sum = 0; // 非进位的结果

        while (B != 0) {
            sum = A ^ B;  // 非进位就进行异或
            carry = (A & B) << 1;  // 进位就是按位与 且 左移
            // 然后进行更新
            B = carry; // 直到进位的为0！
            A = sum;
        }
        return A;
    }
}

---

2. 走方格的方案数

1）思路：
本题是求取路径总数的题目：一般可以使用递归来进行解决；如果问题比较复杂就使用动归来解决。

① 注意：行或列为1的时候，其在一个方格内既可以上走又可以下走。故其路径总数是（n+m）【但是注意保证是存在方格的】
② 如果是(m>1 && n>1)，此时有两种方法，一种是从[m-1,n]向右走，另一种是从[m,n-1]向下走。
③ 注意递归终止的条件是(m==1 || n==1)

2）代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // n列m行
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {
            int n = in.nextInt(); // n是横向格子数，也就是列
            int m = in.nextInt(); // m是纵向格子数，也就是行
            System.out.println(routes(m,n));
        }
    }

    private static int routes(int n, int m) {
        if((m==1&&n>=1) || (m>=1&&n==1)) {
            return (m+n);
        }

        // 其他情况
        return routes(m-1,n) + routes(m,n-1);
    }
}