目录
1.A 派生出子类 B ， B 派生出子类 C ，并且在 java 源代码有如下声明：
3.阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有（）
4.在使用super和this关键字时，以下描述正确的是（）
9.选项中哪一行代码可以替换 //add code here 而不产生编译错误
10.在使用 interface 声明一个外部接口时，只可以使用（ ）修饰符修饰该接口。
单选
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行的声明都是正确的
class A{
}
class B extends A{
}
class C extends B{
}
A a0=new A(); A实例化一个自己当然是没问题的，也就是说，1是正确的。
A a1=new B(); 实例化一个B类对象，因为B是A的子类，所以可以实例化，父类引用可以指向子类对象。
A a2=new C(); 实例化一个C类对象，因为C是B的子类，所以可以实例化，父类引用可以指向子类对象。
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.编译错误
toLowerCase() 是一个字符串方法，用于将字符串中的所有大写字母转换为小写字母。
在toLowerCase（）方法的源码中我们可以发现，这里的返回值是new了一个新的String对象，也就是说，这里调用toLowerCase（）方法不是对本身进行修改而是new了一个新的对象，userId.toLowerCase()这里产生了一个新的对象，而“admin”在常量池中，==表示比较的是双方的地址是否相同，这里肯定是不相等的，也就是false。
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 test=null;表示这个引用不指向任何对象。
此处hello方法是一个静态方法，而静态方法的调用不依赖于任何对象。
所以，这里可以正确运行。
4.在使用super和this关键字时，以下描述正确的是（）
A. 在子类构造方法中使用 super() 显示调用父类的构造方法，super() 必须写在子类构造方法的第一行，否则编译不通过
B. super() 和 this() 不一定要放在构造方法内第一行
C. this() 和 super() 可以同时出现在一个构造函数中
D. this() 和 super() 可以在static环境中使用，包括static方法和static语句块
super和this关键字在 Java 中都有以下特点：
- super(参数)：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）
- this(参数)：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）
- super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参） this：它代表当前对象名（在程序中易产生二义性之处，应使用 this 来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用 this 来指明成员变量名）
- 调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用 super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
- super() 和 this() 类似,区别是，super() 从子类中调用父类的构造方法，this() 在同一类内调用其它方法。
- super() 和 this() 均需放在构造方法内第一行。
- 尽管可以用this调用一个构造器，但却不能调用两个。
- this 和 super 不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有 super 语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
- this() 和 super() 都指的是对象，所以，均不可以在 static 环境中使用。包括：static 变量,static 方法，static 语句块。
- 从本质上讲，this 是一个指向本对象的指针, 然而 super 是一个 Java 关键字。
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. 运行时抛出异常
子类的构造方法会帮父类的构造方法构造，这里子类中没有写，那么会默认帮父类的构造方法构造，所以这里new Alpha会打印Base ，new Base也会打印Base。
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. 编译失败
static在定义的时候不能定义局部变量。也就是说static定义的变量一定是静态成员变量。
不能在普通的方法里面定义静态变量，静态的方法里面也不可以出现静态成员变量。
7.下列哪一种叙述是正确的（）
A. abstract修饰符可修饰字段、方法和类
B. 抽象方法的body部分必须用一对大括号{ }包住
C. 声明抽象方法，大括号可有可无
D. 声明抽象方法不可写出大括号
abstract修饰符不可以修饰字段。
抽象方法不需要大括号，写大括号就表明现在是一个具体实现了。
8.下列说法正确的有：（）
A. class中的constructor不可省略
B. constructor必须与class同名，但方法不能与class同名
C. constructor在一个对象被new 时执行
D. 一个class只能定义一个constructor
class中的constructor不可省略：类中的构造方法可以省略。
constructor必须与class同名，但方法不能与class同名：方法可以和类同名。
一个class只能定义一个constructor：构造方法可以发送重载。
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(){}
首先这个类是抽象类，有一个成员变量和一个方法。
成员变量的运算一定要放到方法里面。
public int method();没有方法体。
public abstract void anotherMethod(){}：抽象方法不能有花括号，有花括号就表示这个方法有具体实现了。
10.在使用 interface 声明一个外部接口时，只可以使用（ ）修饰符修饰该接口。
A. private
B. protected
C. private protected
D. public
在使用 interface 声明一个外部接口时，只可以使用 public 修饰符修饰该接口。
这里考察的还是修饰符权限的问题。
编程
1.排序子序列
相关题目链接：排序子序列_牛客笔试题_牛客网
题目重现
思路
首先，非递减就是：a[i] <= a[i+1],递减就是a[i] > a[i+1]
非递增就是：a[i] >= a[i+1],递增就是a[i] < a[i+1]
要找有多少段，就是说，如果发现它要进入下一个段了，那么我们的计数器加加。
我们使用一个标志来区分当前状态：0表示不增不减，1表示递增，-1表示递减。
代码
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextInt()){
int n = scanner.nextInt();
int[] num = new int[n];
for (int i = 0; i < n; i++) {
num[i] = scanner.nextInt();
}
//开始处理数据
// 非递增 num[i] <= num[i+1]
// 非递减 num[i] >= num[i+1]
int f = 0;
int count = 1;
for (int i = 0; i < num.length-1; i++) {
if (num[i] < num[i+1]){
if (f == 0){
f = 1;
}
if (f == -1){
f = 0;
count++;
}
}else if (num[i] > num[i+1]){
if (f == 0){
f = -1;
}
if (f == 1){
f = 0;
count++;
}
}
}
System.out.println(count);
}
}2.倒置字符串
相关题目链接：倒置字符串__牛客网
题目重现
思路
思路如图所示，先将字符串根据空格进行分割，然后按顺序放入栈中，再从栈中按序取出字符串数组将其添加到stringBuffer中。最后输出。
代码
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()){
String s = scanner.nextLine();
//分割
String[] str = s.split(" ");
//栈先入后出 可以使用
Stack<String> stack = new Stack<>();
for (int i = 0; i < str.length; i++) {
stack.push(str[i]);
}
while (!stack.isEmpty()){
for (int i = 0; i < stack.size(); i++) {
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append(stack.pop() + " ");
System.out.println(stringBuffer);
}
}
}
}
472
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
