目录

一、选择题

二、编程题

2.1排序子序列

2.2倒置字符串

---

一、选择题

1.A 派生出子类 B ， B 派生出子类 C ，并且在 java 源代码有如下声明： 1. A a0=new A(); 2. A a1=new B(); 3. A a2=new C(); 问以下哪个说法是正确的（）

A 只有第一行能通过编译

B 第1、2行能通过编译，但第3行编译出错

C 第1、2、3行能通过编译，但第2、3行运行时出错

D 第1行，第2行和第3行的声明都是正确的

A类当然可以用A类引用创造A类的实例。

根据天然的向上转型，A的子类以及A的子类的子类，都可以用A类引用创造通过子类实例。

所以正确答案是 D 。

2.下面代码将输出什么内容：（）

public class SystemUtil{
    public static boolean isAdmin(String userId){
        return userId.toLowerCase()=="admin";
    }
    public static void main(String[] args){
        System.out.println(isAdmin("Admin"));
    }
}

A true

B false

C 1

D 编译错误

“==”进行的是两个变量数值的比较，对于基本数据类型来说比较的就是基本数值是否相等，对于引用数据类型来说比较的是两个引用是否指向同一个对象（即地址是否相同）。

equals方法进行的是两个类对象的属性值比较。

这道题中考察的就是对于==的理解，toLowerCase表示将该字符串全部大写，但是创建的是新的对象，两个对象地址不同。

所以正确答案是 B 。

3.阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有（）

package NowCoder;
class Test {
    public static void hello() {
        System.out.println("hello");
    }
}
public class MyApplication {
    public static void main(String[] args) {
    // TODO Auto-generated method stub
        Test test=null;
        test.hello();
    }
}

A 能编译通过，并正确运行

B 因为使用了未初始化的变量，所以不能编译通过

C 以错误的方式访问了静态方法

D 能编译通过，但因变量为null，不能正常运行

因为Test类的hello方法时静态的，所以是属于类的，当实例化该类的时候，静态会被优先加载而且只加载一次，所以不受实例化映像，只要是使用到了Test类，都会加载静态hello方法。

在这道题中hello方法时pubilc修饰符修饰的，所以在MyApplication中也能调用该方法，即使Test test=null，也会加载静态方法。

所以正确答案是 A 。

4. 在使用super和this关键字时，以下描述正确的是()
A 在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一 行，否则编译不通过
B super()和this()不一定要放在构造方法内第一行
C this()和super()可以同时出现在一个构造函数中
D this()和super()可以在static环境中使用，包括static方法和static语句块

super()是子类构造调用父类的构造方法，this()是在同一个类中无参构造调用有参构造的方法，两者都必须写在第一行，所以不能出现在一个构造方法中。并且两者都是构造方法，是对象的产生，static是静态的没有对象，所以不可以在static环境中使用。

所以正确答案是 A 。

5.如下代码的 结果是什么 ?

class Base {
    Base() {
        System.out.print("Base");
    }
}
public class Alpha extends Base {
    public static void main( String[] args ) {
    new Alpha();
    //调用父类无参的构造方法
    new Base();
    }
}

A Base

B BaseBase

C 编译失败

D 代码运行但没有输出

E 运行时抛出异常

在继承关系中，子类创建新对象时调用子类构造方法时也会调用父类的构造方法，所以父类构造方法被调用了两次，输出两个Base。

所以正确答案是 B 。

6.如下代码的输出结果是什么？

public class Test {
    public int aMethod(){
        static int i = 0;
        i++;
        return i;
    }
    public static void main(String args[]){
        Test test = new Test();
        test.aMethod();
        int j = test.aMethod();
        System.out.println(j);
    }
}

A 0

B 1

C 2

D 编译失败

在静态的主方法中是不能调用非晶态的方法的，编译会失败。

所以正确答案是 D  。

7.下列哪一种叙述是正确的()
A abstract修饰符可修饰字段、方法和类
B 抽象方法的body部分必须用一对大括号{ }包住
C 声明抽象方法，大括号可有可无
D 声明抽象方法不可写出大括号

abstract修饰符不能修饰字段，只能修饰类和方法，并且abstract修饰的类为抽象类，修饰的方法是抽象方法，抽象方法不能直接实现，所以不可以有大括号。

所以正确答案是 D  。

8.下列说法正确的有：（）

A class中的constructor不可省略

B constructor必须与class同名，但方法不能与class同名

C constructor在一个对象被new 时执行

D 一个class只能定义一个constructor

constructor是构造方法，构造方法是可以省略的。构造方法是在创建新的对象即new时执行。一个类可以有很多个不同形参的构造方法。构造方法和方法都可以和class同名，构造方法是没有返回值的。

所以正确答案是 C  。

9.选项中哪一行代码可以替换 //add code here 而不产生编译错误

public abstract class MyClass { 
    public int constInt = 5; 
    //add code here
    public void method() {
    } 
}

A public abstract void method(int a);
B consInt=constInt+5;
C public int method();
D public abstract void anotherMethod(){}

抽象类中的抽象方法不可以有大括号，在抽象类中的普通方法需要有大括号，所以A正确，C和D都是错误的。并且抽象类中只能定义变量和方法，不能那个有其他语句所以B错。

所以正确答案是A 。

10. 在使用 interface 声明一个外部接口时，只可以使用( )修饰符修饰该接口。
A private
B protected
C private protected
D public

接口必须是public修饰的，所以正确答案是 D 。

二、编程题

2.1排序子序列

牛牛定义排序子序列为一个数组中一段连续的子序列,并且这段子序列是非递增或者非递减排序的。牛牛有一个长度为n的整数数组A,他现在有一个任务是把数组A分为若干段排序子序列,牛牛想知道他最少可以把这个数组分为几段排序子序列. 如样例所示,牛牛可以把数组A划分为[1,2,3]和[2,2,1]两个排序子序列,至少需要划分为2个排序子序列,所以输出2

 在这道题中我们可以先创建一个比规定长度多一个的数组，然后将数存入数组。

大体的思路就是进入循环中，如果num[i]<num[i+1]，那么就进入小循环，当不满足这个条件时或者所有数都遍历完了，count就+1，证明有了一个子序列。如果相等就忽略直接遍历下一个数，如果相反就同样的路数，循环终止条件就是i>=n。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] num = new int[n+1];
        for(int i = 0;i<n;i++){
            num[i] = sc.nextInt();
        }
        int i = 0;
        int count = 0;
        while(i<n){
            if(num[i]<num[i+1]){
                while(i<n-1&&num[i]<num[i+1]){
                    i++;
                }
                count++;
                i++;
            }else if(num[i]==num[i+1]){
                i++;
            }else{
                while(i<n-1&&num[i]>num[i+1]){
                    i++;
                }
                count++;
                i++;
            }
        }
        System.out.println(count);
    }
}

2.2倒置字符串

将一句话的单词进行倒置，标点不倒置。比如 "I like beijing."，经过处理后变为："beijing. like I"。 字符串长度不超过100。

 这道题需要用到String类型中的拆分方法，首先根据空格将字符串拆分为字符串数组，创建StringBuilder类型的sb来连接个字符串，遍历数组从后往前相加，即将整个字符串倒置。

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        String[]  s1 = s.split(" ");
        StringBuilder sb  = new StringBuilder();
        for(int i = s1.length-1;i>=0;i--){
            String s2 = s1[i] + " ";
            sb.append(s2);
        }
        System.out.println(sb.toString());
    }