Java日常刷题第七天

选择题

1.在类Tester中定义方法如下，
public double max(int x, int y) { // 省略 }

则在该类中定义如下哪个方法头是对上述方法的重载(Overload)?（B）

A.public int max(int a, int b) {}
B.public int max(double a, double b) {}
C.public double max(int x, int y) {}
D.private double max(int a, int b) {}
解析：重载：OverLoad
（1） 同一个类中，方法名相同，参数列表不同的2个或多个方法构成方法的重载

（2 ） 参数列表不同指参数的类型，参数的个数，参数的顺序至少一项不同

（3 ） 方法的返回值类型，方法的修饰符可以不同。
2.应用程序的main方法中有以下语句，则输出的结果(A )
String s1=new String（ ” xyz ” ）;
String s2=new String（ ” xyz ” ）;
Boolean b1=s1.equals(s2);
Boolean b2=(s1==s2);
System .out.print(b1+ ” ” +b2);
A.true false
B.false true
C.true true
D.false false
解析：equals比较的值，==比较的地址

详细：
String s1=new String（ ” xyz ” ）; //创建了String类型的内容为xyz的s1对象
String s2=new String（ ” xyz ” ）; //创建了String类型的内容为xyz的s2对象
Boolean b1=s1.equals(s2); //比较s1对象和s2对象的内容相等，返回true。
Boolean b2=(s1==s2); //比较s1和s2两个对象的存储地址是否相等，明显两者分别存储在不同的地址，所以返回：false。
故答案为：true false
3.执行以下程序后的输出结果是（D）

public class Test {
public static void main(String[] args) {
StringBuffer a = new StringBuffer(“A”);
StringBuffer b = new StringBuffer(“B”);
operator(a, b);
System.out.println(a + “,” + b);
}
public static void operator(StringBuffer x, StringBuffer y) {
x.append(y); y = x;
}
}
A。A,A
B。A,B
C。B,B
D。AB,B
解析：
Java参数，不管是原始类型还是引用类型，传递的都是副本(有另外一种说法是传值，但是说传副本更好理解吧，传值通常是相对传址而言)。 如果参数类型是原始类型，那么传过来的就是这个参数的一个副本，也就是这个原始参数的值，这个跟之前所谈的传值是一样的。如果在函数中改变了副本的 值不会改变原始的值. 如果参数类型是引用类型，那么传过来的就是这个引用参数的副本，这个副本存放的是参数的地址。如果在函数中没有改变这个副本的地址，而是改变了地址中的 值，那么在函数内的改变会影响到传入的参数。如果在函数中改变了副本的地址，如new一个，那么副本就指向了一个新的地址，此时传入的参数还是指向原来的 地址，所以不会改变参数的值。
4.Given the following code:

public class Test {
    private static int j = 0;
    private static Boolean methodB(int k) {
        j += k;
        return true;
    }
 
    public static void methodA(int i) {
        boolean b;
        b = i < 10 | methodB(4);
        b = i < 10 || methodB(8);
 
    }
 
    public static void main(String args[]) {
        methodA(0);
        System.out.println(j);
    }}

What is the result?（B）
A.The program prints”0”
B.The program prints”4”
C.The program prints”8”
D.The program prints”12”
E.The code does not complete.
解析：这道题主要考的是"|“与”||"的区别
用法：condition 1 | condition 2、condition 1 || condition 2
"|"是按位或：先判断条件1，不管条件1是否可以决定结果（这里决定结果为true)，都会执行条件2
"||"是逻辑或：先判断条件1，如果条件1可以决定结果（这里决定结果为true)，那么就不会执行条件2

//i=0, i<10为true，但是依然执行methodB(4),之后 j=4
 
b = i < 10| methodB(4);
 
//i=0, i<10位true，可以决定结果，所以不会执行methodB(8)，j依然=4
 
b = i < 10|| methodB(8);

5.下面的程序段创建了BufferedReader类的对象in，以便读取本机c盘my文件夹下的文件1.txt。File构造函数中正确的路径和文件名的表示是( C )。

File f = new File( 填代码处);
file =new FileReader(f);
in=new BufferedReader(file);

A。"./1.txt"
B。"…/my/1.txt"
C。“c:\my\1.txt”
D。“c:\ my\1.txt”
解析：./表示当前项目的路径
…/表示当前目录的父目录路径
盘符：\name\file 或者 盘符：/name/file
表示物理路径
6.

public class Test
{
    public int x;
    public static void main(String []args)
    {
        System. out. println("Value is" + x);
    }
}

对于上面这段代码，以下说法正确的是：C
A。程序会打出 “Value is 0”
B。程序会抛出 NullPointerException
C。非静态变量不能够被静态方法引用
D。编译器会抛出 "possible reference before assignment"的错误
解析：非静态变量只有实例化之后才能被静态方法引用。
D中意思为可能抛出未赋值前引用的错误。就算给x初始时有值，也没法直接在静态方法中直接调用非静态变量。
7.执行以下程序，最终输出可能是：（C）

“ * ” 代表空格

A。010 2123012 3434
B。01201 340124 2334
C。0012314 01223344**
D。12345 12345 12345
解析：
线程内顺序执行，那么如果出现空格，必定说明有一个线程完整执行了for循环。 我的解题思路稍微麻烦了，核心思想还是:线程内有序，线程间交叉。就是首先轻松排除d，将abc三个选项写在纸上，开始找01234这种顺序，如果能找出三条符合这个顺序的即正确，通过验算，前两条中不能找出三条顺序的01234,c可以。
8.下列哪个选项是Java调试器？如果编译器返回程序代码的错误，可以用它对程序进行调试。（C）
A。java.exe
B。javadoc.exe
C。jdb.exe
D。javaprof.exe
解析：javac.exe是编译.java文件
java.exe是执行编译好的.class文件
javadoc.exe是生成Java说明文档
jdb.exe是Java调试器
javaprof.exe是剖析工具
9.面向对象的三个基本元素是什么？（ABD）
A。封装
B。继承
C。重载
D。多态
解析：三个基本元素：

1. 封装： 封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
2. 继承： 继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
3. 多态： 多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

C++ 中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术， RTTI 技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。

五个基本原则：
单一职责原则（Single-Resposibility Principle）：一个类，最好只做一件事，只有一个引起它的变化。单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。
开放封闭原则（Open-Closed principle）：软件实体应该是可扩展的，而不可修改的。也就是，对扩展开放，对修改封闭的。
Liskov替换原则（Liskov-Substituion Principle）：子类必须能够替换其基类。这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。
依赖倒置原则（Dependecy-Inversion Principle）：依赖于抽象。具体而言就是高层模块不依赖于底层模块，二者都同依赖于抽象；抽象不依赖于具体，具体依赖于抽象。
接口隔离原则（Interface-Segregation Principle）：使用多个小的专门的接口，而不要使用一个大的总接口。
10.jvm中垃圾回收分为scanvenge gc和full GC，其中full GC触发的条件可能有哪些（CDE)
A。栈空间满
B。年轻代空间满
C。老年代满
D。持久代满
E。System.gc()
解析：
Full GC是对整个堆进行整理，包括新生代、旧生代和持久代，速度比Scavenge GC慢，触发的条件有： （1）.年老代被写满
（2).持久代被写满
( 3).显示调用System.GC
( 4).上一个GC后个heap的各域分配策略动态变化。

编程题

把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
代码：

public int GetUglyNumber_Solution(int index) {
        if(index <= 0)
            return 0;
        if(index == 1)
            return 1;
        int t2 = 0, t3 = 0, t5 = 0;
        int [] res = new int[index];
        res[0] = 1;
        for(int i = 1; i<index; i++){
            res[i] = Math.min(res[t2]*2, Math.min(res[t3]*3, res[t5]*5));
            if(res[i] == res[t2]*2) t2++;
            if(res[i] == res[t3]*3) t3++;
            if(res[i] == res[t5]*5) t5++;
        }
        return res[index-1];
    }