java中可以有几个主类 java必须有主类

转载

bigrobin 2023-10-18 21:42:48

文章标签 java中可以有几个主类 java 开发语言后端父类 文章分类 Java 后端开发

1、只有实现了()接口的类，其对象才能序列化。

Serializable

Cloneable

Comparable

Writeable

Serializable接口是专门提供给类实现序列化用的。要实现序列化对象必须要实现 Serializable 接口
A

2、Java Application 源程序的主类是指包含有（）方法的类。

public static void main方法

toString方法

init方法

actionPerfromed方法

java程序种类：
1.内嵌于web文件中，有浏览器观看的applet
2.可独立运行的application
3.服务器端的servlets
应用类Java程序必须有一个public static void的main方法作为程序入口。除了application类Java程序，还有Java web等
A

3、类中的数据域使用private修饰为私有变量，所以任何方法均不能访问它

正确

错误

private修饰的东西，只是不能在别的类中访问，但是本类中还是可以的。同时利用反射也可以做到。
B

4、类Person里面有个方法sleep()，如果直接用Person.sleep()，则方法sleep前面必须用的关键词是？ ( )

class

static

public

final

static关键字：针对多个对象共有的成员变量值时所提出的。
特点：1、随着类的加载而加载； 2、优先于对象存在； 3、被类的所有对象共享； 4、可以通过类名直接调用。
注意事项：1.在静态方法中是没有this关键字的； 2.静态方法只能访问静态的成员变量和静态的成员方法。
B

5、运行下面代码，输出的结果是（）

class A {
    public A() {
        System.out.println("class A");
    }
    { System.out.println("I'm A class"); } 
    static { System.out.println("class A static"); }
}
public class B extends A {
    public B() {
        System.out.println("class B");
    }
    { System.out.println("I'm B class"); }
    static { System.out.println("class B static"); }
    
    public static void main(String[] args) { 
 new B();

class A static class B static I'm A class class A I'm B class class B

Java程序初始化顺序：
父类的静态代码块
子类的静态代码块
父类的普通代码块
父类的构造方法
子类的普通代码块
子类的构造方法

6、如果一个list初始化为{5，3，1}，执行以下代码后，其结果为（）？

nums.add(6);
nums.add(0,4);
nums.remove(1);

[5, 3, 1, 6]

[4, 3, 1, 6]

[4, 3, 6]

[5, 3, 6]

list{5,3,1}
nums.add(6); //往后边加一个6，{5，3，1，6}
nums.add(0,4);//往下标为0的数加一个4，{4，5，3，1，6}
nums.remove(1); // 移除下标为1 的元素，{4，3，1，6}
B

7、有以下一个对象：

public class DataObject implements Serializable{
    private static int i=0;
    private String word=" ";
    public void setWord(String word){
        this.word=word;
    }
    public void setI(int i){
        Data0bject.i=i;
     }
}

将此对象序列化为文件，并在另外一个JVM中读取文件，进行反序列化，请问此时读出的Data0bject对象中的word和i的值分别为：

DataObject object=new Data0bject ( );
object.setWord("123");
object.setI(2);

"", 0

"", 2

"123", 2

"123", 0

序列化保存的是对象的状态，静态变量属于类的状态，因此，序列化并不保存静态变量。所以i是没有改变的
D

8、以下 b 的值是： byte b = (byte)129;

-126

-127

-128

-129

129 int类型（4个字节）二进制： 00000000 00000000 00000000 10000001
在计算机系统中，数值一律用补码来表示（存储），正数的补码和源码相同。
int -> byte(1个字节),截取： 10000001
补码转反码：1开始则为负数，负数得到反码是末位-1： 10000000
负数的反码转原码（最高位即符号位不变）：11111111
转换为十进制：-（27-1）=-127
B

9、关于访问权限说法正确的是？ ( )

外部类定义前面可以修饰public,protected和private

局部内部类前面可以修饰public,protected和private

匿名内部类前面可以修饰public,protected和private

以上说法都不正确

1、外部类前可以修饰：public、default、abstract、final

2、内部类前可以修饰：public、protected、default、private、abstract、final、static

3、局部内部类前可以修饰：abstract、final
其中：访问修饰符（public、protected、default、private），其他都是非访问修饰
在Java中，可以将一个类定义在另一个类里面或者一个方法里边，这样的类称为内部类，广泛意义上的内部类一般包括四种：成员内部类，局部内部类，匿名内部类，静态内部类。
1.成员内部类
（1）该类像是外部类的一个成员，可以无条件的访问外部类的所有成员属性和成员方法（包括private成员和静态成员）；
（2）成员内部类拥有与外部类同名的成员变量时，会发生隐藏现象，即默认情况下访问的是成员内部类中的成员。如果要访问外部类中的成员，需要以下形式访问：【外部类.this.成员变量或外部类.this.成员方法】；
（3）在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问；
（4）成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象；
（5）内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。如果成员内部类用private修饰，则只能在外部类的内部访问；如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。外部类只能被public和包访问两种权限修饰。
2.局部内部类
（1）局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内；
（2）局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。
3.匿名内部类
（1）一般使用匿名内部类的方法来编写事件监听代码；
（2）匿名内部类是不能有访问修饰符和static修饰符的；
（3）匿名内部类是唯一一种没有构造器的类；
（4）匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。
4.内部静态类
（1）静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似；
（2）不能使用外部类的非static成员变量或者方法。
D

10、下列在Java语言中关于数据类型和包装类的说法，正确的是（）

基本（简单）数据类型是包装类的简写形式，可以用包装类替代基本（简单）数据类型

long和double都占了64位（64bit）的存储空间。

默认的整数数据类型是int，默认的浮点数据类型是float。

和包装类一样，基本（简单）数据类型声明的变量中也具有静态方法，用来完成进制转化等。

A，包装和基本类型不是同一个概念
B，long和double都占16字节
C，默认的浮点数据类型是double，如果要指明使用float，则需要在后面加f
D，基本数据类型是没有静态方法的，但是基本数据类型的包装类却有
1、整数类型byte（1个字节）short（2个字节）int（4个字节）long（8个字节）
2、字符类型char（2个字节）
3、浮点类型float（4个字节）double（8个字节）
B

11、对于上面这段代码，以下说法正确的是：

public class Test
{
    public int x;
    public static void main(String []args)
    {
        System. out. println("Value is" + x);
    }
}

程序会打出 "Value is 0"

程序会抛出 NullPointerException

非静态变量不能够被静态方法引用

编译器会抛出 "possible reference before assignment"的错误

当类加载时，static静态方法随着类加载而初始化，此时实例对象还未被创建，但是非静态成员变量需要等到实例对象创建才会被初始化，故无法被引用。静态方法先行执行，导致变量x还未被初始化，所以编译出错
C

12、下列关于容器集合类的说法正确的是？

LinkedList继承自List

AbstractSet继承自Set

HashSet继承自AbstractSet

WeakMap继承自HashMap

a选项linkedlist类是实现了List接口，而不是继承
b选项AbstractSet类实现Set接口
c选项HashSet继承 AbstractSet类，同时也实现set
d选项 WeakMap是js中的，java的是WeakHashMap
C

13、说明输出结果。

import java.util.Date;  
public class SuperTest extends Date{  
    private static final long serialVersionUID = 1L;  
    private void test(){  
       System.out.println(super.getClass().getName());  
    }  
     
    public static void main(String[]args){  
       new SuperTest().test();  
    }  
}

SuperTest

SuperTest.class

test.SuperTest

test.SuperTest.class

1、super.getClass()调用的是父类即Date类的方法；
2、父类的getClass方法继承自Object类，且该方法是final的，不能被修改；
3、Object中的getClass()返回的是当前运行的类，即SuperTest;
4、Class中的getName()方法针对引用类型的返回的是包名+类名，即test.SuperTest;
5、如果想要返回父类，即Date的名称，可以使用super.getClass().getSuperClass().getName();
6、此处super还是this，亦或直接getClass().getName()，结果都是一样的；
C

14、servlet周期包含哪些：

初始化

销毁

请求处理

开始

init() --> 初始化
service() --> 处理请求
destory () --> 销毁（停止）
ABC

15、在java中重写方法应遵循规则的包括（）

访问修饰符的限制一定要大于被重写方法的访问修饰符

可以有不同的访问修饰符

参数列表必须完全与被重写的方法相同

必须具有不同的参数列表

两同两小一大原则：
两同：方法名和参数列表相同
两小：返回值或声明异常比父类小（或相同）
一大：访问修饰符比父类的大（或相同）
方法重载
被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。
方法重写
参数列表必须完全与被重写方法的相同；
返回类型必须完全与被重写方法的返回类型相同；
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
父类的成员方法只能被它的子类重写。
声明为final的方法不能被重写。
声明为static的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。
BC

16、下面关于volatile的功能说法正确的是哪个

原子性

有序性

可见性

持久性

synchronized保证三大性，原子性，有序性，可见性，volatile保证有序性，可见性，不能保证原子性
BC

17、以下语句返回值为 true 的是（）

java中可以有几个主类 java必须有主类_开发语言_02

a1==a2

d1==d2

b1==b2

c1==c2

Integer a1=17实际上执行了Integer.valueOf(17)；

public static Integer valueOf(int i) { 
assert IntegerCache.high >= 127; 
if (i >= IntegerCache.low && i <= IntegerCache.high) 
return IntegerCache.***[i + (-IntegerCache.low)]; 
return new Integer(i);
}

选项A，a1、a2赋值给Integer类型，自动装箱。对于–128到127（默认是127）之间的值，Integer.valueOf(int i) 返回的是缓存的Integer对象（并不是新建对象），变量所指向的是同一个对象，所以a1==a2返回true。
选项B，Integer和int比较会进行自动拆箱，比较的是数值大小，所以d1==d2返回true。
选项C，由于超出自动装箱的范围，return返回的是新建的对象，所以对象内存地址不同，b1==b2返回false。
选项D，普通new创建对象，两个new创建两个地址不同的对像，所以c1==c2返回false。
AB

18、下列流当中，属于处理流的是：（）

FilelnputStream

lnputStream

DatalnputStream

BufferedlnputStream

按照流是否直接与特定的地方（如磁盘、内存、设备等）相连，分为节点流和处理流两类。
节点流：可以从或向一个特定的地方（节点）读写数据。如FileReader.
处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。
JAVA常用的节点流：
文件 FileInputStream FileOutputStrean FileReader FileWriter 文件进行处理的节点流。
字符串 StringReader StringWriter 对字符串进行处理的节点流。
数组 ByteArrayInputStream ByteArrayOutputStreamCharArrayReader CharArrayWriter 对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）。
管道 PipedInputStream PipedOutputStream PipedReaderPipedWriter对管道进行处理的节点流。
常用处理流（关闭处理流使用关闭里面的节点流）
缓冲流：BufferedInputStrean BufferedOutputStream BufferedReader BufferedWriter 增加缓冲功能，避免频繁读写硬盘。
转换流：InputStreamReader OutputStreamReader 实现字节流和字符流之间的转换。
数据流 DataInputStream DataOutputStream 等-提供将基础数据类型写入到文件中，或者读取出来.
流的关闭顺序
一般情况下是：先打开的后关闭，后打开的先关闭
另一种情况：看依赖关系，如果流a依赖流b，应该先关闭流a，再关闭流b。例如，处理流a依赖节点流b，应该先关闭处理流a，再关闭节点流b
可以只关闭处理流，不用关闭节点流。处理流关闭的时候，会调用其处理的节点流的关闭方法。
CD