笔试强训day30

一、选择题

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

import 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 以上选项都不正确
他的回答： A (错误)
正确答案： D
getDeclaredMethods:
获取该对象的所有声明的方法:包含该类中所有权限方法(public private 包访问权限 protected)不包含从父类中继承的方法
2、java 的字符类型采用的是 Unicode 编码方案，每个 Unicode 码占用（）个比特位。
A 8
B 16
C 32
D 64
他的回答： A (错误)
正确答案： B
3、下列哪些语句关于 java 内存回收的说明是正确的？
A 程序员必须创建一个线程来释放内存
B 内存回收程序负责释放无用内存
C 内存回收程序允许程序员直接释放内存
D 内存回收程序可以在指定的时间释放内存对象
他的回答： B (正确)
正确答案： B
4、以下多线程对int型变量x的操作,哪个不需要进行同步()
A ++x
B x=y
C x++
D x=1
他的回答： D (正确)
正确答案： D
D是原子操作。
5、如果希望某个变量只可以被类本身访问和调用，则应该使用下列哪一种访问控制修饰？
A public
B private
C private protected
D protected
他的回答： B (正确)
正确答案： B
6、有如下4条语句：()

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

以下输出结果为false的是:
A System.out.println(i01i02);
B System.out.println(i01i03);
C System.out.println(i03i04);
D System.out.println(i02i04);
他的回答： C (正确)
正确答案： C
参考答案：
A、D选项，当包装类与基本数据类型对比时，包装类会自动拆箱变为基本类型再进行比较，即Integer i01会拆箱为int类型与i02对比。因此System.out.println(i01i02);输出为true。
B选项，包装数据类直接赋值，默认调用其对用的valueOf()方法。那么Integer i03=Integer.valueOf(59);就等价于Integer i01=59;valueOf()操作-128 ~ 127之内的整型，在第一次引用，会在缓存中new一个对象；再次引用，直接从缓存中查找；操作-128 ~ 127之外的整型，则每次都要new一个对象。也就是说如果已经创建了一个-128 ~ 127之间的整数，使用valueOf创建第二次时，不会使用new关键字，而用已经缓存的对象。因此System.out.println(i01i03);输出true。
C选项，包装类是基础数据类型的引用类型，i04的定义使用了new关键字，这会开辟出一块新内存来放置值为59的Integer对象。那么两个地址不同的引用类型变量进行==判断结果自然是false。答案选择C。
7、关于以下程序代码的说明正确的是()

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行不能通过编译.因为引用了私有静态变量
他的回答： C (错误)
正确答案： A
8、以下代码输出的是：

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 (正确)
正确答案： A
参考答案：
考察Java得值传递问题，change()方法中的str与sv.str都是新的对象实例成员变量值"6"的引用， 由于String类型的不可变性，change()方法中的str="10"语句实际上是将传入的str副本引用指向了一个值为“10”的新的内存地址，但原数据引用sv.str的引用值（也就是“6”的内存地址）并没有发生改变，因此sv.str指向的
值仍旧为6。不理解的同学可以看另一种情况，代码如下

class SendValue{ public String[] str={"1"}; public static void main(String[] args) { SendValue sv=new SendValue(); sv.cha
nge(sv.str); System.out.println(sv.str[0]); } public void change(String[] str) { str[0]="2"; } }

输出
2
这种情况下则是将srt指向的地址的值从1改成了2，而不是直接将str的副本引用指向一个新地址，再看如下代码

class SendValue{ public String[] str= {"1"}; public static void main(String[] args) { SendValue sv=new SendValue(); sv.ch
ange(sv.str); System.out.println(sv.str[0]); } public void change(String[] str) { str = new String[] {"2"}; } }

输出
1
这种情况则是将str的副本引用指向了一个新的内存地址，但原数据引用sv.str并不受影响。
综上，选A
9、以下关于java封装的描述中，正确的是：
A 封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性
B 封装的意义不大，因此在编码中尽量不要使用
C 如果子类继承父类，对于父类中进行封装的方法，子类仍然可以直接调用
D 只能对一个类中的方法进行封装，不能对属性进行封装
他的回答： A (正确)
正确答案： A
10、在类设计中，类的成员变量要求仅仅能够被同一package下的类访问，请问应该使用下列哪个修饰词（）
A protected
B public
C private
D 不需要任何修饰词
他的回答： A (错误)
正确答案： 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
输入描述：
输入包括多组数据，每组数据一行，为收到的密文。
密文仅有空格和大写字母组成。
输出描述：
对应每一组数据，输出解密后的明文。
示例1：
输入
HELLO WORLD
SNHJ
输出
CZGGJ RJMGY
NICE


牛客网ACM模式代码

import java.util.*;
public class Main {
     public static void main(String[] args){
         Scanner sc=new Scanner(System.in);
         while(sc.hasNextLine()){
             String s=sc.nextLine();
             StringBuilder sb=new StringBuilder();
             for(int i=0;i<s.length();i++){
                 char str=s.charAt(i);
                 if(str==' '){
                     sb.append(" ");
                 }else{
   						 sb.append((char)(str>'E'?str-5:str+21));
                 }
             }
             System.out.println(sb);
         }
     }       
}

【因子个数】
一个正整数可以分解成一个或多个数组的积。例如36=223*3，即包含2和3两个因子。NowCoder最近在研究因子个数的分布规律，现在给出一系列正整数，他希望你开发一个程序输出每个正整数的因子个数。
输入描述：
输入包括多组数据。
每组数据仅有一个整数n (2≤n≤100000)。
输出描述：
对应每个整数，输出其因子个数，每个结果占一行。
示例1：
输入
30
26
20
输出
3
2
2
【解题思路】：
从最小因子2到数字的最大因子数（数字的平方根）开始判断是否能够取余可以则循环取余直到取余不为0，因子个数+1；否则使用下一个因子计算；
最终整除了各个因子数之后剩余的数字不为1则本身也是一个因子，因此因子数+1。



牛客网ACM模式代码

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int n = sc.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);
        }
    }
}