目录
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行的声明都是正确的
🙈大家觉得答案是什么呢
🙉答案是 D 啦~
🔎思路解析:根据题目可以写出代码
class A {
}
class B extends A { //A 派生出子类 B
}
class C extends B { //B 派生出子类 C
}
public class Test {
public static void main(String[] args) {
A a0=new A();
A a1=new B();//父类引用,引用子类对象
A a2=new C();//此时A虽然不是C的直接父类,但是C依然间接继承了A的内容的,此时可以发生向上转型的。
}
}
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 编译错误
🙈大家觉得答案是什么呢
🙉答案是 B 啦~
🔎思路解析:上述代码为 调用 admin 函数,传入“Admin” ,此时 userId 拿到的就是 Admin
toLowerCase:将大写变成小写
❗❗注意:toLowerCase 在进行大写变小写的时候会产生一个新的对象,此时再与“admin”比较是拿到这个新的对象与之比较,所以最终结果为 false
例如:
String s1 = "abcd";
String s2 = s1.toLowerCase();
System.out.println(s1 == s2);//true
System.out.println(s1.toLowerCase() == "abcd");//true
✅此时就是因为 s1 在进行大小写转换的时候,它本身就是一个小写,这时候小写转换为小写的时候,就不会 new 一个新的对象,这时候的结果就是TRUE
🔥总结:在使用 toLowerCase 进行比较的时候:
如果是发生了从大写变成小写的时候:toLowerCase 会 new 一个新的对象,这时候比较就是 false
如果原本就是小写,使用 toLowerCase 再变成小写:这时候t oLowerCase 就不会 new 一个新的对象,这时候比较就是 true
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,不能正常运行
🙈大家觉得答案是什么呢
🙉答案是 A 啦~
🔎思路解析:
Test test=null;//引用null,不指向任何对象
理论上这个代码应该会发生一个空指针异常, 但是此时的 hello 是一个静态方法 (静态方法的调用不依赖任何对象),因此这个代码可以正常运行
4.在使用super和this关键字时,以下描述正确的是( )
A 在子类构造方法中使用super()显示调用父类的构造方法,super()必须写在子类构造方法的第一行,否则编译不通过
B super()和this()不一定要放在构造方法内第一行
C this()和super()可以同时出现在一个构造函数中
D this()和super()可以在static环境中使用,包括static方法和static语句块
🙈大家觉得答案是什么呢
🙉答案是 A 啦~
🔎思路解析:super()和this()一定要放在构造方法内第一行
对于super()和this()的理解,可以看我的博客: 继承的博客链接
✅【相同点】
1. 都是 Java 中的关键字
2. 只能在类的非静态方法中使用,用来访问非静态成员方法和字段
3. 在构造方法中调用时,必须是构造方法中的第一条语句,并且不能同时存在
❎【不同点】1. this 是当前对象的引用,当前对象即调用实例方法的对象, super 相当于是子类对象中从父类继承下来部分成员的引用
2. 在非静态成员方法中, this 用来访问本类的方法和属性, super 用来访问父类继承下来的方法和属性
3. 在构造方法中: this(...) 用于调用本类构造方法, super(...) 用于调用父类构造方法,两种调用不能同时在构造方法中出现
4. 构造方法中一定会存在 super(...) 的调用,用户没有写编译器也会增加,但是 this(...) 用户不写则没有
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 运行时抛出异常
🙈大家觉得答案是什么呢
🙉答案是 B 啦~
🔎思路解析:本题主要考察继承关系上的执行顺序。
当子类继承父类之后,在实例化子类对象的时候,先要调用父类的构造方法,来帮助父类初始化。上述代码相当于如下代码:
class Base {
Base() {
System.out.print("Base");
}
}
public class Alpha extends Base {
Alpha() {
super();
}
public static void main( String[] args ) {
new Alpha();//1
//调用父类无参的构造方法
new Base();//2
}
}
编译器会默认提供如上的子类的构造方法。所以,注释1处输出的结果为Base,注释2处输出的结果为:Base 最终结果是BaseBase。故:选择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 啦~
🔎思路解析:
static 在定义的时候,不能定义局部变量,static 定义的静态变量一定是成员变量
在普通方法的内部,一定不可以出现 static
在静态方法的内部,也不可以出现 static (一个变量被静态变量修饰,这个变量叫做类变量,属于类,是不能放在方法内部)
7.下列哪一种叙述是正确的( )
A abstract修饰符可修饰字段、方法和类
B 抽象方法的body部分必须用一对大括号{ }包住
C 声明抽象方法,大括号可有可无
D 声明抽象方法不可写出大括号
🙈大家觉得答案是什么呢
🙉答案是 D 啦~
🔎思路解析:
A、abstract 不可以修饰符可修饰字段
B、抽象方法的body部分不可以用一对大括号{ }包住,{ }包住就变成了一个具体的实现
public abstract void func();//抽象方法
C、声明抽象方法,大括号必须没有
8.下列说法正确的有:( )
A class中的constructor不可省略
B constructor必须与class同名,但方法不能与class同名
C constructor在一个对象被new 时执行
D 一个class只能定义一个constructor
🙈大家觉得答案是什么呢
🙉答案是 C 啦~
🔎思路解析:
A、class 中的 constructor 可以省略,这时候编译器会默认提供一个不带参数的构造方法
B、方法可以与class同名
D、一个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(){}
🙈大家觉得答案是什么呢
🙉答案是 A 啦~
🔎分析代码:这是一个抽象类,定义了一个成员变量=5,并且写了一个方法
A、A的方法与原来的方法构成重载
B、成员变量的运算一定要放在方法里边
C、普通方法应该有大括号,对于C的代码如果加上 abstract,这个代码也是错误的,与原方法同名
D、抽象方法不可以有大括号
10.在使用 interface 声明一个外部接口时,只可以使用( )修饰符修饰该接口。
A private B protected C private protected D public
🙈大家觉得答案是什么呢
🙉答案是 D 啦~
🔎思路解析:接口一定要被实现,默认为 public 修饰
🔥编程题
1.倒置字符串
牛客网链接:倒置字符串
题目:将一句话的单词进行倒置,标点不倒置。比如 I like beijing. 经过函数后变为:beijing. like I
输入描述:每个测试输入包含1个测试用例: I like beijing. 输入用例长度不超过100
输出描述:依次输出倒置之后的字符串,以空格分割
示例1
输入:I like beijing.
输出:beijing. like I
思路:1.整体逆置 2.每一部分逆置
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
//逆置
public static void reverse(char[] arr, int start, int end) {
while (start < end) {
char tmp = arr[start];
arr[start] = arr[end];
arr[end] = tmp;
start++;
end--;
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String str = scanner.nextLine();
//转换字符串为数组
char[] arr = str.toCharArray();
//整体倒置 I like beijing. --> .gnijieb ekil I
reverse(arr, 0, arr.length - 1);
int start = 0;//开始的位置
while (start < arr.length) {
int end = start;
//j < arr.length——防止越界
while (end < arr.length && arr[end] != ' ') {
end++;
}
//不是最后一个单词
if (end < arr.length) {
reverse(arr, start, end-1);
start = end + 1;//此时下一个开始的位置为空格+1(end+1)
} else {//是最后一个单词
reverse(arr, start, end-1);
start = end;//此时开始=结尾,结束
}
}
//转化为字符串
String ret = new String(arr);
System.out.println(ret);
}
}
2.排序子序列
牛客网链接:排序子序列
牛牛定义排序子序列为一个数组中一段连续的子序列,并且这段子序列是非递增或者非递减排序的。牛牛有一个长度为n的整数数组A,他现在有一个任务是把数组A分为若干段排序子序列,牛牛想知道他最少可以把这个数组分为几段排序子序列.
如样例所示,牛牛可以把数组A划分为[1,2,3]和[2,2,1]两个排序子序列,至少需要划分为2个排序子序列,所以输出2
输入描述:输入的第一行为一个正整数n(1 ≤ n ≤ 10^5) 第二行包括n个整数A_i(1 ≤ A_i ≤ 10^9),表示数组A的每个数字。
输出描述:输出一个整数表示牛牛可以将A最少划分为多少段排序子序列
示例1
输入
6
1 2 3 2 2 1
输出
2
🔎解题思路:
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int[] arr = new int[n +
1]; //多给数组一个长度,避免遍历不到最后一个元素
for (int i = 0; i < n; i++) {
arr[i] = scanner.nextInt();
}
int i = 0;
int count = 0;
while (i < n) {
//三种情况
//1.非递减序列
if (arr[i] < arr[i + 1]) {
while (i < n && arr[i] < arr[i + 1]) {
i++;
}
//此时为一个序列
count++;
i++;
} else if (arr[i] == arr[i + 1]) {
{
//2.相等既可以是非递增也可以是非递减,所以可以不处理,直接加一
i++;
}
} else {
while (i < n && arr[i] >= arr[i + 1]) {
i++;
}
//此时为一个序列
count++;
i++;
}
}
System.out.println(count);
}
}