nowcoder刷题错题总结（3）

最新推荐文章于 2022-08-25 16:16:44 发布

原创最新推荐文章于 2022-08-25 16:16:44 发布 · 902 阅读

3 ·

CC 4.0 BY-SA版权

nowcoder刷题专栏收录该内容

8 篇文章

订阅专栏

这篇博客主要总结了NowCoder上的编程练习中的错误题目，涵盖了类的定义、抽象类与最终类的区别、接口修饰、Web应用目录结构、Applet执行顺序以及关键字super的使用等知识点，通过解析这些问题帮助读者理解并避免常见的编程错误。

01.类Test1定义如下:

public class Test1{//1
    public float aMethod(float a,float b){}//2 
    //3
}//4

将以下哪种方法插入行3是不合法的。
在这里插入图片描述
解析：

方法重载具体规范
一.方法名一定要相同。
二.方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。
三.方法的返回类型、修饰符可以相同，也可不同。

B重复了。。。。同是public float aMethod(float a,float b){}

02.执行以下程序后的输出结果是（）

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和x是同个地址，b和y是同个地址，然后执行x.append(y)就把y的值放在x的地址里面此时a地址和x是同一个所以a就是AB了，
接着执行y=x是把x的地址给y，这时候axy属于同一个地址。
 所以y=x 只是改变了y的地址没改变b的地址，所以b还是B。

在这里插入图片描述
03.关于抽象类与最终类，下列说法错误的是？

解析：

1，抽象类中可以有抽象方法，也可以没有抽象方法。
2，抽象类当然可以被继承，因为它就是用来继承的，
3，继承抽象类，若有抽象方法，则子类必须将其抽象方法实现，
4，抽象类中的非抽象方法可以被重写。

最终类和抽象类正好相反
5，加上final的类就叫最终类，加上final的方法就叫最终方法，
6，最终类中可以有最终方法也可以没有
7，最终类不能有子类，最终方法不能被重写


抽象类和最终类的区别：

1.抽象类可以被继承，并且最初创建抽象类就是为了被继承，但是最终类只能实例化；
2.抽象类和最终类都可以被声明使用。
3.抽象类可以没有抽象方法，最终类中可以没有最终方法。
4.最终类不能被继承，最终方法不能被重写，但是可以被继承。
5. 抽象类是不能实例化的，实例化必将加载类，然后根本不知道抽象方法的方法体大小，所以不能实例化。



然后是抽象类和接口的区别：

 类中只要含有一个抽象方法，该类就是抽象类；抽象类中可以包含一个或多个抽象方法，
也可以不含有抽象方法，直接在类声明时候加上Abstract ，该类就是抽象类，但是这种情况没有意义。

接口中的方法只有声明，没有实现，类似抽象方法，但是不含有abstract 修饰符；

接口中的变量默认是final 和 static 的；

接口中的方法默认是public 的；

接口定义时候，如果不声明为public 的接口，那么该接口只有包访问权限。

一个子类只能继承一个抽象类（虚类），但能实现多个接口；

一个抽象类可以有构造方法，接口没有构造方法；

一个抽象类中的方法不一定是抽象方法，即其中的方法可以有实现（有方法体），接口中的方法都是抽象方法，不能有方法体，只有声明；

一个抽象类可以是public 、 private 、 protected 、 default, 接口只有 public;

一个抽象类中的方法可以是public 、 private 、 protected 、 default ，接口中的方法只能是 public 和 default 。

04.下列语句正确的是：
在这里插入图片描述
解析：

Java语言提供了很多修饰符，大概分为两类： 

1. 访问权限修饰符 
2. 非访问权限修饰符

访问权限修饰符
public：共有访问。对所有的类都可见。
protected：保护型访问。对同一个包可见，对不同的包的子类可见。
default：默认访问权限。只对同一个包可见，注意对不同的包的子类不可见。
private：私有访问。只对同一个类可见，其余都不见。


非访问权限修饰符
static 修饰符，用来创建类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 用于多线程的同步。
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
transient：序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
 

 

类

外部类修饰符
public（访问控制符），将一个类声明为公共类，它可以被任何对象访问，一个程序的主类必须是公共类。
default（访问控制符），类只对包内可见，包外不可见。
abstract（非访问控制符），将一个类声明为抽象类，抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充，抽象类可以包含抽象方法和非抽象方法。。
final（非访问控制符），将一个类生命为最终（即非继承类），表示它不能被其他类继承。 

注意： 
1.protected 和 private 不能修饰外部类，是因为外部类放在包中，只有两种可能，包可见和包不可见。 
2. final 和 abstract不能同时修饰外部类，因为该类要么能被继承要么不能被继承，二者只能选其一。 
3.不能用static修饰类，因为类加载后才会加载静态成员变量。所以不能用static修饰类和接口，因为类还没加载，无法使用static关键字。

 

内部类修饰符
  内部类与成员变量地位一直，所以可以public,protected、default和private，同时还可以用static修饰，表示嵌套内部类，不用实例化外部类，即可调用。

方法修饰符
public（公共控制符），包外包内都可以调用该方法。
protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。
default(默认权限），指定该方法只对同包可见，对不同包（含不同包的子类）不可见。
private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类），非常严格的控制。
final ,指定方法已完备，不能再进行继承扩充。
static，指定不需要实例化就可以激活的一个方法，即在内存中只有一份，通过类名即可调用。
synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对它所属的方法加锁，以防止其他线程的访问，运行结束后解锁。
native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。
abstract ,抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成 final 和 static。 任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。 如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。 抽象方法的声明以分号结尾，例如：public abstract sample();。
 

成员变量修饰符
public（公共访问控制符），指定该变量为公共的，它可以被任何对象的方法访问。
protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。
default(默认权限），指定该变量只对同包可见，对不同包（含不同包的子类）不可见。
private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。
final，最终修饰符，指定此变量的值不能变。
static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。
transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。不持久化。
volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改，保证两个不同的线程总是看到某个成员变量的同一个值。 
final 和 static 经常一起使用来创建常量。

 

局部变量修饰符

only final is permitted。 

为什么不能赋予权限修饰符？ 
 因为局部变量的生命周期为一个方法的调用期间，所以没必要为其设置权限访问字段，既
然你都能访问到这个方法，所以就没必要再为其方法内变量赋予访问权限，因为该变量在
方法调用期间已经被加载进了虚拟机栈，换句话说就是肯定能被当前线程访问到，所以设置没意义。 

为什么不能用static修饰 
 我们都知道静态变量在方法之前先加载的，所以如果在方法内设置静态变量，可想而知，
方法都没加载，你能加载成功方法内的静态变量？

 

接口

接口修饰符
接口修饰符只能用public、default和abstract。 
不能用final、static修饰。
接口默认修饰为abstract。

接口中方法修饰符
only public & abstract are permitted 。 
意思只能用 public abstract修饰，当然如果你什么都不写，默认就是public abstract。 

注意：在Java1.8之后，接口允许定义static 静态方法了！所以也可以用static来修饰！

05.以下代码执行的结果显示是多少（）？
在这里插入图片描述

解析：

  当我们在为Integer赋值的时候，java编译器会将其翻译成调用valueOf()方法。
比如Integer i=127翻译为Integer i=Integer.valueOf(127)。

  对于-128到127之间的数，Java会对其进行缓存。而超出这个范围则新建一个对象。

所以现在回到这道问题
 i1和i2为128，超出范围，所以都需要新建对象，对象比较为false；
 i5和i6为100，在范围之内，在执行Integer i5=100时，就会直接缓存到内存中，但执行执
行Integer i6=100时，就直接从缓存里取，而不需要新建对象，所以为true。

06.以下代码的输出结果是？

public class B
{
    public static B t1 = new B();
    public static B t2 = new B();
    {
        System.out.println("构造块");
    }
    static
    {
        System.out.println("静态块");
    }
    public static void main(String[] args)
    {
        B t = new B();
    }
}

在这里插入图片描述
解析：

 静态块：用static申明，JVM加载类时执行，仅执行一次
 构造块：类中直接用{}定义，每一次创建对象时执行
 执行顺序优先级：静态块>main()>构造块>构造方法

**************
之前我一直有一个误区!就是认为静态块一定是最先初始化的!但是是错误的。

正确的理解是这样的:
 并不是静态块最先初始化,而是静态域.（多么痛的领悟!)
 而静态域中包含静态变量、静态块和静态方法,其中需要初始化的是静态变量和静态块.
而他们两个的初始化顺序是靠他们俩的位置决定的!并且静态域只在类的第一次加载时执行 。
 构造块总是在构造方法前执行（当然，第一次new时，会先执行静态域，静态域〉构造块〉构造方法） 
So！
初始化顺序是 t1 t2 静态块
****************************
	总结一下：
 1.程序入口main方法要执行首先要加载类B 
 2.静态域：分为静态变量，静态方法，静态块。这里面涉及到的是静态变量和静态块，当执行到静态域时，按照静态域的顺序加载。并且静态域只在类的第一次加载时执行 
 3.每次new对象时，会执行一次构造块和构造方法，构造块总是在构造方法前执行（当然，第一次new时，会先执行静态域，静态域〉构造块〉构造方法） 注意：加载类时并不会调用构造块和构造方法，只有静态域会执行 
 4.根据前三点，首先加载类B，执行静态域的第一个静态变量，static b1=new B，
输出构造块和构造方法（空）。ps:这里为什么不加载静态方法呢？因为执行了静态变量
的初始化，意味着已经加载了B的静态域的一部分，这时候不能再加载另一个静态域了，
否则属于重复加载 了（静态域必须当成一个整体来看待。否则加载会错乱） 于是，依次static b2 =new B，输出构造块，再执行静态块，完成对整个静态域的加载，再执行main方法，new b，输出构造块。

07.不能用来修饰interface的有（）（仅限外部接口）
在这里插入图片描述
解析：

1、抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。
原因如下：
 -抽象方法没有方法体，是用来被继承的，所以不能用private修饰；
 -static修饰的方法可以通过类名来访问该方法（即该方法的方法体），抽象方法用static修饰没有意义；static是用来修饰变量或者方法的，而不修饰类。（final同样不能修饰接口）
 -使用synchronized关键字是为该方法加一个锁。。而如果该关键字修饰的方法是static
方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。但是抽象
类不能实例化对象，因为该方法不是在该抽象类中实现的。是在其子类实现的。所以。锁
应该归其子类所有。所以。抽象方法也就不能用synchronized关键字修饰了；
 -native，这个东西本身就和abstract冲突，他们都是方法的声明，只是一个把方法实
现移交给子类，另一个是移交给本地操作系统。如果同时出现，就相当于即把实现移交给
子类，又把实现移交给本地操作系统，那到底谁来实现具体方法呢？



2、接口是一种特殊的抽象类，接口中的方法全部是抽象方法（但其前的abstract可以省
略），所以抽象类中的抽象方法不能用的访问修饰符这里也不能用。而且protected访问
修饰符也不能使用，因为接口可以让所有的类去实现（非继承），不只是其子类，但是要
用public去修饰。接口可以去继承一个已有的接口。

在这里插入图片描述

08.在Web应用程序的文件与目录结构中，web.xml是放置在( )中。

解析：

（1）/WEB-INF/web.xml 是部署描述文件

（2）/WEB-INF/classes 用来放置应用程序用到的自定义类(.class)，必须包括包(package)结构。

（3）/WEB-INF/lib 用来放置应用程序用到的JAR文件。

09.在 Applet 中，方法执行的顺序是 ?（）
在这里插入图片描述
解析：

init 初始化，
start启动运行，
paint 窗口最小化等时候需要暂停，
stop 停止，
destory 销毁;

10.关键字super的作用是？
在这里插入图片描述
解析：

1：特殊变量super，提供了对父类的访问。
2：可以使用super访问父类被子类隐藏的变量或覆盖的方法。
3：每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
4：构造是不能被继承的。