【Java】基础面试题

第一套：

一、选择题：

1. 下面那些是不合法的标识符 (AC)

A.$persons B.TwoUsers C.*point D._endline

标识符是用户编程时使用的名字，对于变量、常量、函数、语句块也有名字；我们统统称之为标识符。

标识符规则如下：
（1）第一个字符必须是字母（不分大小写）或下划线（）;
（2）后跟字母（不分大小写）、下划线（）或数字组成;
（3）标识符中的大小写字母有区别。如，变量sum,sum,sum代表三个不同的变量；
（4）不能与c编译系统已经预定义的、具有特殊用途的保留标识符（即关键字）同名。比如，不能将标识符命名为float,auto,break,case,this,try,for,while,int,char,short, unsigned,等等。

2. 下列语句执行后，k的值为 （ A.12）

int i=6,j=8,k=10,m=7
if(!( i>j | m>k++))
    k++;

A.12 B.11 C.10 D.9

3. 关于下列程序段的输出结果，正确的是 （D）

public class MyClass{
    static int i;
    public static void main(String args[])){
     System.out.println(i);       
    }
}

A.有错误，变量i没有初始化 B.null C.1 D.0

原因： 静态变量只能初始化一次，如果未初始化，则运行时系统会自动初始化为0

4. 欲构造ArrayList的一个实例，此继承类List接口，下列哪个方法是正确的？ ( B )

A. ArrayList mylist = new Object();
B. List myList = new ArrayList();
C.ArrayList myList = new List();
D.List myList = new List();

*5. 下列哪个类声明是正确的？ ( D )

A. abstract final class HI{…}
B. abstract private move(){…}
C. protected private number;
D. public abstract class Car{…}

修饰类的关键字：
static :可修饰类，修饰方法，修饰变量
final ：可修饰类，修饰方法，修饰变量
abstract ：修饰类，修饰方法

public ：可修饰类，所有的类都可以使用
private ：可修饰类，只有同一个包下面的类和子类可以使用
protected：修饰类，只有同一个包下的类可以用，子类在同包中可以用，不在同包中不能用
default：可修饰类，自己的类中才能用
abstract和final不能同时修饰一个类的原因：abstract是抽象类，以就是指定必须要子类继承才可以使用;
而final是指定不允许继承，这岂不是矛盾了。

6. 下列叙述中，错误的是 (D)

A. 接口与类的层次无关
B. 通过接口说明类所实现的方法
C. 通过接口可了解对象的交互界面
D. 接口与存储空间有关

接口与类的关系： 接口不包括任何实现，所以与存储空间没有任何关系。

7. 下列代码的执行结果是： C

public class Test5{
    public static void main(String arrgs[]){
        String s1 = new String("hello");
        String s2 = new String("hell0");
        System.out.print(s1 == s2);
        System.out.print(",");
        System.out.print(s1.equals(s2));    
    }
}

A. true,false B.true,true C.false,true D.false,false

== 和 equals的区别
== ：即比较字符串的内容，又比较字符串的大小
equals : 只比较字符串的大小

example1:
String a=“abc”;String b=“abc”
那么ab将返回true。因为在java中字符串的值是不可改变的，相同的字符串在内存中只会存
一份，所以a和b指向的是同一个对象；
example2：
String a=new String(“abc”); String b=new String(“abc”);
那么ab将返回false，此时a和b指向不同的对象。
example：
String a=new String(“abc”);
String b=new String(“abc”);
a.equals(b);
将返回true。

8. 下列说法正确的是： D

A. 在java中类和接口是都多继承的
B. 在java中一个类只能实现一个接口
C. 在java中一个类不能同时继承一个类和实现一个结构
D. java的单一继承使代码更可靠

java中一个类只能继承一个类，可以实现多个接口；并且可以同时继承一个类，实现一个接口

9. 下面一段程序第十行的声明将调用哪行的方法： D

class Person{
    public void printValue(int i,int j){/*...*/}
    public void printValue(int i){/*...*/}
}
public class Teacher extends Person{
    public void printValue(){/*...*/}
    public void printValue(int i){/*...*/}
    public static void main(String args[]){
        Person t = new Teacher();
        Teacher t1 = new (Teacher)Person();
        t.printValue(10);            
    }
}

A.第2行 B.第1行 C.第6行 D.第7行

子类继承父类并且重写父类的方法时，在子类中调用该方法则执行的是子类重写过的

*10.下列说法正确的有： B

A. 在类方法中可用this来调用本类的类方法
B. 在类方法中调用本类的类方法是可直接调用
C. 在类方法中只能调用本类中的类方法
D. 在类方法中绝对不能调用实例方法

Java中类的方法分为类方法（用static修饰，也叫静态方法）和实例方法（没有用static修饰，也叫非静态方法）
static修饰的方法才能用类名.方法调用，如果不是静态方法你还得通过构造器new 类名，才能调用该类的方法. 非静态方法可以调用静态方法；静态方法不能调用本类的非静态方法和非静态变量。
A.解答
静态方法随着类的加载而加载，静态方法是优先于对象而存在的。当我们加载一个类的时候，对象还没有存在，而this代表的是对象的引用，当我们加载类的时候对象都没有,this更不可能存在
B.C.解答
本类的静态方法，在本类中直接调用就可以了，其他类的静态方法，只要修饰符是public，可以直接 类名.方法名 来调用
D.解答
静态方法不能直接调用实例方法和变量，但可以间接调用(即在静态方法中创建类的实例，然后调用)

*11. 下列不正确的有 A,C,D

A. call by value 不会改变实际参数的数值
B. call by reference 能改变实际参数的参考地址
C. call by reference 不能改变实际参数的参考地址
D. call by reference 能改变实际参数的内容

call by value(值传递) 和 call by reference(引用传递)：
值传递：传递的是具体的值，如基础数据类型。按值传递时在调用的方法中，参数只是实际参数的一个拷贝。所以不管参数在方法里面如何修改都不会改变原来参数值。也就是说val的值一直保持不变。
引用传递：传递的是对象的引用，即对象的存储地址。按引用传递时，会产生一份新的引用。(不妨叫做y)。此时x和y指向了同一个对象。
例子中：当调用setStringVal方法时，引用拷贝即y指向了另一个对象（“345”）此时并不会改变x引用的值，所以打印的是234。
例子中：当调用changeStringVal时，y引用改变了对象的实际的值，此时x和y指向的还是同一个对象。所以打印的是234123。

public static void main(String[] args) {

    //按值传递
    int val = 20 ;
    System.out.println(val); //打印的是20
    setVal(val);
    System.out.println(val) ; //打印的还是20
    
    //按引用传递
    StringBuffer val2 = new StringBuffer("234");
    System.out.println(val2.toString()) ;//打印的是234
    setStringVal(val2) ;
    System.out.println(val2.toString()) ;//打印的是234
    changeStringVal(val2);
    System.out.println(val2.toString()) ;//打印的是234123
}

static void setVal(int val)
{
    val = 10;
}
static void setStringVal(StringBuffer val)
{
    val =  new StringBuffer("345");
}
static void changeStringVal(StringBuffer val)
{
    val = val.append("123") ;
}

*12. 下列说法正确的是： A,C

A. 数组是一种对象
B. 数组属于一种原生类
C. int number[] = {31,23,33,43,35,63}
D. 数组的大小可以任意改变

java的原生类可以理解为java的8中基本数据类型对应的8个封装类，而数组的类型并不局限这8个基本数据类型的封装类。
数组的长度，在定义数组时，长度可以任意指定，但数组一旦定义完毕，数组的大小，也就是数组的长度就不可以改变了。
java 静态数组的定义：数据类型[] 数组名 =new 数组类型 [] {元素1，元素2，元素3…}; 或 如C

*13. 阅读下列代码，正确的说法是： B

public class Test{
    private static int j = 0;
    private static boolean methodB(int k){
        j += k;
        return true;    
    }
    public static void methodA(int i){
        boolean b;
        b = i < 10 | methodB(4);
        b = i < 10 || methodB(8);    
    }
    public static void main(String[] args){
        methodA(0);
        System.out.println(j);    
    }
}

A. The program prints “0”
B. The program prints “4”
C. The program prints “8”
D. The code does not complete

1. java中 “|” 与 “||” 的区别：
两者都是或，但是 “||” 表示短路或，当运算符左边的值为true时，右边的表达式不会进行运算。
而 "|"中，无论第一个条件是否为true，程序都会去执行判断第二个条件表达式
EX：
int i=0;
if(3>2 || (i++)>1) i=i+1;
System.out.println(i);
这段程序会打印出1，而不是打印出2。
因为在if的条件判断中，程序先判断第一个表达式3>2是否成立，结果3>2为真，那么按照逻辑来说，无论后面一个表达式(i++)>1是否成立，整个或表达式肯定为真，因此程序就不去执行判断后面一个表达式即(i++)>1了，所以这里i并没有自增1。然后程序执行到i=i+1，于是i变为1。最后打印出1。
int i=0;
if(3>2 | (i++)>1) i=i+1;
System.out.println(i);
如果换做这样写，那么就是打印出2了，
因为无论第一个条件3>2是否为真，程序都会去执行判断第二个条件表达式，因此i++这个自增是会被执行的，再加上if内的i=i+1，所以最终i=2。

2. static修饰的变量：作用之一——保持变量内容的持久！
静态变量（static）：变量的值在函数调用结束后不消失而保留原值，即下次调用该函数时该变量能保留上次函数调用结束之后的值。
静态变量分为静态局部变量和静态全局变量，均储存在静态储区。
static的作用：
1.储存在静态数据区的变量会在程序刚开始运行时就完成分配和初始化，并且只分配和初始化一次；
2.如果在定义局部变量时不赋初值，系统自动赋初值为0；
3.static修饰全局变量的时候，这个全局变量只能在本文件中访问，不能在其他文件中访问，即便是extern(外部声明)也不可以。

局部：把局部变量改变为静态变量后是改变了它的存储方式，即改变了它的生存期。
静态局部变量在函数内定义,生存期为整个源程序，但作用域与自动变量相同，只能在定义该变量的函数内使用。退出该函数后， 尽管该变量还继续存在，但不能使用它。
对基本类型的静态局部变量若在说明时未赋以初值，则系统自动赋予0值。而对自动变量不赋初值，则其值是不定的。

全局：把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。
全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。但是他们的作用域不一样。
非静态全局变量的作用域是整个源程序（多个源文件可以共同使用）；
而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。

**14、假设部署了Tomcat服务器上的helloapp应用中有一个hello.jsp，它的文件路径如下：%CATALINA_HOME%/webapps/helloapp/hello/hello.jsp 如果Tomcat采用默认配置，那么在浏览器访问hello.jsp的URL是什么？ C

A. http://localhost:8080/hello.jsp
B. http://localhost:8080/helloapp/hello.jsp
C. http://localhost:8080/helloapp/hello/hello.jsp
D. http://localhost:8080/helloapp/helloapp/hello.jsp

注：tomcat默认的而发布路径为： tomcat/webapps/目录

15、在MVC体系架构中，承担显示功能(VIEW层)的组件是： A

A. JSP B. JavaBean C. Servlet C. JDBC

Model（模型）： 负责业务数据管理和处理，包括增删改查。Model必须提供外部可以操作模型数据的接口，同时在数据发生变化后能够通知外部
View（视图）： 用户界面。View需要感知Model的变化，数据变化时，更新用户界面
Controller（控制器）： 业务逻辑层。Controller需要感知View的事件，调用Model提供的接口对数据进行操作

16、下面哪个函数是public void example(){…}的重载函数？ A

A. public void example(int m){…}
B. public void example(){…}
C. public void example2(){…}
D. public void example2(int m,float f){…}
函数重载条件：
1）函数名称必须相同。
2）参数列表必须不同（个数不同、类型不同、参数排列顺序不同等）。
3）函数的返回类型可以相同也可以不相同。
4）仅仅返回类型不同不足以成为函数的重载。

17、已知如下代码，当m的值为什么时输出“Condition 2”？ B

A. 4 B. 1 C.None D. 3

switch(m){
    case 0:System.out.println("Condition 0");
    case 1:System.out.println("Condition 1");
    case 2:System.out.println("Condition 2");
    case 3:System.out.println("Condition 3");
    break;
    default:System.out.println("Other Condition");
}

case的穿透性： 在switch语句中，如果后面不写break，程序会一直往下走，不会判断case中的常量值，执行后面所有的case知道遇到break结束，或者执行完所有的case结束

18、以下哪个方法用于定义线程的执行体？ C

A. start() B. init() C. run() D.main()

run()方法是用来定义这个线程在启动的时候需要做什么，但是，直接执行run()方法那就不是线程，必须使用start()启动，那样才是线程。
线程是进程中的实体，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程不拥有系统资源，只有运行必须的一些数据结构；与父进程的其它线程共享该进程所拥有的全部资源。线程可以创建和撤消线程，从而实现程序的并发执行。一般，线程具有就绪、阻塞和运行三种基本状态。

19、下段代码的输出值为： C

public calss Test{
    void printValue(int m){
        do{
             System.out.println("The Value is"+m);       
        }while(--m > 10);
    }
    public static void main(String[] args){
        int i=10;
        Test t = new Test();
        t.printValue(i);    
    }
}

A. The Value is8 B. The Value is9 C.The Value is10 D.The Value is11

do…while循环： 先执行循环体语句，然后在进入判断循环条件是否满足表达式的值；
–i 表示先执行自减运算，然后在使用自减后的i变量值进行其他的运算。
i-- 表示先使用 i 的值进行运算，然后在对 i 变量进行自减。

20、下列语句哪一个正确： B

A. Java程序经编译后会产生machine code
B. Java程序经编译后会产生byte code
C. Java程序经编译后会产生DLL
D. 以上都不正确

bytecode（字节码文件），也就是.class文件。 Java字节码是Java源文件编译产生的中间文件，java程序在编译（javac .java文件名 指令）后会产生字节码文件，也就是.class文件。然后根据虚拟机所在系统（l例如：xp、win7、Linux）的不同将字节码文件转变为不同的可执行文件，这也是java程序可跨平台的根据。
machine code是机器码，是电脑的CPU可直接解读的数据。java是高级语言，产生的是字节码，电脑只能运行机器码。Java在运行的时候需要依赖JVM来翻译成01的机器码。
java程序怎么编译 java程序编译后会产生byte code

21、典型的JDBC程序按（）顺序编写（排序） DBECFA

A. 释放资源
B. 获得与数据库的物理链接
C. 执行SQL命令
D. 注册JDBC Driver
E. 创建不同类型的Statement
F. 如果有结果集，处理结果集

第一步：注册驱动（告诉Java程序，即将要连接那个品牌的数据库）
第二步：获取连接（表示JVM的进程和数据库进程之间的通道打开了，这属于进程之间的通信，重量级的，使用完后一定要关闭）
第三步：获取数据库操作对象（专门执行sql语句的对象）
第四步：执行SQL语句（DQL DML …)
第五步：处理查询结果集（只有第四步执行select语句时，才会执行第五步）
第六步：释放资源（使用完资源后一定要关闭资源。Java和数据库属于进程间通信，开启后一定要关闭）

二、问答题

1、请编写一个java类 Test.java，求出100以内既能被2整除又能被3整除的数，并输出到控制台上。

public class NumberDivide {
    public static void main(String[] args) {
        
        int[] num = new int[100];
        for(int i=0;i<num.length;i++){
            num[i] = i;
        if(num[i]%2 == 0 && num[i]%3 == 0){
        
        System.out.print(num[i]+" ");
        }
        }
        
    }
}

2、有3张表，

Employee职工（工号，姓名，性别，年龄，部门）(num，name，sex，age，departmentno)
Wage工资（编号，工资金额）(No，amount)
Attend 出勤（工号，工资编号，出勤率）(num，No，attendance)
请根据要求，编写相应的SQL语句
1）写一个SQL语句，查询工资金额为8000的职工工号和姓名。

select e.num,e.name from Employee e where e.num in (select a.num from Wage w,Attend a where a.no = w.no and w.amount = 8000)

2）写一个SQL语句，查询职工张三的出勤率。

select e.name,a.attendance from Attend a,Employee e where a.num = e.mum and a.name = '张三'

3）写一个SQL语句，查询出勤率为10并且工资金额小于2500的职工信息。

select * from Employee e where  e.num in (select a.num from Wage w,Attend a where a.no = w.no and w.amount < 2500 and a.attendance <10)

3、String类是否可以继承？为什么？

不能被继承，因为String类有final修饰符，而final修饰的类是不能被继承的。String类是不可变类型(Immutable)类。

为什么要加final或将String类设置成不可变类，主要是两点：
第一个原因是线程安全： 不可变对象始终是线程安全的，因为线程必须完全构建它们，然后才能将它们传递给其他人——并且在构建之后，它们不能再被更改。因为字符串是不可变的，所以是多线程安全的，同一个字符串实例可以被多个线程共享。这样便不用因为线程安全问题而使用同步。如果字符串是可变的，那么会引起很严重的安全问题。譬如，数据库的用户名、密码都是以字符串的形式传入来获得数据库的连接，或者在socket编程中，主机名和端口都是以字符串的形式传入。
第二个原因是速度： final 类无法被继承，这使得 JIT 在处理字符串时可以进行各种优化——永远不需要检查被覆盖的方法

final修饰符的用法：
1.修饰类
当用final修饰一个类时，表明这个类不能被继承。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。
2.修饰方法
使用final修饰方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。因此，只有在想明确禁止该方法在子类中被覆盖的情况下才将方法设置为final。
注：一个类中的private方法会隐式地被指定为final方法。
3.修饰变量
对于被final修饰的变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。虽然不能再指向其他对象，但是它指向的对象的内容是可变的。

4、请给出至少2个常见运行时异常。

1、空指针异常类：NullPointerException
2、数据类型转换异常：java.lang.ClassCastException
3、没有访问权限：java.lang.IllegalAccessException
4、方法的参数错误：java.lang.IllegalArgumentException
5、数组下标越界异常：java.lang.IndexOutOfBoundsException
6、文件已结束异常：EOFException
7、文件未找到异常：FileNotFoundException
8、字符串转换为数字异常：NumberFormatException
9、指定的类不存在： java.lang.ClassNotFoundException
10、实例化异常：java.lang.InstantiationException

1、空指针异常类：NullPointerException
调用了未经初始化的对象或者是不存在的对象。经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针， 即把数组的初始化和数组元素的初始化混淆起来了。
数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化， 依然是空的，所以还需要对每个元素都进行初始化(如果要调用的话)。
2、数据类型转换异常：java.lang.ClassCastException
当试图将对某个对象强制执行向下转型，但该对象又不可转换又不可转换为其子类的实例时将引发该异常，如下列代码。
Object obj = new Integer(0);
String str = obj;
3、没有访问权限：java.lang.IllegalAccessException
当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了Package的情况下要注意这个异常。
4、方法的参数错误：java.lang.IllegalArgumentException
比如g.setColor(int red,int green,int blue)这个方法中的三个值，如果有超过255的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。
5、数组下标越界异常：java.lang.IndexOutOfBoundsException
查看调用的数组或者字符串的下标值是不是超出了数组的范围，一般来说，显示(即直接用常数当下标)调用不太容易出这样的错，但隐式(即用变量表示下标)调用就经常出错了。
还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候先查看一下数组的length，以免出现这个异常。
6、文件已结束异常：EOFException
当程序在输入的过程中遇到文件或流的结尾时，引发异常。因此该异常用于检查是否达到文件或流的结尾
7、文件未找到异常：FileNotFoundException
当程序试图打开一个不存在的文件进行读写时将会引发该异常。该异常由FileInputStream,FileOutputStream,RandomAccessFile的构造器声明抛出，即使被操作的文件存在，但是由于某些原因不可访问，比如打开一个只读文件进行写入，这些构造方法仍然会引发异常。
8、字符串转换为数字异常：NumberFormatException
当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常.如现在讲字符型的数据“123456”转换为数值型数据时，是允许的。
但是如果字符型数据中包含了非数字型的字符，如123#56，此时转换为数值型时就会出现异常。系统就会捕捉到这个异常，并进行处理。
9、指定的类不存在： java.lang.ClassNotFoundException
这里主要考虑一下类的名称和路径是否正确即可，通常都是程序试图通过字符串来加载某个类时可能引发异常。比如：调用Class.forName;或者调用ClassLoad的finaSystemClass;或者LoadClass;
10、实例化异常：java.lang.InstantiationException
当试图通过Class的newInstance方法创建某个类的实例,但程序无法通过该构造器来创建该对象时引发。Class对象表示一个抽象类，接口，数组类，基本类型 。该Class表示的类没有对应的构造器。