Java面向对象编程（30）

考虑下面这个简单的例子，让我们看看reflection是如何工作的。

mport java.lang.reflect.*;
public class DumpMethods{
public static void main(String[] args) {
try {
Class c=Class.forName(args[0]);
Method m[]=c.getDeclaredMethods();
for (int i = 0; i < m.length; i++) {
System.out.println(m[i].toString());
}
} catch (Throwable e) {
System.err.println(e);
}
}
}

其中"c.getDeclaredMethods"的作用是:

A. 取得类的公有方法对象

B. 取得类的所有公有方法名称

C. 取得类的所有方法对象

D. 以上选项都不正确

答案：D

java 的字符类型采用的是 Unicode 编码方案，每个 Unicode 码占用（）个比特位。

A. 8

B. 16

C. 32

D. 64

答案：B

下列哪些语句关于 java 内存回收的说明是正确的？

A. 程序员必须创建一个线程来释放内存

B. 内存回收程序负责释放无用内存

C. 内存回收程序允许程序员直接释放内存

D. 内存回收程序可以在指定的时间释放内存对象

答案：B

以下多线程对int型变量x的操作,哪个不需要进行同步()

A. ++x

B. x=y

C. x++

D. x=1

答案：D

如果希望某个变量只可以被类本身访问和调用，则应该使用下列哪一种访问控制修饰？

A. public

B. private

C. private protected

D. protected

答案：B

有如下4条语句：()

Integer i01=59;
int i02=59;
Integer i03=Integer.valueOf(59);
Integer i04=new Integer(59);

以下输出结果为false的是:

A. System.out.println(i01==i02);

B. System.out.println(i01==i03);

C. System.out.println(i03==i04);

D. System.out.println(i02==i04);

答案：C

关于以下程序代码的说明正确的是()

public class HasStatic {// 1
private static int x = 100;// 2
public static void main(String args[]) {// 3
HasStatic hsl = new HasStatic();// 4
hsl.x++;// 5
HasStatic hs2 = new HasStatic();// 6
hs2.x++;// 7
hsl = new HasStatic();// 8
hsl.x++;// 9
HasStatic.x--;// 10
System.out.println(" x=" + x);// 11
}
}

A. 程序通过编译，输出结果为:x=102

B. 程序通过编译，输出结果为:x=103

C. 10行不能通过编译.因为x星私有静态变量

D. 5行不能通过编译.因为引用了私有静态变量

答案：A

以下代码输出的是：

public class SendValue{
public String str="6";
public static void main(String[] args) {
SendValue sv=new SendValue();
sv.change(sv.str);
System.out.println(sv.str);
}
public void change(String str) {
str="10";
}
}

A. 6

B. 10

C. 都不对

D. 16

答案：A

以下关于java封装的描述中，正确的是：

A. 封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性

B. 封装的意义不大，因此在编码中尽量不要使用

C. 如果子类继承父类，对于父类中进行封装的方法，子类仍然可以直接调用

D. 只能对一个类中的方法进行封装，不能对属性进行封装

答案：A

在类设计中，类的成员变量要求仅仅能够被同一package下的类访问，请问应该使用下列哪个修饰词（）

A. protected

B. public

C. private

D. 不需要任何修饰词

答案：D

最难的问题

题目描述：NowCoder生活在充满危险和阴谋的年代。为了生存，他首次发明了密码，用于军队的消息传递。假设你是军团中的一名军官，需要把发送来的消息破译出来、 并提 供给你的将军。

消息加密的办法是：对消息原文中的每个字母，分别用该字母之后的第5个字母替换（例如：消息原文中的每个字母A 都分别替换成字母F），其他字符不 变，并 且消息原文的所有字母都是大写的。

密码中的字母与原文中的字母对应关系如下。

密码字母：A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

原文字母：V W X Y Z A B C D E F G H I J K L M N O P Q R S T U

输入描述：输入包括多组数据，每组数据一行，为收到的密文。

密文仅有空格和大写字母组成。

输出描述：对应每一组数据，输出解密后的明文。

public class Main47 {
//    最难的问题
public static void main(String[] args) {
    Scanner scanner=new Scanner(System.in);
    while (scanner.hasNext()){
        String line=scanner.nextLine();
        StringBuilder sb=new StringBuilder();
        for (int i = 0; i < line.length(); i++) {
            char c=line.charAt(i);
            if (c==' '){
                sb.append(" ");
            }else {
                sb.append((char) (c>'E' ?c-5:c+21));
            }
        }
        System.out.println(sb);
    }
}
}

因子个数

题目描述：一个正整数可以分解成一个或多个数组的积。例如36=2*2*3*3，即包含2和3两个因子。NowCoder最近在研究因子个数的分布规律，现在给出一系列正整数， 他希望你开发一个程序输出每个正整数的因子个数。

输入描述：输入包括多组数据。 每组数据仅有一个整数n (2≤n≤100000)。 输出描述：对应每个整数，输出其因子个数，每个结果占一行。

public class Main48 {
    //因子个数
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        while (scanner.hasNext()){
            int n=scanner.nextInt();
            int count=0;
            for (int i = 2; i < Math.sqrt(n); i++) {
                if (n % i==0){
                    while (n % i==0){
                        n=n/i;
                    }
                    count++;
                }
            }
            if (n != 1){
                count++;
            }
            System.out.println(count);
        }
    }
}