Java面试题精解-优快云博客

Java初中级面试题

基本概念
类和接口
泛型（暂缺）
- 简答题
- - 泛型的优缺点
  - 泛型常用特点，List<String>能否转为List<Object>
枚举和注解（暂缺）
方法（暂缺）
异常

基本概念

选择题

下面关于变量及其作用范围的陈述哪个是不对的? （B ）
A．实例变量是类的成员变量。
B．实例变量用关键字static声明。
C．在方法中定义的局部变量在该方法被执行时创建。
D．局部变量在使用前必须被初始化。
下面哪条语句把方法声明为抽象的公共方法?（ B ）
A．public abstract method();
B．public abstract void method();
C．public abstract void method(){}
D．public void method() extends abstract;
哪个是将一个十六进制值赋值给一个long型变量?（ D ）
A．long number = 345L;
B．long number = 0345;
C．long number = 0345L;
D．long number = 0x345L;
下面的哪个赋值语句是不对的?（ A ）
A．float f = 11.1;
B．double d = 5.3E12;
C．double d = 3.14159;
D．double d = 3.14D;
下面哪个是不合法的标识符?（ C）
A．$persons;
B．TwoUsers;
C．*point;
D．_endline;
若在某一个类定义中定义有如下的方法： final void aFinalFunction( );则该方法属于（ C ）。
A．本地方法
B．静态方法
C．最终方法
D．抽象方法
main方法是Java Application程序执行的入口点，关于main方法的方法头以下哪项是合法的（ B ）。
A．public static void main()
B． public static void main(String[ ] args)
C． public static int main(String[ ] args)
D．public void main(String arg[ ])
以下代码段执行后的输出结果为（ C ）。

int x=-3; float y=10.0f;
System.out.println(y%x);

A．不能成功编译 B． -1.0 C．1.0 D．-1
下列关于构造方法的叙述中，错误的是（ C ）
A．Java语言规定构造方法名与类名必须相同
B．Java语言规定构造方法没有返回值，但不用void声明
C．Java语言规定构造方法不可以重载
D．Java语言规定构造方法只能通过new自动调用
关于被私有访问控制符private修饰的成员变量，以下说法正确的是（C）
A．可以被三种类所引用：该类自身. 与它在同一个包中的其他类. 在其他包中的该类的子类
B．可以被两种类访问和引用：该类本身. 该类的所有子类
C．只能被该类自身所访问和修改
D．只能被同一个包中的类访问
阅读以下代码：
输出结果应该是：（ C ）
A．代码得到编译，并输出“s=”
B．代码得到编译，并输出“s=null”
C．由于String s没有初始化，代码不能编译通过
D．代码得到编译，但捕获到 NullPointException异常

public class foo{
	public static void main (String[] args){
		String s;
		System.out.println("s=" + s);
	}
}

下述概念中不属于面向对象方法的是( D )。
A．对象. 消息
B．继承. 多态
C．类. 封装
D．过程调用
下面哪个不是String类的方法?（ C ）
A．subString()
B．startsWith()
C．toString()
D．toUpperCase()
下面哪条语句是正确的?（ D ）
A: short snum = 99s;
B: String name = ‘Class Name is: 03076’;
C: char c = 17c;
D: float f = 3.4f;
下面方法中的“返回类型Type”应该是什么？ ( A )
A . double
B. int
C. byte
D. short

public class ReturnIt{

    returnType methodA(byte x, double y){

        return (short)x / y * 2;

    }

}

下面哪一个表达式是正确的？ ( C )
A. byte=128;
B. Boolean=null;
C. long l=0xfffL;
D. double=0.9239d;
下面哪个修饰符修饰的变量是所有同一个类生成的对象共享的?（ C）
A. public
B. private
C. static
D. final
下面关于java中类的说法哪个是不正确的?（ C ）
A. 类体中只能有变量定义和成员方法的定义，不能有其他语句。
B. 构造函数是类中的特殊方法。
C. 类一定要声明为public的，才可以执行。
D. 一个java文件中可以有多个class定义。
指出正确的表达式 ( C )
A. byte=128;
B. Boolean=null;
C. long l=0xfffL;
D. double=0.9239d;
指出下列程序运行的结果 ( B )

public class Example {
    String str = new String("good");
    char[] ch = {'a', 'b', 'c'};

    public static void main(String args[]) {
        Example ex = new Example();
        ex.change(ex.str, ex.ch);
        System.out.print(ex.str + " and ");
        System.out.print(ex.ch);
    }

    public void change(String str, char ch[]) {
        str = "test ok";
        ch[0] = 'g';
    }
}

A. good and abc
B. good and gbc
C. test ok and abc
D. test ok and gbc

下列代码哪几行会出错: ( C )

     public void modify() {
        	int I, j, k;
        	I = 100;
        	while ( I > 0 ) {
        	j = I * 2;
        	System.out.println (" The value of j is " + j );
        	k = k + 1;
        	I--;
        	}
         }

A. line 4
B. line 6
C. line 7
D. line 8

MAX_LENGTH是int型public成员变量, 变量值保持为常量100，用简短语句定义这个变量。 ( D )
A. public int MAX_LENGTH=100;
B. final int MAX_LENGTH=100;
C. final public int MAX_LENGTH=100;
D. public final int MAX_LENGTH=100;
给出下面代码：

class Parent { 
	private String name; 
	public Parent(){} 
} 
public class Child extends Parent { 
	private String department; 
	public Child() {} 
	public String getValue(){ return name; } 
	public static void main(String arg[]) { 
 		Parent p = new Parent(); 
 	} 
 }

那些行将引起错误？ ( D )
A. 第3行
B. 第6行
C. 第7行
D. 第8行

类Teacher和Student是类Person的子类；

     Person p; 
　　　Teacher t; 
　　　Student s; 
　　　//p, t and s are all non-null. 
　　　if(t instanceof Person) { 
　　　  s = (Student)t; 
　　　}

最后一句语句的结果是： ( D )
A. 将构造一个Student对象；
B. 表达式是合法的；
C. 表达式是错误的；
D. 编译时正确，但运行时错误。

给出下面代码段

 public class Test { 
	int m, n; 
	public Test() {} 
	public Test(int a) { m=a; } 
	public static void main(String arg[]) { 
		Test t1,t2; 
		int j,k; 
		j=0; k=0; 
		t1=new Test(); 
 		t2=new Test(j,k); 
 	} 
 }

哪行将引起一个编译时错误？( D )
A. line 3
B. line 5
C. line 6
D. line 10

对于下列代码：

 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(); 
 	t.printValue(10); 
 }

第10行语句将调用哪行语句？ ( D )
A. line 2
B. line 3
C. line 6
D. line 7

哪个关键字可以抛出异常？ ( C )
A. transient
B. finally
C. throw
D. static
Main()方法的返回类型是： ( B )
A. int
B. void
C. boolean
D. static
System类在哪个包中? ( D )
A. java.util
B. java.io
C. java.awt
D. java.lang
对于下列代码：

public class Parent {
    public int addValue(int a, int b) {
        int s;
        s = a + b;
        return s;
    }
}

class Child extends Parent {
}

下述哪些方法可以加入类Child? ( C )
A. int addValue( int a, int b ){// do something…}
B. public void addValue (int a, int b ){// do something…}
C. public int addValue( int a ){// do something…}
D. public int addValue( int a, int b )throws MyException {//do something…}

给出下面代码：

public class test {

    static int a[] = new a[10];

    public static void main(String args[]) {
        System.out.println(arr[10]);
    }

}

那个选项是正确的？ ( C )
A. 编译时将产生错误；
B. 编译时正确，运行时将产生错误；
C. 输出零；
D. 输出空。

下面哪些选项是正确的main方法说明？ ( B )
A. public main(String args[])
B. public static void main(String args[])
C. private static void main(String args[])
D. void main()
给定下面的代码片段：

        String str = null;
        if ((str != null) && (str.length() > 10)) {
            System.out.println("more than 10");
        } 
        else if ((str != null) & (str.length() < 5)) {
            System.out.println("less than 5");

        } 
        else {
            System.out.println("end");
        }

哪些行会导致错误？ ( C )
A. line 1
B. line 2
C. line 5
D. line 8

下面哪种注释方法能够支持javadoc命令: ( B )
A. /…/
B. /**…/
C. //
D. /…/
看下面一段程序：

class Aclass {
    void go() {
        System.out.println("Aclass");
    }
}

public class Bclass extends Aclass {
    void go(){
        System.out.println("Bclass");
    }

    public static void main(String args[]) {
        Aclass a = new Aclass();
        Aclass a1 = new Bclass();
        a.go();
        a1.go();
    }
}

以上程序运行结果是：( C)
A. Aclass
　　　 Aclass
B. Bclass
　　　 Bclass
C. Aclass
　　　 Bclass
D. Bclass
　　　 Aclass

看以下程序：

boolean a=false; 
boolean b=true; 
boolean c=(a&&b)&&(!b)； 
int result=c==false?1:2;

这段程序执行完后，c与result的值是： ( A )
A. c=false;result=1;
B. c=true;result=2;
C. c=true;result=1;
D. c=false;result=2;

指出下列程序的运行结果 ( B )

int i = 9;
switch (i) {
    default:
        System.out.println("default");
    case 0:
        System.out.println("zero");
        break;
    case 1:
        System.out.println("one");
    case 2:
        System.out.println("two");
}

A. default
B. default, zero
C. error default clause not defined
D. no output displayed那个

下面哪个单词是Java语言的关键字（ B ）
A. Float
B. this
C. string
D. unsigned
下面哪个是Java语言中正确的标识符（ C ）
A. 3com
B. import
C. that
D. this
下面哪个语句不能定义一个字符变量（ B ）
A. char c1=06477;
B. char c2=’\uface’ ;
C. char c4=0xbeef ;
D. char c3=\u0041;
下面哪个修饰符修饰的方法只能被本类中的其他方法使用（ C ）
A. protected
B. static
C. private
D. public
下面哪个是对字符串String的正确定义（ A ）
A. String s1=null;
B. String s2=’null’ ;
C. String s3=(String) ‘abc’ ;
D. String s4=(String) ‘\uface’;
下面哪条语句不能定义一个float型的变量（ B ）
A. float f1= -343 ;
B. float f2=3.14 ;
C. float f3=0x12345 ;
D. float f4=2.8F ;
给出一段程序，选择运行结果

public class sss {

    public static void main(String args[])

    {

        String s1=args[1];    String s2=args[2];

        String s3=args[3];    String s4=args[4];

        System.out.println("args[2]="+s2);

    }

}

命令行执行： java sss 1 2 3 4 结果是下面哪一个？( D )
A. args[2]=2
B. args[2]=null
C. args[2]=1
D. 运行出现异常

给出一段程序，试判断哪个是正确的结果（ B ）

public class rtExcept {

    public static void throwit() {

        System.out.print("throwit");

        throw new RuntimeException();
    }

    public static void main(String[] aa) {

        try {

            System.out.print("hello ");

            throwit();
        } catch (Exception re) {

            System.out.print("caught ");
        } finally {

            System.out.print("finally ");
        }

        System.out.print("after ");

    }

}

A. hello throwit caught
B. hello throwit caught finally after
C. hello throwit RuntimeException after
D. hello throwit caught finally after RuntimeException

对一个java源文件 aaa.java，编辑保存后但未编译，在其所在目录下执行 java aaa，则接着会出现什么（ C ）
A. error: cannot read: aaa.java
B. 无任何显示
C. Exception in thread “main” java.lang.NoClassDefFoundError: aaa
D. 程序正常执行并显示
编译java程序时出现error: cannot read: aaa.java，则下列原因最正确的是（ C ）
A. 原因是执行的当前目录下没有找到aaa.java文件。
B. 原因是没有安装JDK开发环境。
C. 原因是java源文件名后缀一定是以 .txt 结尾。
D. 原因是JDK安装后没有正确设置环境变量PATH和Classpath 。
给出一段程序，试判断哪个是正确的结果（ D ）

	public class myprogram {
	    public static void main(String args[]) {
	        try {
	            System.out.print("Hello world");
	        } finally {
	            System.out.println("Finally executing");
	        }
	    }
	}

A. 无法编译，因为没有指定异常
B. 无法编译，因为没有catch子句
C. Hello world
D. Hello world Finally executing

下面哪个是Java语言中正确的标识符（ B ）
A. 3D
B. $this
C. extends
D. implements
下面哪个范围是char型的取值范围（ C ）
A. -256 ~ 255
B. -(2^15) ~ (2^15)-1
C. ’\u0000’ ~ ‘\uffff’
D. 0~32767
下面哪个语句不能定义一个字符变量（ D ）
A. char c1=3210;
B. char c2=’\uface’ ;
C. char c4=0xabcd ;
D. char c3=”\u0065”;
下面哪个是对字符串String的正确定义（ A ）
A. String s1=”\n\t null”;
B. String s2=’null’ ;
C. String s3=(String) ‘abc’ ;
D. String s4=(String) ‘\uface’;
给出下面一段程序，选择运行结果（ D ）

	public class X {
	    public static void main(String[] args) {
	        String names[] = new String[5];
	        for (int x = 0; x < args.length; x++) 
	        	names[x] = args[x];
	        System.out.println(names[2]);
	
	    }
	}

命令行执行： java X a b 结果是下面哪一个？
A. names
B. b
C. null
D. 运行出现异常

下面哪个描述是正确的（ C ）
A. Applet程序中不需要main()方法，也不能有
B. Application程序中可以没有main()方法。
C. Applet程序中可以不定义init( )方法
D. Application程序中必须有run( )方法
下面哪项可以得到数组元素的个数，java中定义数组名为 abc，（ B ）
A. abc.length( )
B. abc.length
C. len(abc)
D. ubound(abc)
下面哪个修饰符修饰的变量是所有同一个类生成的对象共享的（ C ）
A. public
B. private
C. static
D. final
给出一段程序，试判断哪个是正确的结果（ D ）

     public class myprogram{
     	public static void main (String args[]){
        try{	
      		System.out.print(“Hello world ”); 
      	}
      	finally{
      		System.out.println(“Finally executing”); 
      	} 
     	} 
     }

A. 无法编译运行，因为没有指定异常
B. 无法编译运行，因为没有catch子句
C. Hello world
D. Hello world Finally executing

下面程序运行后的输出结果为（ D ）

	class A{
	  static int y=3; 
      void showy( ){
      	System.out.println(“y=”+y); 
      	}   
     }
	class testA{
      	public static void main(String aaa []){ 
      		A a1=new A( );
      		A.y+=1;  a1.y++;
      	  	a1.showy( );
      	}
   	}

输出结果选择：
A. y=3;
B. y=4;
C. y=5;
D. 程序运行出错

编译java程序时出现error: cannot read: aaa.java，则下列原因最正确的是（ C ）
A. 原因是执行的当前目录下没有找到aaa.java文件。
B. 原因是没有安装JDK开发环境。
C. 原因是java源文件名后缀一定是以 .txt 结尾。
D. 原因是JDK安装后没有正确设置环境变量PATH和Classpath 。
下面关于构造函数的说法不正确的是（ B ）
A. 构造函数也属于类的方法，用于创建对象的时候给成员变量赋值。
B. 构造函数不可以重载。
C. 构造函数没有返回值。
D. 构造函数一定要和类名相同。
对一个java源文件 aaa.java，编辑保存后但未编译，在其所在目录下执行 java aaa，则接着会出现什么（ C ）
A. error: cannot read: aaa.java
B. 无任何显示
C. Exception in thread “main” java.lang.NoClassDefFoundError: aaa
D|. 程序正常执行并显示
给出如下代码:

    class Test{
     　　private int m;
     　　public static void fun() {
     　　　　// some code...
     　　}
     }

如何使成员变量m 被函数fun()直接访问? ( D )
A. 将private int m 改为protected int m
B. 将private int m 改为 public int m
C. 将private int m 改为 static int m
D. 将private int m 改为 int m

下面的代码段中，执行之后i 和j 的值是什么? ( C )
int i = 1;
int j;
j = i++;
A. 1, 1
B. 1, 2
C. 2, 1
D. 2, 2
给出下面代码：

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

那个语句是正确的？ ( C )
A. 编译时将产生错误；
B. 编译时正确，运行时将产生错误；
C . 输出零；
D. 输出空。

哪个关键字可以对对象加互斥锁？ ( B )
A. transient
B. synchronized
C. serialize
D. static
给出下面代码：

	public class test{ 
　　　	static int a[] = new a[10]; 
　　　	public static void main(String args[]) { 
　　　　		System.out.println(arr[10]); 
　　　	} 
　　}

那个选项是正确的？ ( )
A. 编译时将产生错误；
B. 编译时正确，运行时将产生错误；
C. 输出零；
D. 输出空。

Java语言具有许多优点和特点，下列选项中，哪个反映了Java程序并行机制的特点(　B　)
A. 安全性　　　
B. 多线程　　　
C. 跨平台　　　
D. 可移植
下列哪个类声明是正确的(　D　)
A. abstract final class H1｛…｝
B. abstract private move()｛…｝
C. protected private number；
D. public abstract class Car｛…｝

填空题

Java基础介绍（Java概述. 编译. 注释. 类型转换. 变量. 运算符）

Java是目前最广泛的__编程语言之一。网络
Java具有简单. ___. 稳定. 与平台无关. 解释型. 多线程. 动态等特点。面向对象
JDK开发java程序需三个步骤,分别为______,编译java源程序,运行java源程序。编写源文件
Java具有简单. 面向对象. 稳定. 与平台无关. 解释型. ___. 动态等特点。多线程
编写Java程序,可以使用一个__来编写源文件。文字编辑器
把编写好的Java源文件保存起来,原文件的扩展名必须是___。java
用JDK编译Java源程序,使用的命令是__,编译源文件得到字节码文件。Javac
要编译一个文件名为Test的Java源程序,需在命令控制台窗口输入编译命令: __。 javac Test.java
Java源程序编译后生成的字节码文件扩展名为__。class
应用程序编译后生成字节码文件,由 ____解释器直接解释执行。
用JDK运行Java应用程序,使用的命令是__。Java
Java程序分为两类,即___和Java小应用程序。Java应用程序
一个Java源程序是由若干个___组成。类
执行退出(结束)程序的语句是 System.exit(0) 。
在Java程序中,用"//"符号表示单行注释,那么用 /* */ 符号表示多行注释。
在Java程序中使用注释的目的在于为程序增加说明，增强程序可读性(便于理解) 。
(有待商榷)Java应用程序中有多个类时,java命令后的类名必须是包含了___方法的那个类的名字。main
一个Java应用程序必须且只有一个类含有___方法。main
在一个Java应用程序中main方法必须被说明为_____。public static void
Java中所有程序都使用方法,应用程序以______方法开始。main
Java源文件中有多个类,但只能有一个类是____类。public
Java程序用{ }将多条语句组合在一起,语句之间必须用；隔开。
变量的数据类型转换分为自动类型转换和强制转换两种。
自动类型转换是把级别低的变量的值赋给级别高的值。
在Java中有5种算术运算符,分别为加. 减. 乘. 除以及取模。
在Java中，两个连续等号(==)是等于运算符,那么一个等号是赋值运算符。

包和访问权限

__语句作为Java源文件的第一条语句,指明该源文件定义的类所在的包。package
在java程序中,系统会自动引入java.lang这个包,因此不需要再使用___语句引入该包。import
在java程序中,为了使程序能够使用自定义的包,必须在___中指明自定义包的位置。classpath
____包是java语言的核心类库,它包含了运行java程序必不可少的系统类。Java.lang
访问权限是____变量,只能在本类中使用,不能在类外使用。私有
访问权限是___变量,不但在本类中使用,还可以在任何另外一个类中使用。共有
访问权限是___-变量,只能在本类和与本类同一个包中的其他类使用。友好

标识符和数据类型

用来标识类名. 变量名. 方法名. 类型名. 数组名. 文件名的有效字符序列称为___。标识符
Java语言规定标识符由字母. 下划线. 美元符号和数字组成,并且第一个字符不能是___。数字
____就是Java语言中已经被赋予特定意义的一些单词,不可以把这类词作为名字来用。关键字
Java的数据类型可以分为两大类: 基本数据类型和引用数据类型。
Java定义了8个基本数据类型:字节型. 短整型. 整型. 长整型. 字符型. 布尔型. 单精度型和双精度型。
使用关键字___来定义逻辑变量。boolean
使用关键字__来定义字符变量。char
Java中byte型数组在内存中的存储形式是___。补码
java中,实型变量的类型有float和______两种。double
对于boolean型变量,内存分配__位。1
对于byte型变量,内存分配__个字节。1
对于short型变量,内存分配___个字节。2
对于int型变量,内存分配___个字节。4 （32位）
对于float型变量,内存分配___个字节。4
对于double型变量,内存分配___个字节。8
对于long型变量,内存分配__个字节。8
Java中关系运算符的运算结果是___型。boolean
Java中逻辑运算符的操作元必须是____型数据。boolean
布尔型的数据不对应于任何整数值,它只有两个值true和 false

String. Integer

Java中使用java.lang包中的___类来创建一个字符串变量,因此字符串变量是类类型变量,是一个对象。String
创建一个字符串时,使用String类的___。构造方法
使用String类的___方法可以获取一个字符串的长度。length()
可以使用String类的___方法判断一个字符串的前缀是否是字符串s。public boolean startsWith(String s)
可以使用String类的___方法判断一个字符串的后缀是否是字符串s。public boolean endsWith(String s)
可以使用String类的__方法比较一字符串是否与字符串s相同。public boolean equals(String s)
可以使用java.lang包中的__类将形如“12387”的字符串转化为int型数据。Integer
可以使用java.lang包中的__类将字符串转化为long型数据。Long
可以使用String类直接调用___方法将数值转化为字符串。valueOf
Object类有一个public方法是__,一个对象通过调用该方法可以获得该对象的字符串表示。toString

继承. 多态和封装

____是一种由已有的类创建新类的机制。继承
Java中由继承而得到的类成为____,被继承的类称为父类。子类
Java中不支持____继承。多重
Java中一个类可以有__个父类。1
子类自然地继承了其父类中不是____的成员变量作为自己的成员变量。private
当子类中定义的成员变量和父类中的成员变量同名时,子类的成员变量___了父类的成员变量。隐藏
子类通过成员变量的隐藏和方法的__可以把父类的状态和行为改变为自身的状态和行为。重写
如果一个类的声明中没有使用extends关键字,这个类被系统默认为是___的子类。Object
（多态）对于重写或继承的方法,Java运行时系统根据调用方法的__的类型来选择调用哪个方法。实例
对于子类创建的一个对象,如果子类重写了父类的方法,则运行时系统调用____的方法。子类
对于子类创建的一个对象,如果子类继承了父类的方法,未重写,则运行时调用_____的方法。父类

修饰符. 关键字. 通配符

（预留关键字）Java中常量定义的修饰符是_____。const
Java中用_____修饰的成员变量和方法称为私有变量和私有方法。private
Java中用___修饰的成员变量和方法称为共有变量和共有方法。public
在类的声明中,通过使用关键字___来创建一个类的子类。extends
_____类不能创建对象,必须产生其子类,由子类创建对象。abstract
如果一个类是一个abstract类的子类,它必须具体实现___的abstract方法。父类
对于_____方法,只允许声明,而不允许实现。abstract
____类不能被继承,即不能有子类。final
如果一个方法被修饰为_____方法,则这个方法不能被重写。final
如果在子类中想使用被子类隐藏的父类的成员变量**或方法可以使用关键字____。 super
子类如果想用父类的构造方法,必须在子类的构造方法中使用,并且必须使用关键字____来表示。super
在关键字中能代表当前类或对象本身的是_______。this
类修饰符有3种,它们分别是public, abstract 和final。
用关键字 static 修饰的方法就称为类方法。
包定义时，需使用关键字 package 来实现。
要使用包中的类，必须用关键字 import 导入这些类所在的包。
当要引用包中所有的类时，类名可以用通配符 * 号代替。

控制语句

Java语言的控制语句有3种类型,即条件语句. ____. 和转移语句。循环语句
Java程序中语句执行有三种基本控制结构: 顺序. 选择和循环。
Java中有两种类型的控制语句即if和___。switch
在同一个switch语句中,case后的__必须互不相同。常量值
Java语言的控制语句有3种类型,即____. 循环语句. 和转移语句。条件语句
do-while循环和while循环的区别是_______。do-while循环体至少被执行一次
在循环体中,如果想结束本次循环可以用___语句。continue
在循环体中,如果想跳出循环,结束整个循环可以用___语句。break
Java中有3种跳转语句:break语句. continue语句和 return 语句。

对象. 方法. 抽象方法. 抽象类

对象是由一组属性和对这组属性进行操作的一组服务组成的
对象是指具体的事物,而类是指一类具有某种共性的事物。
方法声明包括方法名. 返回类型和形式参数,一个方法的标志是小括号。
抽象方法是一种仅有方法头，没有具体方法体和操作实现的方法，该方法必须在抽象类之中定义。
由类来确定具体对象的过程称为实例化。
对一类对象的抽象则是类,而类的实例化结果是对象。
抽象类不能被实例化,它不具备实际功能,只用于衍生字类。
在Java中，用关键字 abstract 来修饰一个类，则该类为抽象类。
抽象方法是只有方法声明,没有代码实现的空方法。
一个对象的生命周期包括3个阶段：创建. 使用和释放（消亡）。
面向对象的3个特性是：封装性. 继承性和多态性。
在Java中，通过对象的封装，实现了模块化和信息隐藏。

正则表达式(暂缺)

简答题

JAVA中的关键字static，final和const

static

1.static修饰变量

JAVA的局部变量，全局变量和成员变量

全局变量：JAVA中不存在全局变量这个概念
局部变量：定义在方法中，需要自己初始化，不可以被访问控制符及static修饰，可定义成final型
成员变量：定义在类中，JAVA可帮你初始化，可以被访问控制符（public）及static修饰，可定义成final型
成员变量有两种：实例变量，类变量（静态变量）
实例变量（对象变量）：没有static修饰
类变量（静态变量）：由static修饰，被类的实例公用

2.static修饰函数

JAVA的成员方法

成员方法：包括静态方法，实例方法
类方法（静态方法）：被一个类的所有实例公用
实例方法（对象方法）：属于某个对象
注：1.static方法内部不能引用非static变量。
2.static方法不能被子类重写为非static方法。
3.父类的非static方法不能被子类重写为static方法。
4.static代码块可以用static {}来完成，在类被第一次装载时执行初始化，先于静态方法和其他方法的执行。

3.static修饰内部类

没有外部类对象时，也能够访问静态内部类。

静态内部类仅能访问外部类的静态成员和方法。

4.static修饰代码块

静态代码块与非静态代码块的不同：静态代码块只在第一次new的时候执行，而非静态代码块每一次new都要执行。

JVM加载类的时候执行顺序：静态代码块---非静态代码块---主方法

static的含义：1.静态存储方式  2.作用域仅限于本文件 3.不需要实例化就可以使用

final

1.final修饰变量

final成员变量表示常量，只能被赋值一次，赋值后值不再改变。final经常和static一起使用表示常量(即static final，不用实例化)。

2.final修饰方法

final方法表示不能被子类重写，但可以被继承，如果认为一个方法的功能足够完善，子类不需要改变的话，就声明为final。final方法比非final方法要快，因为在编译的时候已经静态绑定了，不需要在运行时再动态绑定。

3.final修饰类

final类功能通常是完整的，它们不能被继承，没有子类，Java中有许多类是final的，譬如String, Interger以及其他包装类。

const

const是java中的预留关键字（java中预留关键字还有goto），现在没有作为关键字，以后的版本中可能扩展用，但现在常用于C,C++中。C中的const类似于final。

Java Object有几个方法

public class Object {

    private static native void registerNatives();
    static {
        registerNatives();
    }
    public final native Class<?> getClass();
    public native int hashCode();
    public boolean equals(Object obj) {
        return (this == obj);
    }
    protected native Object clone() throws CloneNotSupportedException;
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
    public final native void notify();
    public final native void notifyAll();
    public final native void wait(long timeout) throws InterruptedException;
    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }
    public final void wait() throws InterruptedException {
        wait(0);
    }
    protected void finalize() throws Throwable { }
    
}

java的基本数据类型有哪些，以及他们的封装类。

八种基本数据类型，int ,double ,long ,float, short,byte,character,boolean；

对应的封装类型是：Integer ,Double ,Long ,Float, Short,Byte,Character,Boolean

Switch能否用string做参数

在Java 5以前，switch(expr)中，expr只能是byte. short. char. int。从Java 5开始，Java中引入了枚举类型，expr也可以是enum类型，从Java 7开始，expr还可以是字符串（String），但是长整型（long）在目前所有的版本中都是不可以的。

equals与==的区别

==与equals的主要区别是：常用于比较原生类型，而equals()方法用于检查对象的相等性。另一个不同的点是：如果和equals()用于比较对象，当两个引用地址相同，返回true。而equals()可以返回true或者false主要取决于重写实现。最常见的一个例子，字符串的比较，不同情况和equals()返回不同的结果。equals()方法最重要的一点是，能够根据业务要求去重写，按照自定义规则去判断两个对象是否相等。重写equals()方法的时候，要注意一下hashCode是否会因为对象的属性改变而改变，否则在使用散列集合储存该对象的时候会碰到坑！！理解equals()方法的存在是很重要的。

使用==比较有两种情况：

比较基础数据类型(Java中基础数据类型包括八中：short,int,long,float,double,char,byte,boolen)：这种情况下，==比较的是他们的值是否相等。

引用间的比较：在这种情况下，比较的是他们在内存中的地址，也就是说，除非引用指向的是同一个new出来的对象，此时他们使用去比较得到true，否则，得到false。

使用equals进行比较：

equals追根溯源，是Object类中的一个方法，在该类中，equals的实现也仅仅只是比较两个对象的内存地址是否相等，但在一些子类中，如：String. Integer 等，该方法将被重写。

Object有哪些公用方法

1．clone方法

保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。

主要是JAVA里除了8种基本类型传参数是值传递，其他的类对象传参数都是引用传递，我们有时候不希望在方法里讲参数改变，这是就需要在类中复写clone方法。

2．getClass方法

final方法，获得运行时类型。

3．toString方法

该方法用得比较多，一般子类都有覆盖。

4．finalize方法

该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。

5．equals方法

该方法是非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法。

6．hashCode方法

该方法用于哈希查找，可以减少在查找中使用equals的次数，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。

一般必须满足obj1.equals(obj2)==true。可以推出obj1.hashCode()==obj2.hashCode()，但是hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。

如果不重写hashCode(),在HashSet中添加两个equals的对象，会将两个对象都加入进去。

7．wait方法

wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。

调用该方法后当前线程进入睡眠状态，直到以下事件发生。

（1）其他线程调用了该对象的notify方法。

（2）其他线程调用了该对象的notifyAll方法。

（3）其他线程调用了interrupt中断该线程。

（4）时间间隔到了。

此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。

8．notify方法

该方法唤醒在该对象上等待的某个线程。

9．notifyAll方法

该方法唤醒在该对象上等待的所有线程。

Hashcode的作用

以Java.lang.Object来理解,JVM每new一个Object,它都会将这个Object丢到一个Hash哈希表中去,这样的话,下次做Object的比较或者取这个对象的时候,它会根据对象的hashcode再从Hash表中取这个对象。这样做的目的是提高取对象的效率。具体过程是这样:

new Object(),JVM根据这个对象的Hashcode值,放入到对应的Hash表对应的Key上,如果不同的对象确产生了相同的hash值,也就是发生了Hash key相同导致冲突的情况,那么就在这个Hash key的地方产生一个链表,将所有产生相同hashcode的对象放到这个单链表上去,串在一起。
比较两个对象的时候,首先根据他们的hashcode去hash表中找他的对象,当两个对象的hashcode相同,那么就是说他们这两个对象放在Hash表中的同一个key上,那么他们一定在这个key上的链表上。那么此时就只能根据Object的equal方法来比较这个对象是否equal。当两个对象的hashcode不同的话，肯定他们不能equal.

String. StringBuffer与StringBuilder的区别

Java 平台提供了两种类型的字符串：String和StringBuffer / StringBuilder，它们可以储存和操作字符串。其中String是只读字符串，也就意味着String引用的字符串内容是不能被改变的。而StringBuffer和StringBulder类表示的字符串对象可以直接进行修改。StringBuilder是JDK1.5引入的，它和StringBuffer的方法完全相同，区别在于它是单线程环境下使用的，因为它的所有方面都没有被synchronized修饰，因此它的效率也比StringBuffer略高。

请说出作用域 public， private， protected，以及不写时的区别

回答:这四个作用域的可见范围如下表所示。
说明：如果在修饰的元素上面没有写任何访问修饰符，则表示 friendly。
作用域当前类同一包（ package）子孙类其他包（ package）
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×

接口和抽象类

接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final (这里需要说一点,既然一个变量被final修饰了,那么这个变量就是一个常量!!!变量必须初始化成常量!!!)
下面比较一下两者的语法区别：

抽象类可以有构造方法，接口中不能有构造方法。
抽象类中可以有普通成员变量，接口中没有普通成员变量!!!(注意重点在普通即非静态和变量!!!)
抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

数组有没有length()这个方法? String有没有length()这个方法

数组没有length()这个方法，有length的属性。String有length()这个方法。

编程题

定义一个长度为5的字符串数组，并初始化其初值为“open”, “door”, “the”, “open”, “name”；计算该数组中 “open”出现的次数，并倒序输出数组元素。

      public class TestDemo {
      
          public  static void main(String[] args){
              //声明并初始化数组
              String[] arr = {"open", "door", "the", "open", "name"};
              int count = 0;
              //计算该数组中 "open"出现的次数。过滤统计
               count = ((int) Arrays.stream(arr).filter(x -> x.equalsIgnoreCase("open")).count());
              System.out.println("count =" + count);
              //倒序输出数组元素
              List<String> list = Arrays.asList(arr);
              Collections.reverse(list);
              String[] arrNew = list.toArray(new String[5]);
              //打印
              Arrays.stream(arrNew).forEach(System.out::println);
        
          }
      }

定义一个抽象类AbstractTest，其中有一个公共的抽象方法printMsg()。然后定义此抽象类的一个子类DefaultTest，包括的成员变量有姓名，学号，分数，且此类中包括二个构造方法。

  abstract class AbstractTest {
          public abstract void printMsg();
      }
      
      class DefaultTest extends AbstractTest {
          /**
           * 姓名
           */
          String name;
      
          /**
           * 学号
           */
          String id;
          /**
           * 分数
           */
          int score;
      
          //接收三个参数的构造方法
          public DefaultTest(String id, String name, int score) {
              this.id = id;
              this.name = name;
              this.score = score;
          }
      
          //接收姓名和学号二个参数的构造方法
          public DefaultTest(String id, String name) {
              this.id = id;
              this.name = name;
              this.score = 0;
          }
          //实现抽象方法，方法体为打印出学生的姓名与成绩
          @Override
          public void printMsg() {
              System.out.println("抽象方法");
          }
      }

定义接口Student，该接口中有一个无参. 无返回值的方法prtMsg；定义类College，包括的私有属性有id和name，包括一个接收学生学号和姓名的构造方法，并且实现Student接口。

      interface Student{
        public abstract void prtMsg();
      }
      class College implements Student{
          //定义私有成员变量id和name，类型自定
          /**
           * id
           */
          private int id;
          /**
           * name
           */
          private String name;
          //构造方法声明和定义，接收二个参数
          public College(int id,String name){
              this.id = id;
              this.name =name;
          }
      
          /**
           * prtMsg的方法体
           */
          @Override
          public void prtMsg() {
              System.out.println(id + name);
          }
      }

类和接口

选择题

类Test1定义如下：

public  class  Test1{

  public  float  aMethod(float  a, float  b){   }		

}

将以下哪种方法插入行3是不合法的。（ B ）

A. public float aMethod（float a， float b，float c）{ }
B. public float aMethod（float c，float d）{ }
C. public int aMethod（int a， int b）{ }
D. private float aMethod（int a，int b，int c）{ }

编译并运行以下程序，以下描述哪个选项是正确的( A )。

   class  A {
  
  		protected  String  toString(){
  
  			return  super.toString();}
  
  	}

A. 行2出错，不能成功编译
B. 编译通过但运行时出错
C. 编译通过运行无异常
D. 不能成功编译，行3出错

假设Foo类有如下定义，设f是Foo类的一个实例，下列语句调用哪个是错误的？( A )

	public class Foo {	
	    int  i;
		static String  s;
		void  imethod() {   }
		static  void  smethod()  {   }

}

A. Foo.imethod();
B. f.imethod();
C. System.out.println(f.i);
D. Foo.smethod()

以下哪个接口的定义是正确的？( D )

A. interface A{ void print() { } ;}
B. abstract interface A{ void print() ;}
C. abstract interface A extends I1, I2 // I1. I2为已定义的接口{ abstract void print(){ };}
D. interface A{ void print();}

关于以下程序段，正确的说法是( C )

  String  s1=“a”+“b”;
  String  s2=new  String（s1）；
  if（s1==s2）
     System.out.println(“= =  is succeeded”);
  if (s1.equals(s2))
      System.out.println(“.equals() is succeeded”);

A．行4与行6都将执行 B．行4执行，行6不执行
C．行6执行，行4不执行 D．行4. 行6都不执行

下列哪些标识符是不合法的?（ B ）
A: _underscore
B: 5Intel
C: Intel5
D: value
对数组的定义及初始化不正确的方法是：（ B ）
A．int array[];
B．int array[8];
C．int[] array=new int[8];
D．int array[]=new int[8];
下面哪个表达式正确?（ D ）
A．float f=1.3;
B．char c=“a”;
C．byte b=257;
D．int i=10;
下面程序运行结果为：（　　D,如果输出count则为A　）

public class test3
{public static void main(String args[])
 　{ int count=0;
  　　　for (int i=0;i<=100;i++)
      　　count+=count++;
  　}
 }

A. 0 　　　　
　 B. 7 　　　　　
　 C . 编译有错误　　　　
　 D. 其他答案

下面哪个函数是public void aMethod(){…}的重载函数？（　D　）
A. void aMethod( ){…}
B. public int aMethod(){…}
C. public void aMethod ( ){…}
D. public int aMethod ( int m){…}
下面关于继承的哪些叙述是正确的? ( D )
A．在java中允许多继承。
B．在java中一个类只能实现一个接口。
C．在java中一个类不能同时继承一个类和实现一个接口。
D． java的单一继承使代码更可靠。
关于length()这个方法的表述正确的是哪个? ( C )
A．数组有length()这个方法，string也有length()这个方法。
B．数组有length()有这个方法，string没有length()这个方法。
C．数组没有length()这个方法，string有length()这个方法。
D．数组没有length()这个方法，string也没有length()这个方法。
运行下面程序段的结果是：( C )。

public class MyMain{

   public static void main(String args){

   		System.out.println(“Hello Java”);

	}
}

A．正常输出Hello Java
B．编译时出错
C．运行时出错
D. 以上答案都不对

关于以下程序段，正确的说法是( C )。

1．  String  s1=“x”+“y”;
2．  String  s2=new  String（s1）；
3．  if（s1==s2）
4．     System.out.println(“= =  is succeeded”);
5．  if (s1.equals(s2))
6．     System.out.println(“.equals() is succeeded”);

A．行4与行6都将执行
B．行4执行，行6不执行
C．行6执行，行4不执行
D．行4. 行6都不执行

类与对象的关系是( A )。
A. 类是对象的抽象
B. 类是对象的具体实例
C. 对象是类的抽象
D. 对象是类的子类
下列关于修饰符混用的说法，错误的是( D )
A. abstract不能与final并列修饰同一个类
B. abstract类中不可以有private的成员
C. abstract方法必须在abstract类中
D. static方法中能处理非static的属性
编译并运行下述程序段的结果是：( B )。

public class Test{

     public static void main(String argv[]){

      int[] count = new int[4];

      System.out.println(count[4]);
	}
}

A．编译时错误
B．运行时错误
C．输出0
D．输出null

下面是有关子类继承父类构造函数的描述，其中正确的是( B )。
A．创建子类的对象时, 先调用子类自己的构造函数，然后调用父类的构造函数。
B．子类无条件地继承父类不含参数的构造函数。
C．子类必须通过super关键字调用父类的构造函数。
D．子类无法继承父类的构造函数。
下列类的定义中，错误的是( C )。
A． class x { … }
B． public x extends y { … }
C．public class x extends y { … }
D． class x extends y implements y1 { … }
假设A类有如下定义，设a是A类的一个实例，下列语句调用哪个是错误的？（ C ）

class  A{	
	int  i;
	static  String  s;
	void  method1() {   }
	static  void  method2()  {   }

}

A. System.out.println(a.i)；
B. a.method1();
C. A.method1();
D. A.method2()

A派生出子类B ，B派生出子类C，并且在Java源代码中有如下声明：

\1.          A  a0=new  A();    
\2.          A  a1 =new  B();
\3.          A  a2=new  C();

问以下哪个说法是正确的？（ D ）
A. 只有第1行能通过编译
B. 第1. 2行能通过编译，但第3行编译出错
C. 第1. 2. 3行能通过编译，但第2. 3行运行时出错
D. 第1行. 第2行和第3行的声明都是正确的

以下哪个接口的定义是正确的？（ D ）
A. interface B{ void print() { } ;}
B. abstract interface B{ void print() ;}
C. abstract interface B extends A1,A2 //A1. A2为已定义的接口{ abstract void print(){ };}
D. interface B
{ void print();}
下面的哪个赋值语句是正确的?（ D ）
A. short myshort=99s;
B. String name=’Excellent’;
C. char c=17c;
D. int z=015;
下面哪个不是Java的保留字或关键字?（ B ）
A. default
B. NULL
C. throws
D. long
下面哪个是Math类中正确的方法?（ A ）
A. random()
B. Random()
C. square()
D. sqr()
下列哪个类声明是正确的? ( D )
A. abstract final class H1｛…｝
B. abstract private move()｛…｝
C. protected private number；
D. public abstract class Car｛…｝
方法重载是指 (A )
A.两个或两个以上的方法取相同的方法名，但形参的个数或类型不同
B.两个以上的方法取相同的名字和具有相同的参数个数，但形参的类型可以不同
C.两个以上的方法名字不同，但形参的个数或类型相同
D.两个以上的方法取相同的方法名，并且方法的返回类型相同。
下面关于java中类的说法哪个是不正确的（ C ）
A. 类体中只能有变量定义和成员方法的定义，不能有其他语句。
B. 构造函数是类中的特殊方法。
C. 类一定要声明为public的，才可以执行。
D. 一个java文件中可以有多个class定义。

填空题

类. 内部类. 匿名类

_____是组成Java程序的基本要素,封装了一类对象的状态和方法。类
Java中___是创建对象的模板。类
____是Java的关键字,用来定义类。class
通常类名可由字母. 数字. 下划线以及美元符号组成,但类名的第一个字符不能是数字。
类的实现包括两部分:类声明和___。类体
当使用一个类创建了一个___时,我们也说给出了这个类的实例。对象
Java中用类创建一个对象包括对象的声明和为对象____两个步骤。分配内存
一个类通过使用new运算符和类的____为声明的对象分配内存。构造方法
对象声明的一般格式为___。类名对象名
一个类通过使用_____运算符可以创建多个不同对象,这些对象将分配不同得内存空间。new
Java中不同对象的____变量将被分配不同的内存空间。实例
内部类是被定义于另一个类中的类。
实现事件监听器时，采用内部类. 匿名类编程非常容易实现其功能。

类的变量

类体有两部分构成:一部分是变量的定义,另一部分是_____的定义。方法
在Java中,使用变量遵守先声明后使用(先定义后使用) 的原则
Java中不用修饰的成员变量称为_____变量。友好（友好：即不被public. protected. private关键修饰的变量和方法，区别在于比public低一级用于只能在同一包下访问的变量）
在类体中,变量定义部分所定义的变量称为类的____。成员变量
成员变量在整个类内都有效,____变量只在定义他的方法内有效。局部
用修饰符_____说明的成员变量是类变量。static
Java中如果类中的成员变量是______,那所有的对象的给这样的变量分配给相同的一处内存。类变量
变量的名字与成员变量的名字相同,则成员变量被___,该成员变量在这个方法内暂时失效。隐藏
Java中成员变量又分为实例成员变量和____。类成员变量
局部变量的名字与成员变量的名字相同,若想在该方法内使用成员变量,必须使用关键字____。this

类的方法

方法定义包括两部分:____和方法体。方法声明
对象创建完后,通过使用运算符“ . ”, 对象可以实现对变量的访问和____的调用。方法
在Java中,当一个方法不需要返回数据时返回类型必须是___。void
__是指,一个类中可以有多个方法具有相同的名字和类型,但这些方法的参数必须不同。方法重载
___是一种特殊方法,它的名字必须与它所在的类的名字完全相同,并不返回任何数据类型。构造方法
java中____方法与类名相同,没有返回值,在创建对象实例时由new运算符自动调用。构造
因为类体的内容由成员变量的定义和成员方法的定义两部分组成,对成员变量的操作只能放在____中。成员方法
Java中类的方法分为____和类方法。实例方法
在类方法中只能调用类变量和类方法,不能调用___方法。实例
实例方法既能对类变量操作也能对实例变量操作,而类方法只能对___进行操作。类变量
类方法和实例方法的区别在于类方法不但可以由对象调用还可以直接由______调用,而实例方法却不可以。类名
当一个方法中有多个参数时,参数之间是用逗号隔开。
构造方法的方法名要求与类名相同,而且无返回值。
构造方法只能通过 new 运算符调用,用户不能直接调用。
一个对象的生命周期包括3个阶段：创建. 使用和释放（消亡）。

接口定义

Java中为了克服_____的缺点,Java使用了接口,一个类可以实现多个接口。单继承
使用关键字___来定义接口。interface
要在类声明中实现接口,需使用关键字 implements 。
接口定义包括接口的声明和____。接口体
定义接口时,接口体中只进行方法的声明,不允许提供方法的______。实现
一个类通过使用关键字_____声明自己使用一个或多个接口。implements

接口方法//TODO

如果一个类使用了某个接口,那么这个类必须实现该接口的______。所有方法
接口中的方法被默认的访问权限是____。public
如果接口中的方法的返回类型不是void的,那么在类中实现该接口的方法时,方法体至少要有一个_____语句。return

简答题

Java中类的方法分为类方法（用static修饰，也叫静态方法）和实例方法（没有用static修饰，也叫非静态方法），这两种方法之间有什么区别呢？

实例方法(创建对象)

当类的字节码文件加载到内存中时，类的实例方法并没有被分配入口地址，只有当该类的对象创建以后，实例方法才分配了入口地址。从而实例方法可以被类创建的所有对象调用，还有一点需要注意，当我们创建第一个类的对象时，实例方法的入口地址会完成分配，当后续在创建对象时，不会再分配新的入口地址，也可以说，该类的所有对象共享实例方法的入口地址，当该类的所有对象被销毁，入口地址才会消失。

类方法
当类的字节码文件加载到内存，类方法的入口地址就会分配完成，所以类方法不仅可以被该类的对象调用，也可以直接通过类名完成调用。类方法的入口地址只有程序退出时消失。

区别：

因为类方法的入口地址的分配要早于实例方法的入口地址分配时间，所有在定义类方法和实例方法是有以下规则需要遵循：

在类方法中不能引用实例变量
实例变量的定义类似实例方法，没有用static修饰的变量，实例变量的创建与实例方法的创建相同，也是在类的对象创建时完成，所以在类方法中是不能引用实例变量的，因为这个时候实例变量还没有分配内存地址。
在类方法中不能使用super和this关键字
这是因为super和this都指向的是父类和本类的对象，而在类方法中调用的时候，这些指代的对象有可能都还没有创建。
类方法中不能调用实例方法
原因同1。
与类方法相比，实例方法的定义就没有什么限制了：
实例方法可以引用类变量和实例变量
实例方法可以使用super和this关键字
实例方法中可以调用类方法

方法重写和重载的区别？

重写（覆盖）：在子类中定义某方法与其父类有相同的名称，返回类型和参数（有继承关系）

重载：JAVA中一个类可以有多个同名方法，参数类型或个数等可以不同。（没有继承关系）

Java面向对象的三个特征与含义

**继承：**继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类. 基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。

**封装：**通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治. 封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口（可以想想普通洗衣机和全自动洗衣机的差别，明显全自动洗衣机封装更好因此操作起来更简单；我们现在使用的智能手机也是封装得足够好的，因为几个按键就搞定了所有的事情）。

**多态：**多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当A系统访问B系统提供的服务时，B系统有多种提供服务的方式，但一切对A系统来说都是透明的（就像电动剃须刀是A系统，它的供电系统是B系统，B系统可以使用电池供电或者用交流电，甚至还有可能是太阳能，A系统只会通过B类对象调用供电的方法，但并不知道供电系统的底层实现是什么，究竟通过何种方式获得了动力）。

方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：

方法重写（子类继承父类并重写父类中已有的或抽象的方法）；
对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。

Override和Overload的含义与区别

Overload: 顾名思义，就是Over(重新)——load（加载），所以中文名称是重载。它可以表现类的多态性，可以是函数里面可以有相同的函数名但是参数名. 类型不能相同；或者说可以改变参数. 类型但是函数名字依然不变。

Override: 就是ride(重写)的意思，在子类继承父类的时候子类中可以定义某方法与其父类有相同的名称和参数，当子类在调用这一函数时自动调用子类的方法，而父类相当于被覆盖（重写）了。

方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

Interface与abstract类的区别

抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用。

一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类。

接口比抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的方法全部都是抽象方法。

抽象类中的成员可以是private. 默认. protected. public的，而接口中的成员全都是public的。

抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法。

Static class 与non static class的区别

内部静态类不需要有指向外部类的引用。但非静态内部类需要持有对外部类的引用。非静态内部类能够访问外部类的静态和非静态成员。静态类不能访问外部类的非静态成员。他只能访问外部类的静态成员。一个非静态内部类不能脱离外部类实体被创建，一个非静态内部类可以访问外部类的数据和方法，因为他就在外部类里面。

java多态的实现原理

当JVM执行Java字节码时，类型信息会存储在方法区中，为了优化对象的调用方法的速度，方法区的类型信息会增加一个指针，该指针指向一个记录该类方法的方法表，方法表中的每一个项都是对应方法的指针。

方法区：方法区和JAVA堆一样，是各个线程共享的内存区域，用于存储已被虚拟机加载的类信息. 常量. 静态变量. 即时编译器编译后的代码等数据。运行时常量池：它是方法区的一部分，Class文件中除了有类的版本. 方法. 字段等描述信息外，还有一项信息是常量池，用于存放编译器生成的各种符号引用，这部分信息在类加载时进入方法区的运行时常量池中。方法区的内存回收目标是针对常量池的回收及对类型的卸载。

方法表的构造

由于java的单继承机制，一个类只能继承一个父类，而所有的类又都继承Object类，方法表中最先存放的是Object的方法，接下来是父类的方法，最后是该类本身的方法。如果子类改写了父类的方法，那么子类和父类的那些同名的方法共享一个方法表项。

由于这样的特性，使得方法表的偏移量总是固定的，例如，对于任何类来说，其方法表的equals方法的偏移量总是一个定值，所有继承父类的子类的方法表中，其父类所定义的方法的偏移量也总是一个定值。

实例

假设Class A是Class B的子类，并且A改写了B的方法的method()，那么B来说，method方法的指针指向B的method方法入口；对于A来说，A的方法表的method项指向自身的method而非父类的。

流程：调用方法时，虚拟机通过对象引用得到方法区中类型信息的方法表的指针入口，查询类的方法表，根据实例方法的符号引用解析出该方法在方法表的偏移量，子类对象声明为父类类型时，形式上调用的是父类的方法，此时虚拟机会从实际的方法表中找到方法地址，从而定位到实际类的方法。注：所有引用为父类，但方法区的类型信息中存放的是子类的信息，所以调用的是子类的方法表。

foreach与正常for循环效率对比

直接for循环效率最高，其次是迭代器和 ForEach操作。作为语法糖，其实 ForEach 编译成字节码之后，使用的是迭代器实现的，反编译后，testForEach方法如下：

public static void testForEach(List list) {  

   for (Iterator iterator = list.iterator();iterator.hasNext();){  
        Object t = iterator.next();  
        Object obj = t;  
   }  
}

可以看到，只比迭代器遍历多了生成中间变量这一步，因为性能也略微下降了一些。

编程题

泛型（暂缺）

简答题

泛型的优缺点

优点：

使用泛型类型可以最大限度地重用代码. 保护类型的安全以及提高性能。

泛型最常见的用途是创建集合类。

缺点：

在性能上不如数组快。

泛型常用特点，List能否转为List

能，但是利用类都继承自Object，所以使用是每次调用里面的函数都要通过强制转换还原回原来的类，这样既不安全，运行速度也慢。

枚举和注解（暂缺）

方法（暂缺）

异常

选择题

在java的一个异常处理中，哪个语句块可以有多个（ A ）
A. catch
B. finally
C. try
D. throws

填空题

在Java程序中，使用关键字 throws 用于声明一个方法会抛出哪些异常，而 throw 是在方法体中实际执行抛出异常的动作。
程序运行过程中出现的非正常现象称为异常。
异常处理是一种对异常情况进行技术处理的技术。
所谓异常处理机制是对各种可能设想到的错误情况进行判断，以匹配特定的异常，并对其进行相应的处理。
在Java中，把异常分为异常情况和错误两大类。
在异常类定义中，错误是指程序本身存在非法的情形，这些情形常常是因为代码存在着问题而引起的。
Java应用程序在运行时如果出现了一个可识别的错误，就会产生一个与该错误相对应的异常类的对象，这个过程称为异常的抛出。
抛出异常的方法有两种：系统自动抛出的异常和throw抛出。
异常处理主要包括捕捉异常、程序流程的跳转和异常处理语句块的定义。
当一个异常被抛出时，有专门的语句来捕获这个被抛出的异常对象，这个过程称为异常捕获。
异常处理的方法有两种：应用try…catch…finally结构对异常进行捕捉和处理、通过throws与 throw 语句抛出异常进行处理。
异常处理过程中，一个try程序块可以对应多个catch块。
假若多个catch块有父子继承关系，则应该将子类的catch块放置到父类的catch块之前。

简答题

try catch finally，try里有return，finally还执行么

会执行，在方法返回调用者前执行。Java允许在finally中改变返回值的做法是不好的，因为如果存在finally代码块，try中的return语句不会立马返回调用者，而是纪录下返回值待finally代码块执行完毕之后再向调用者返回其值，然后如果在finally中修改了返回值，这会对程序造成很大的困扰，C#中就从语法规定不能做这样的事。

Excption与Error区别

Error表示系统级的错误和程序不必处理的异常，是恢复不是不可能但很困难的情况下的一种严重问题；比如内存溢出，不可能指望程序能处理这样的状况；Exception表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示如果程序运行正常，从不会发生的情况。

Excption与Error包结构。OOM你遇到过哪些情况，SOF你遇到过哪些情况

在这里插入图片描述
Java异常架构图

1、Throwable Throwable是 Java 语言中所有错误或异常的超类。 Throwable包含两个子类: Error 和 Exception 。它们通常用于指示发生了异常情况。 Throwable包含了其线程创建时线程执行堆栈的快照，它提供了printStackTrace()等接口用于获取堆栈跟踪数据等信息。

2、Exception Exception及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。

3、RuntimeException RuntimeException是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。编译器不会检查RuntimeException异常。例如，除数为零时，抛出ArithmeticException异常。RuntimeException是ArithmeticException的超类。当代码发生除数为零的情况时，倘若既"没有通过throws声明抛出ArithmeticException异常"，也"没有通过try…catch…处理该异常"，也能通过编译。这就是我们所说的"编译器不会检查RuntimeException异常"！如果代码会产生RuntimeException异常，则需要通过修改代码进行避免。例如，若会发生除数为零的情况，则需要通过代码避免该情况的发生！

4、Error 和Exception一样， Error也是Throwable的子类。它用于指示合理的应用程序不应该试图捕获的严重问题，大多数这样的错误都是异常条件。和RuntimeException一样，编译器也不会检查Error。

Java将可抛出(Throwable)的结构分为三种类型：被检查的异常(Checked Exception)，运行时异常(RuntimeException)和错误(Error)。

(01) 运行时异常定义 : RuntimeException及其子类都被称为运行时异常。特点 : Java编译器不会检查它。也就是说，当程序中可能出现这类异常时，倘若既"没有通过throws声明抛出它"，也"没有用try-catch语句捕获它"，还是会编译通过。例如，除数为零时产生的ArithmeticException异常，数组越界时产生的IndexOutOfBoundsException异常，fail-fail机制产生的ConcurrentModificationException异常等，都属于运行时异常。虽然Java编译器不会检查运行时异常，但是我们也可以通过throws进行声明抛出，也可以通过try-catch对它进行捕获处理。如果产生运行时异常，则需要通过修改代码来进行避免。例如，若会发生除数为零的情况，则需要通过代码避免该情况的发生！

(02) 被检查的异常定义 : Exception类本身，以及Exception的子类中除了"运行时异常"之外的其它子类都属于被检查异常。特点 : Java编译器会检查它。此类异常，要么通过throws进行声明抛出，要么通过try-catch进行捕获处理，否则不能通过编译。例如，CloneNotSupportedException就属于被检查异常。当通过clone()接口去克隆一个对象，而该对象对应的类没有实现Cloneable接口，就会抛出CloneNotSupportedException异常。被检查异常通常都是可以恢复的。

(03) 错误定义 : Error类及其子类。特点 : 和运行时异常一样，编译器也不会对错误进行检查。当资源不足、约束失败、或是其它程序无法继续运行的条件发生时，就产生错误。程序本身无法修复这些错误的。例如，VirtualMachineError就属于错误。按照Java惯例，我们是不应该是实现任何新的Error子类的！

对于上面的3种结构，我们在抛出异常或错误时，到底该哪一种？《Effective Java》中给出的建议是：对于可以恢复的条件使用被检查异常，对于程序错误使用运行时异常。