「这是我参与11月更文挑战的第3天，活动详情查看：2021最后一次更文挑战」

⭐欢迎来到算法入门到王者之路专栏，一起学习，一起进步⭐

前言

大家好，我是全世界最强男人-白胡子。从今天开始我打算立一个flag。就是连续刷题48天。每天最少两道编程题。外加选择题不等。还望大家监督！！！。如果到时候一起刷题的人多的话，我会建一个算法交流群。主要还是看大家的想法啦。

@TOC

一、选择题

1： 下面代码将输出什么内容：（）
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 编译错误

解析：上面代码的意思是输出isAdmin方法的结果。而这个方法传过去的参数是一个Admin，注意这个A是大写的。方法体执行的代码是将传过来的Userid调用toLowerCase（）方法。将userid转换成小写。最后返回小写和字符串admin用==比较的结果。

这里给大家复习一些Java中对象的比较。
String使用==是用来比较两个引用是否是指向同一个对象的。真要判断引用的值是不是相等还得是用equals方法。

大家来看下面这一段代码：

  public static void main (String[] args) {
        String userId=new String ("Admin");
      
        String str1=new String ("abc");
        String str2=new String ("abc");
        System.out.println (str1==str2);
        System.out.println (userId.toLowerCase ()=="admin");
    }
复制代码

你猜猜最后输出结果是什么?
两个都是False。因为str1，和str2虽然字符串的内容相同，但是==比较的是他们的引用。在这里初始化的方式是new了一个string。所以相当于是新创建了一个对象。
在JVM栈的效果如下。所以他们的引用是不相同的，打印false。而第二个也是一个道理因为userid同样是new了一个String对象。

再来看看这段代码：

 String str1="abc";
        String str2="abc";
        System.out.println (str1==str2);
复制代码

再猜猜结果是什么？
这次就是ture了。str1和str2没有用过new的方式来初始化，这就相当于是一个引用指向了字符串常量池中的abc对象。效果就像下面这种，只不过把hello换成abc了。

本题答案：B

2：
阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有（）
p
ackage 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是不是null都是可以调用的。

本题答案：A

3:
如下代码的 结果是什么 ?
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 Base（）还是new Alpha（）最后都会打印一个Base。 Alpha类继承了Base类。所以在调用父类无参的构造方法时打印一次。调用子类时也会打印一次所以一共是两次base。

本题答案：B

4：
如下代码的输出结果是什么？
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

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

解析：
实践出真知，我们一个一个试试。
A： 修饰类，没问题
:
修饰方法：没问题

修饰字段：不行。

其实想知道为什么也很简单，抽象关键字abstract关键字的引出是因为父类方法的不确定性 。是为了防止程序员在写代码的时候将一个不想具体出来的方法或者类写具体的关键字。抽象类还有下面的特性：
抽象类不能被实例化。
有抽象方法的类，一定是抽象类，但是抽象类可以没有抽象方法。
当一个类继承的父类是抽象类的话，需要我们把抽象类中的所有抽象方法全部实现。
抽象方法不能有方法体。

B：抽象方法的初衷就是不想让程序员实现它。所以当你想去到大括号里实现的时候就会报错。

C：同理B，不是可有可无，而是没得商量。不能用大括号

D：正确。不需要实现就不能写出大括号。

本题答案：D

6：
下列说法正确的有：（）
A class中的constructor不可省略
B constructor必须与class同名，但方法不能与class同名
C constructor在一个对象被new 时执行
D 一个class只能定义一个constructor

解析：
A：构造器可有省略，当你什么都不写的时候，系统会默认给你创建一个构造器

B：构造器必须与class同名是对的。不然会报错。

方法可以和class同名，这里没有报错。

C:constructor在一个对象被new 时执行这句话是正确的，在new对象时构造器就会开始启动。

D：一个类可以定义多个构造器，这里我就定义了两个构造器，一个是对于a的，一个是对于b的。

7：
选项中哪一行代码可以替换 //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:在抽象类中实现抽象方法，并且没有大括号。正确，不会编程错误。
B：抽象类里不能修改变量值
C：不能同名
D:抽象方法不能含有大括号的方法体

二、编程题

标题：倒置字符串 | 时间限制：1秒 | 内存限制：32768K | 语言限制： 不限
【倒置字符串】将一句话的单词进行倒置，标点不倒置。比如 I like beijing. 经过函数后变为：beijing. like I

这道题我之前写过类似的题目，这里附上博客链接：倒置字符串

这里在附上代码：

import java.util.Scanner;

public class reverseStr {
}
/**
 * 倒置字符串
 * 将一句话的单词进行倒置，标点不倒置。比如 I like beijing. 经过函数后变为：beijing. like I
 */
class Main{
    /**
     * 思路先整体逆置，再按照每个单词逆置。
     * @param ch
     */
    public  static  void rerverse(char ch[],int start,int end){
          while (start<end){
              char  tmp=ch[start];
              ch[start]=ch[end];
              ch[end]=tmp;
              start++;
              end--;
          }
    }
    public static void main (String[] args) {
        Scanner scanner=new Scanner (System.in);
        String str=scanner.nextLine ();
        char ch[]=str.toCharArray ();
        rerverse (ch, 0, str.length ()-1);
        int i=0;
        int len= ch.length;
        while (i<len){
            int j=i;
            while (j<len && ch[j]!=' '){
                j++;
            }
            //遇到空格了，逆置
            //需要在多判断一下J<LEN
            //有的情况是只输入了一整个单词 avcd这种。
            //这种情况不特判的话就会数组越界
            if(j<len){
                rerverse (ch, i, j-1);
                //倒置完一个单词之后更新i，下次进入循环j又等于i了。如此反复
                i=j+1;
            }
            else {
                //只有一整个单词的情况
                rerverse (ch, i, j-1);
                i=j;
            }
        }
        String ret=new String (ch);
        System.out.println (ret);
    }
}
复制代码

三、结尾

希望大家看到了能给个反馈，今天是第二天啦，一起加油!.