牛客Java专项练习

最新推荐文章于 2022-04-01 01:06:13 发布

•••

最新推荐文章于 2022-04-01 01:06:13 发布

阅读量619

点赞数

分类专栏： Java基础面试题文章标签： java

本文链接：https://blog.csdn.net/weixin_44072872/article/details/109026018

版权

Java基础面试题专栏收录该内容

2 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的JVM内存区域，包括栈、堆、方法区等，并讨论了垃圾回收、线程、String、异常处理及MySQL等相关知识点，深入剖析了各种内存区域的作用、生命周期及垃圾回收机制。同时，涵盖了Java并发编程的基础概念，如volatile关键字、线程启动及String对象的特性。此外，还涉及了Java集合、类与接口、异常处理、数据库访问权限等内容。

摘要由CSDN通过智能技术生成

本文记录牛客网Java专项练习刷题过程中遇到的个人认为有意思的题目…

JVM

以下哪个不属于JVM堆内存中的区域（）？

survivor区
常量池
eden区
old区
参考文章：
Java内存区域和GC机制

程序计数器 PC Register
　　每个线程都有一个程序计算器，就是一个指针，指向方法区中的方法字节码（下一个将要执行的指令代码），由执行引擎读取下一条指令，是一个非常小的内存空间，几乎可以忽略不记。
　　程序计数器（Program Counter Register）是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的行号指示器。在虚拟机的概念模型里（仅是概念模型，各种虚拟机可能会通过一些更高效的方式去实现），字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。由于Java 虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的，在任何一个确定的时刻，一个处理器（对于多核处理器来说是一个内核）只会执行一条线程中的指令。因此，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各条线程之间的计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存。如果线程正在执行的是一个Java 方法，这个计数器记录的是正在执行的虚拟机字节码指令的地址；如果正在执行的是Natvie 方法，这个计数器值则为空（Undefined）。此内存区域是唯一一个在Java 虚拟机规范中没有规定任何OutOfMemoryError 情况的区域。
本地方法栈 Native Method Stack
　　Native Method Stack中登记native方法，在Execution Engine执行时加载native libraies
　　本地方法栈与虚拟机栈基本类似，区别在于虚拟机栈为虚拟机执行的java方法服务，而本地方法栈则是为Native方法服务
方法区 Method Area

用于存储虚拟机加载的：静态变量+常量+类信息+运行时常量池（类信息：类的版本、字段、方法、接口、构造函数等描述信息）
默认最小值为16MB，最大值为64MB，可以通过-XX:PermSize 和 -XX:MaxPermSize 参数限制方法区的大小
对于习惯在HotSpot 虚拟机上开发和部署程序的开发者来说，很多人愿意把方法区称为“永久代”（Permanent Generation），本质上两者并不等价，仅仅是因为HotSpot 虚拟机的设计团队选择把GC 分代收集扩展至方法区，或者说使用永久代来实现方法区而已。对于其他虚拟机（如BEA JRockit、IBM J9 等）来说是不存在永久代的概念的。即使是HotSpot 虚拟机本身，根据官方发布的路线图信息，现在也有放弃永久代并“搬家”至Native Memory 来实现方法区的规划了。Java 虚拟机规范对这个区域的限制非常宽松，除了和Java 堆一样不需要连续的内存和可以选择固定大小或者可扩展外，还可以选择不实现垃圾收集。相对而言，垃圾收集行为在这个区域是比较少出现的，但并非数据进入了方法区就如永久代的名字一样“永久”存在了。这个区域的内存回收目标主要是针对常量池的回收和对类型的卸载，一般来说这个区域的回收“成绩”比较难以令人满意，尤其是类型的卸载，条件相当苛刻，但是这部分区域的回收确实是有必要的。在Sun 公司的BUG 列表中，曾出现过的若干个严重的BUG 就是由于低版本的HotSpot 虚拟机对此区域未完全回收而导致内存泄漏。根据Java 虚拟机规范的规定，当方法区无法满足内存分配需求时，将抛出OutOfMemoryError 异常。

栈 JVM Stack
　　编译器可知的各种基本数据类型(boolean、byte、char、short、int、float、long、double)、对象引用(引用指针，并非对象本身)
　　栈是java 方法执行的内存模型：
　　每个方法被执行的时候都会创建一个“栈帧”用于存储局部变量表(包括参数)、操作栈、方法出口等信息。
　　每个方法被调用到执行完的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。
　　栈的生命期是跟随线程的生命期，线程创建时创建，线程结束栈内存也就释放，是线程私有的。
堆 Java Heap
　　所有的对象实例以及数组都要在堆上分配，此内存区域的唯一目的就是存放对象实例
　　堆是Java 虚拟机所管理的内存中最大的一块。Java 堆是被所有线程共享的一块内存区域，在虚拟机启动时创建
　　堆是理解Java GC机制最重要的区域，没有之一
　　结构：新生代（Eden区+2个Survivor区）老年代永久代（HotSpot有）
　　新生代：新创建的对象——>Eden区
　　GC之后，存活的对象由Eden区 Survivor区0进入Survivor区1
　　再次GC，存活的对象由Eden区 Survivor区1进入Survivor区0
　　老年代：对象如果在新生代存活了足够长的时间而没有被清理掉（即在几次Young GC后存活了下来），则会被复制到老年代
　　如果新创建对象比较大（比如长字符串或大数组），新生代空间不足，则大对象会直接分配到老年代上（大对象可能触发提前GC，应少用，更应避免使用短命的大对象）
　　老年代的空间一般比新生代大，能存放更多的对象，在老年代上发生的GC次数也比年轻代少
　　永久代：可以简单理解为方法区（本质上两者并不等价）

在Java中，对于不再使用的内存资源，如调用完成的方法，“垃圾回收器”会自动将其释放。（错误）

JVM 内存可简单分为三个区：
1、堆区（heap）：用于存放所有对象，是线程共享的（注：数组也属于对象）
2、栈区（stack）：用于存放基本数据类型的数据和对象的引用，是线程私有的（分为：虚拟机栈和本地方法栈）
3、方法区（method）：用于存放类信息、常量、静态变量、编译后的字节码等，是线程共享的（也被称为非堆，即 None-Heap）
Java 的垃圾回收器（GC）主要针对堆区

java 虚拟机，对于方法的调用采用的是栈帧（方法调用和方法执行），调用则入栈，完成之后则出栈。方法调用时，会创建栈帧在栈中，调用完是程序自动出栈释放，而不是gc释放。

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

原子性
有序性
可见性
持久性

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

线程

以下程序的运行结果是？

A.foobar
B.barfoo
C.foobar或者barfoo都有可能

答案是 A foobar 这道题是考线程的调用情况，线程的启动方式只能通过start这种方式启动才能真正的实现多线程的效果，如果是手动调用run方法和普通方法调用没有区别，所以这个还是按照顺序执行首先执行run方法之后，执行输出语句所以最终得到结果foobar.

public class ThreadTest {
    public static void main(String[] args) {
        Runner1 runner1 = new Runner1();
        Runner2 runner2 = new Runner2();
        // Thread(Runnable target) 分配新的 Thread 对象。
        Thread thread1 = new Thread(runner1);
        Thread thread2 = new Thread(runner2);
        thread1.start(); //执行start，thread1与thread2交叉执行
        thread2.start();
        //thread1.run(); //执行run，thread1与thread2顺序执行
        //thread2.run();
    }
}

class Runner1 implements Runnable { // 实现了Runnable接口，jdk就知道这个类是一个线程
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("进入Runner1运行状态——————————" + i);
        }
    }
}

class Runner2 implements Runnable { // 实现了Runnable接口，jdk就知道这个类是一个线程
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("进入Runner2运行状态==========" + i);
        }
    }
}

下列关于Java并发的说法中正确的是（）

A. CopyOnWriteArrayList适用于写多读少的并发场景
B. ReadWriteLock适用于读多写少的并发场景
C. ConcurrentHashMap的写操作不需要加锁，读操作需要加锁
D. 只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了

Java的Daemon线程，setDaemon( )设置必须要？

在start之前
在start之后
前后都可以

java中线程分为两种类型：
1：用户线程。通过Thread.setDaemon(false)设置为用户线程；
2：守护线程。通过Thread.setDaemon(true)设置为守护线程，如果不设置，默认用户线程；
守护线程是服务用户线程的线程，在它启动之前必须先set。

String

以下代码的输出的正确结果是

public class Test {
	public static void main(String args[]) {
		String s = "祝你考出好成绩！";
		System.out.println(s.length());
	}
}

length得到的是字符，不是字节。（8）
如果是s.getBytes(“GBK”).length就是求的字节数。如果是GBK，一个中文字符占2字节（16），如果是UTF-8则是3个字节（24）。

下面论述正确的是（）？

A. 如果两个对象的hashcode相同，那么它们作为同一个HashMap的key时，必然返回同样的值。
B. 如果a,b的hashcode相同，那么a.equals(b)必须返回true。
C. 对于一个类，其所有对象的hashcode必须不同。
D. 如果a.equals(b)返回true，那么a,b两个对象的hashcode必须相同。

hashCode()方法和equals()方法的作用其实是一样的，在Java里都是用来对比两个对象是否相等一致。
那么equals()既然已经能实现对比的功能了，为什么还要hashCode()呢？因为重写的equals()里一般比较的比较全面比较复杂，这样效率就比较低，而利用hashCode()进行对比，则只要生成一个hash值进行比较就可以了，效率很高。
那么hashCode()既然效率这么高为什么还要equals()呢？因为hashCode()并不是完全可靠，有时候不同的对象他们生成的hashcode也会一样（生成hash值得公式可能存在的问题），所以hashCode()只能说是大部分时候可靠，并不是绝对可靠，
所以我们可以得出：
1.equals()相等的两个对象他们的hashCode()肯定相等，也就是用equals()对比是绝对可靠的。
2.hashCode()相等的两个对象他们的equal()不一定相等，也就是hashCode()不是绝对可靠的。
所有对于需要大量并且快速的对比的话如果都用equals()去做显然效率太低，所以解决方式是，每当需要对比的时候，首先用hashCode()去对比，如果hashCode()不一样，则表示这两个对象肯定不相等（也就是不必再用equal()去再对比了）,如果hashCode()相同，此时再对比他们的equals()，如果equals()也相同，则表示这两个对象是真的相同了，这样既能大大提高了效率也保证了对比的绝对正确性！
所以选D

URL u =new URL(“http://www.123.com”);。如果www.123.com不存在，则返回______。

A. http://www.123.com
B. ””
C. null
D. 抛出异常

1）我们在执行URL u =new URL(“http://www.123.com”);这句话的时候确实要抛出异常，但是这个异常属于IOException，不管网址是否存在，最后都会返回该网址的一个连接，打印出来就是该网址。
2）new URL()时必须捕获检查异常，但这个异常是由于字符串格式和URL不符导致的，与网址是否存在无关。

String，StringBuffer，StringBuilder的区别。
下面哪些情况下需要使用抽象类？

A. 当一个类的一个或多个方法是抽象方法时
B. 当类是一个抽象类的子类，并且不能为任何抽象方法提供任何实现细节或方法体时
C. 当一个类实现多个接口时
D. 当一个类实现一个接口，并且不能为任何抽象方法提供实现细节或方法体时

对Collection和Collections描述正确的是

A. Collection是java.util下的类，它包含有各种有关集合操作的静态方法
B. Collection是java.util下的接口，它是各种集合结构的父接口
C. Collections是java.util下的接口，它是各种集合结构的父接口
D. Collections是java.util下的类，它包含有各种有关集合操作的静态方法

public interface Collection<E> extends Iterable<E> {
	//省略源码内容
}

public class Collections {
	//将自己的构造函数私有化，保证不会创建 Collections 的实例
    // Suppresses default constructor, ensuring non-instantiability.
    private Collections() {
    }
    //省略源码内容
}

以下类型为Final类型的为

A. HashMap
B. StringBuffer
C. String
D. Hashtable

StringBuilder , StringBuffer ,String 都是 final 的，但是为什么StringBuilder , StringBuffer可以进行修改呢，因为不可变包括的是，引用不可变以及对象不可变，而这三个都是属于引用不可变，（也就是地址不要变，里面的内容随心所欲），而StringBuilder , StringBuffer 中都包含右append方法，可对对象中的内容进行增加。
而String a=“123”+new String(“456”);实际上底层是用了一个StringBuffer 进行append；

关于Java中的ClassLoader下面的哪些描述是错误的：( )

A. 默认情况下，Java应用启动过程涉及三个ClassLoader: Boostrap, Extension, System
B. 一般的情况不同ClassLoader装载的类是不相同的，但接口类例外，对于同一接口所有类装载器装载所获得的类是相同的
C. 类装载器需要保证类装载过程的线程安全
D. ClassLoader的loadClass在装载一个类时，如果该类不存在它将返回null
E. ClassLoader的父子结构中，默认装载采用了父优先
F. 所有ClassLoader装载的类都来自CLASSPATH环境指定的路径

A、java中类的加载有5个过程，加载、验证、准备、解析、初始化；这便是类加载的5个过程，而类加载器的任务是根据一个类的全限定名来读取此类的二进制字节流到JVM中，然后转换为一个与目标类对应的java.lang.Class对象实例，在虚拟机提供了3种类加载器，引导（Bootstrap）类加载器、扩展（Extension）类加载器、系统（System）类加载器（也称应用类加载器）。A正确
B、一个类，由不同的类加载器实例加载的话，会在方法区产生两个不同的类，彼此不可见，并且在堆中生成不同Class实例。所以B前面部分是正确的，后面接口的部分真的没有尝试过，等一个大佬的讲解吧；
C、类加载器是肯定要保证线程安全的；C正确
D、装载一个不存在的类的时候，因为采用的双亲加载模式，所以强制加载会直接报错，D错误
java.lang.SecurityException: Prohibited package name: java.lang
E、双亲委派模式是在Java 1.2后引入的，其工作原理的是，如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式，即每个儿子都很懒，每次有活就丢给父亲去干，直到父亲说这件事我也干不了时，儿子自己想办法去完成，所以默认是父装载，E正确
F、自定义类加载器实现继承ClassLoader后重写了findClass方法加载指定路径上的class，F错误

下列说法错误的有（）

A. 能被java.exe成功运行的java class文件必须有main()方法
B. J2SDK就是Java API
C. Appletviewer.exe可利用jar选项运行.jar文件
D. 能被Appletviewer成功运行的java class文件必须有main()方法

B：来自百度百科：在JDK5之后，J2SDK 改名为 Java SE DK(简称依然是JDK) ，它是java开发编程的工具，提供了编译功能和运行环境等，包含jdk和jre。但它不是java编程开发的平台。Java API 是Java应用程序编程接口，它和JDK不是一回事。
C: appletviewer.exe执行选项参数中并没有jar选项。如下如所示：

D： appletviewer(小程序浏览器)：一种执行HTML文件上的Java小程序类的Java浏览器，就是用来解释执行java applet应用程序的,简单理解就是没有main函数的继承applet类的 java 类。类似于WEB上开发的java类，不需要写main函数。

关于如下程序的描述哪个是正确的？（）

public class Person{
	static int arr[] = new int[5];
	public static void main(String a[]){
		System.out.println(arr[0]);
	}
}

编译将产生错误
编译时正确，但运行时将产生错误
正确，输出0
正确，输出 null

类的成员变量会被默认初始化

Java 源程序文件的扩展名为（）

.java
.class
.exe
.jar

.class 编译后的Java文件
.java是未编译的程序
.jsp是页面程序
.xml配置程序
.jar是.class的集合

定义：String s1 = “uml”; String s2 = “uml”; String s3= new String(“uml”); String s4= new String(“uml”);那么，s1==s2；s3 == s4；s1.equals(s3); 判断正确与否

T，F，T
F，T，F

该题考察的是String类创建的对象在JVM中的内存分配和“equals”与“==”的区别。
“==”比较的是地址和值。
“equals”比较的是值。

s1 == s2，比较的是比较的是地址和值，由上图得知两个引用指向的是同一个地址，所以返回true.
s3 == s4，比较的是两个new出来开辟的空间对象地址，所以值相同，但地址不同，返回false.
s1.equals(s3)，比较的是内容,返回true。

java中 String str = "hello world"下列语句错误的是？

str+=’ a’
int strlen = str.length
str=100
str=str+100

A.str += ‘a’ 和 str +="a"都是对的，但是如果a前面加一个空格，那么只能用双引号了。代表字符串
B.数组有length属性，字符串只有length()方法
C.int 无法直接转成String类型
D.字符串尾部添加字符串”100“

Java集合

对 Map 的用法，正确的有：

A. new java.util.Map().put(“key” , “value”) ;
B. new java.util.SortedMap().put(“key” , “value”) ;
C. new java.util.HashMap().put( null , null ) ;
D. new java.util.TreeMap().put( 0 , null ) ;

Map家族的继承实现关系如下，注意一点就是顶层的Map接口与Collection接口是依赖关系：
关于Key和Value能否为null的问题：

选C，D
Map和SortedMap是接口，不能直接new对象，A,B错误
HashMap 允许null-null键值对 C正确
TreeMap 允许value值为null，不允许key值为null，D是value为null，key不为null，正确

类和接口

关于Java的抽象类、接口，以下描述错误的是？

A. 抽象类不一定含有抽象方法，接口中的方法都是抽象方法
B. 一个类只能继承一个抽象类，但可以实现多个接口；一个接口可以继承多个接口
C. 抽象类和接口中的方法都没有方法体
D. 抽象类可以含有私有成员变量，接口不含有私有成员变量

选择C。
A----------抽象类不一定含有抽象方法，接口中的方法都是抽象方法。
接口中的方法默认修饰符有public abstract。
B----------一个类只能继承一个一个抽象类，但可以实现多个接口；一个接口可以继承多个接口。
Java里类是单继承的，接口是可以多继承的，用关键字extends。
C----------抽象类和接口中的方法都没有方法体。
抽象类中的方法是可以有方法体的。JDK1.8之后，接口中的方法也可以有方法体，用default关键字修饰方法。
D----------抽象类可以含有私有成员变量，接口不含有私有成员变量。
接口中的成员变量都是public static final的，一般用作常量。

以下描述正确的是

CallableStatement是PreparedStatement的父接口
PreparedStatement是CallableStatement的父接口
CallableStatement是Statement的父接口
PreparedStatement是Statement的父接口

Statement 每次执行sql语句，数据库都要执行sql语句的编译，最好用于仅执行一次查询并返回结果的情形，效率高于PreparedStatement.
PreparedStatement是预编译的，使用PreparedStatement有几个好处
a. 在执行可变参数的一条SQL时，PreparedStatement比Statement的效率高，因为DBMS预编译一条SQL当然会比多次编译一条SQL的效率要高。
b. 安全性好，有效防止Sql注入等问题。
c. 对于多次重复执行的语句，使用PreparedStament效率会更高一点，并且在这种情况下也比较适合使用batch；
d. 代码的可读性和可维护性。
CallableStatement接口扩展 PreparedStatement，用来调用存储过程,它提供了对输出和输入/输出参数的支持。CallableStatement 接口还具有对 PreparedStatement 接口提供的输入参数的支持。

我们在程序中经常使用“System.out.println()”来输出信息，语句中的System是包名，out是类名，println是方法名。[ 错误 ]

System是java.lang中的一个类，out是System内的一个成员变量，这个变量是一个java.io.PrintStream类的对象，println呢就是一个方法了。

异常

代码String str=”123456a”；int i=Integer.parseInt(str);会报异常的是（）

java.lang.NullPoninterException
java.lang.NumberFormatException
java.lang.RuntimeException
java.lang.ArrayindexOutOfBoundsException

java.lang.NullPoninterException：变量未被初始化、对象未赋值、对象为空（俗称的空指针异常）
java.lang.NumberFormatException：数据格式转换失败（integer的取值范围为：-127-128，超过范围都会访问false）
java.lang.RuntimeException：运行时异常
java.lang.ArrayindexOutOfBoundsException：数组下标越界

基本数据类型（转换、赋值等）

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

-126
-127
-128
-129

byte取值范围

Java中，byte在内存中占一个字节，取值范围为何是-128~127？（-2⁷ ~ 2⁷-1）

计算机是用二进制来表示数据的，一个字节也就是8个比特位，其中最高位表示符号位（0正1负）

故byte的取值范围为1000 0000 到 0111 1111

在Java中，是采用补码来表示数据的

正数的补码和原码相同，负数的补码是在原码的基础上各位取反然后加1

1000 000是补码，减一然后按位取反得到其原码1000 0000
（减一得 0111 1111，再按位取反得 1000 0000）

因为是负数，所以最小的byte值为-2^7=-128
0111 1111的十进制为2^7-1=127（等比序列求和）

byte是一个字节，共有2^8=256种可能性，也就是-128~127

其他基本数据类型同理
char没有负值，占两个字节，所以取值范围是0~2^16-1（65535）

以下那些代码段能正确执行

public static void main(String args[]) {
byte a = 3;
byte b = 2;
b = a + b;
System.out.println(b);
}
public static void main(String args[]) {
byte a = 127;
byte b = 126;
b = a + b;
System.out.println(b);
}
public static void main(String args[]) {
byte a = 3;
byte b = 2;
a+=b;
System.out.println(b);
}
public static void main(String args[]) {
byte a = 127;
byte b = 127;
a+=b;
System.out.println(b);
}

byte类型的变量在做运算时被会转换为int类型的值，故A、B左为byte，右为int，会报错；而C、D语句中用的是a+=b的语句，此语句会将被赋值的变量自动强制转化为相对应的类型。

给出下面的代码段:

public class Base{
		int w, x, y ,z;
	public Base(int a,int b)
	{
		x=a; y=b;
	}
	public Base(int a, int b, int c, int d)
	{
		// assignment x=a, y=b
		w=d;z=c;
	}
}

在代码说明// assignment x=a, y=b处写入如下哪几个代码是正确的？（）

Base(a,b);
x=a, y=b;
x=a; y=b;
this(a,b);

A错，调用Base这个构造方法应该这样 new Base(a,b)
B错，可以使用逗号的是变量初始化的语句，比如int i=1,b=2;如果是赋值语句，不能用逗号分隔
C正常赋值操作
D调用本类的构造方法

下面的Java赋值语句哪些是有错误的（）

int i =1000;
float f = 45.0;
char s = ‘\u0639’;
Object o = ‘f’;
String s = “hello,world\0”;
Double d = 100;

选项B，float f = 45.0f ;
选项F是自动装箱，装箱过程中调用的是Double类的valueOf( double d )方法，而这里是100为int型，所以编译会“cannot convert from int to Double”

What is the result of compiling and executing the following fragment of code:

Boolean flag = false;
if (flag = true)
{
    System.out.println(“true”);
}
else
{
    System.out.println(“false”);
}

The code fails to compile at the “if” statement.
An exception is thrown at run-time at the “if” statement.
The text “true” is displayed.
The text “false” is displayed.
Nothing is displayed.

Boolean修饰的变量为包装类型，初始化值为false,进行赋值时会调用Boolean.valueOf(boolean b)方法自动拆箱为基本数据类型，因此赋值后flag值为true，输出文本true。如果使用==比较,则输出文本false。if的语句比较，除boolean外的其他类型都不能使用赋值语句，否则会提示无法转成布尔值。

MySQL

mysql数据库，game_order表表结构如下，下面哪些sql能使用到索引（）？

select * from game_order where plat_game_id=5 and plat_id=134
select * from game_order where plat_id=134 and
plat_game_id=5 and plat_order_id=’100’
select * from game_order where plat_order_id=’100’
select * from game_order where plat_game_id=5 and
plat_order_id=’100’ and plat_id=134
select * from game_order where plat_game_id=5 and plat_order_id=’100’

考察组合索引的知识。有一个最左优先的原则，组合索引(a, b, c)，会建立三个索引, (a), (a, b), (a, b, c)。
在查询语句中，
1)where a = xxx
2)或者 where a = xxx and b = yyy
3)或者where a = xxx and b = yyy and c = zzz
4)或者 where b = yyy and c = zzz and a = xxx
都可以使用索引。第4）中情况可以优化成第3）种。
不包含a的情况，则用不到索引。例如where b = yyy and c = zzz

访问权限问题

final方法等同于private方法。（错误）

说白了private方法只可以在类的内部使用，在类外根本访问不到，而final方法可以在类外访问，但是不可以重写该方法，就是说可以使用该方法的功能但是不可以改变其功能，这就是private方法和final方法的最大区别

protected访问权限要小于包访问权限。(错误)
Java类成员的访问控制权限：
public > protected > 同包（default） > private
关于访问权限说法正确的是？ ( )

A. 外部类前面可以修饰public,protected和private
B. 成员内部类前面可以修饰public,protected和private
C. 局部内部类前面可以修饰public,protected和private
D. 以上说法都不正确

（ 1 ）对于外部类而言，它也可以使用访问控制符修饰，但外部类只能有两种访问控制级别： public 和默认。因为外部类没有处于任何类的内部，也就没有其所在类的内部、所在类的子类两个范围，因此 private 和 protected 访问控制符对外部类没有意义。
（ 2 ）内部类的上一级程序单元是外部类，它具有 4 个作用域：同一个类（ private ）、同一个包（ protected ）和任何位置（ public ）。
（ 3 ）因为局部成员的作用域是所在方法，其他程序单元永远不可能访问另一个方法中的局部变量，所以所有的局部成员都不能使用访问控制修饰符修饰。

下面字段声明中哪一个在interface主体内是合法的? （）

private final static int answer = 42;
public static int answer = 42;
final static answer = 42;
int answer;

在接口中，属性都是默认public static final修饰的，所以：
A（错误）：不能用private修饰；
B（正确）：在接口中，属性默认public static final，这三个关键字可以省略；
C（错误）：没写属性的类型；
D（错误）：final修饰的属性必须赋值；

方法

对于构造方法，下列叙述正确的是（）。

构造方法的优先级一般比代码块低。
构造方法的返回类型只能是void型。
构造方法的主要作用是完成对类的对象的初始化工作。
一般在创建新对象时，系统会自动调用构造方法。

A：静态成员变量或静态代码块>main方法>非静态成员变量或非静态代码块>构造方法
B：think in java中提到构造器本身并没有任何返回值。
C: 构造方法的主要作用是完成对类的对象的初始化工作。
D: 一般在创建(new)新对象时，系统会自动调用构造方法。

以下哪些方法是Object类中的方法

clone()
toString()
wait()
finalize()

下列有关java构造函数叙述正确的是（）

构造器的返回值为void类型
如果一个源文件中有多个类，那么构造器必须与公共类同名
构造器可以有0个，1个或一个以上的参数
每个类可以有一个以上的构造器

构造方法是一种特殊的方法，具有以下特点。
（1）构造方法的方法名必须与类名相同。
（2）构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。
（3）构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的参数传给对象的域。
（4）一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造器，这个构造器不执行任何代码。
（5）构造方法可以重载，以参数的个数，类型，顺序。

如果有多个类，多个类都可以有自己的构造器，所以我认为b是错的

名词解释

以下J2EE中常用的名词解释错误的是？

EJB容器：Enterprise java bean 容器
JNDI：JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。
JMS：JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。
JAF：JAVA安全认证框架。提供一些安全控制方面的框架。

web容器：给处于其中的应用程序组件（JSP，SERVLET）提供一个环境，使 JSP,SERVLET直接更容器中的环境变量接**互，不必关注其它系统问题。主要有WEB服务器来实现。例如：TOMCAT,WEBLOGIC,WEBSPHERE等。该容器提供的接口严格遵守J2EE规范中的WEB APPLICATION 标准。我们把遵守以上标准的WEB服务器就叫做J2EE中的WEB容器。
EJB容器：Enterprise java bean 容器。更具有行业领域特色。他提供给运行在其中的组件EJB各种管理功能。只要满足J2EE规范的EJB放入该容器，马上就会被容器进行高效率的管理。并且可以通过现成的接口来获得系统级别的服务。例如邮件服务、事务管理。
JNDI：（Java Naming & Directory Interface）JAVA命名目录服务。主要提供的功能是：提供一个目录系，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能。
JMS：（Java Message Service）JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。
JTA：（Java Transaction API）JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。
JAF：（Java Action FrameWork）JAVA安全认证框架。提供一些安全控制方面的框架。让开发者通过各种部署和自定义实现自己的个性安全控制策略。

RMI/IIOP:（Remote Method Invocation /internet对象请求中介协议）他们主要用于通过远程调用服务。例如，远程有一台计算机上运行一个程序，它提供股票分析服务，我们可以在本地计算机上实现对其直接调用。当然这是要通过一定的规范才能在异构的系统之间进行通信。RMI是JAVA特有的。

计网

默认RMI采用的是什么通信协议？

TCP/IP

•••

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
牛客Java专项练习

题目线程StringJava集合线程以下程序的运行结果是？A.foobarB.barfooC.foobar或者barfoo都有可能答案是 A foobar 这道题是考线程的调用情况，线程的启动方式只能通过start这种方式启动才能真正的实现多线程的效果，如果是手动调用run方法和普通方法调用没有区别，所以这个还是按照顺序执行首先执行run方法之后，执行输出语句所以最终得到结果foobar.public class ThreadTest { public static vo
复制链接

扫一扫