网上看到的一篇java语法笔试题总结，总结的很好

转载地址：http://wenku.baidu.com/view/f1ffc97101f69e31433294fd.html

作者：outpainfo

相比总结一。后面加了一些，都是我笔试过来认为最重要的

1

class Something {

final int i;

public void doSomething() {

System.out.println("i = " + i);

}

}

和上面一题只有一个地方不同，就是多了一个final。这难道就错了吗?

答案: 错。final int i是个final的instant variable (实例变量，或叫成员变量)。final的instant variable没有default value，必须在constructor(构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。

2

此处，Something类的文件名叫OtherThing.java

class Something {

private static void main(String[] something_to_do) {

System.out.println("Do something ...");

}

}

这个好像很明显。

答案: 正确。从来没有人说过Java的Class名字必须和其文件名相同。但public class的名字必须和文件名相同。

3、

java myprog good morning

public class myprog{

public static void main(String argv[])

{

System.out.println(argv[2])

}

}

4) Exception raised:"java.lang.ArrayIndexOutOfBoundsException: 2"

4

7. String s1=new String("Hello")

String s2=new String("there");

String s3=new String();

下面哪条是正确的。 1是对的输出：hellothere

1) s3=s1 + s2; 2) s3=s1-s2; 3) s3=s1 &s2; 4) s3=s1 && s2；

5

12. public int bbb(){

static int i=0; // error

i++;

return i;

}

常量，静态变量不能在方法中定义,切记切记

6

14. public class Test {

public static void main(String[] args) {

String s ;

Test test = new Test();

test.f(s); //error

}

public void f(String s){

s="1223";

System.out.println(s);

}

}

error: The local variable s may not havebeen initialized

即使初始化了输出为： 1223

7

class CtorBase {

CtorBase(int k) {System.out.println("Base Created");}

}

public class Complex extends CtorBase {

Complex(int k) {System.out.println("Complex Created");}　　 //error

public static void main(String args[]) {

Complex a = new Complex(10);

}

}

error: Implicit super constructorCtorBase() is undefined. Must explicitly invoke another constructor

Rule1：编译器总是确保类至少有一个构造函数；如果类没有构造函数，编译器会为它构造一个无参的构造函数。Rule2：如果类已经有了一个构造函数，不管它是有参函数还是无参函数，编译器都不会再为它构造一个构造函数。

　　在这过程中，编译器会去调用其父类的无参构造函数，如果其父类没有默认（无参）的构造函数，则构造过程出错，编译不能通过。

8

下面哪个声明是合法的

1) int abc-xy; 2)int 8xe; 3)int abc xyz; 4)int x = 0;float f = 2.3;

4是合法的，其它的都是不合法的。

9

public class javaTest {

public static void main(String[] args) {

floata = 14.7;

floatb = 3f;

floatc = 4.1f;

System.out.println(a+""+b+" "+c);

}

}

编译出错：float a = 14.7;14.7是double不能把它转换成float;

10

public class javaTest {

public static void main(String[] args) {

finalint i = 1;

i= 1;

//System.out.println(i);

}

} 编译出错：无法为常量指定值。

11

public class javaTest {

public static void main(String[] args) {

bytea = 1;

byteb = 2;

bytec = a + b; //error

byted = 1+2;

bytee = 2+a; //error

inti = 2L+3; //error

}

}

编译错误：a+b （2+a）为int ，要不能转化为byte精度损失。 但byte d = 1+2;因为 1 2 是整数，不是整数变量。

注：整数变量的运算结果至少是int类型。

如果有一个整数变量是long类型，那么运算结果是long类型。

浮点数运算的类型是最大的浮点数类型。

12

public class javaTest {

public static void main(String[] args) {

intn = 3;

intm = 4;

System.out.println("compareresult is "+((n>m)&&(++n)>m));

System.out.println(n)

}

}

输出为compare result isfalse

3

n为3而不是4.因为n>m为false ，因此整个表达式为false，程序不再计算（++n）>m.

13

class A {

inti = 1;

voidfunc(){

System.out.println("funin a");}

}

public class B1 extends A {

inti = 2;

voidfunc(){

System.out.println("funin b");

}

publicstatic void main(String args[]){

B1b = new B1();

Aa = new A();

b.func();

a.func();

System.out.println("b.i="+b.i);

System.out.println("a.i="+a.i);

Ax = new B1();

x.func();

System.out.println("x.i="+x.i);

}

}

记住：“域是什么”在编译时确定的，“方法是什么”是在运行时确定的。

编程程序只进行“字面”上的检查所以编译时，它认为x.i是父类A的域，因为x的类型是A。

14

class A {

inti = 1;

}

public class B1 extends A {

inti = 2;

voidfunc(){

System.out.println("funin b");

}

publicstatic void main(String args[]){

Ax = new B1();

x.func();

System.out.println("x.i="+x.i);

}

}

这个程序编译时会出错是，x.func()因为编译时检查类A中没有此方法。所以编译错误。。

15

package mypack.lib2;

public class TestExtend {

int x;

public static void main(String[] args){

int i,j,k,l=0;

k = l++;

j=++k;

i = j++;

System.out.println(i+" "+j+" "+k);

}

}

输出为I ,j k 分别为1 2 1。

总结i++,++i.

I++是先不加前赋值给左边的，++i是先加完再赋值给左边的，运行完i++的值还是会加的。I=i++;这个i的值没有加。

16>

int x = 0,y = 1,z;

if(x)

z= 0;

不能编译成功，因为if只能赋值为boolean.

17>

public class TestExtend {

int x;

public static void main(String[] args){

boolean a = false;

if(a=true)

System.out.println("helloe");

else

System.out.println("GOOLDA");

}

}

输出为helloe。。a=true是赋值，不是a==true这是判断。注意区别

17

public class TestExtend {

int x;

public static void main(String[] args){

boolean flag = true;

switch(flag){

case true:System.out.println("true");

}

}

}

编译错误

Switch 里的不能为boolean类型。

18》

public class TestExtend {

public static void main(String[] args){

int m = 0,j;

while(m++<2)

System.out.println(m);

}

}

输出为 12

局部变量要初始化才能输出，否则编译错误。

19。

不能在静态的方法中使用super 和 this 关键字。。切记

20

方法的重写Overriding和重载Overloading是Java多态性的不同表现。

注意，Java的方法重载要求同名的方法必须有不同的参数表，仅有返回类型不同是不足以区分两个重载的方法。

class Test{

void show(){

System.out.println("test");

}

}

public class TestExtend extends Test{

static show(){

System.out.pritln("");

}

public static void main(String[] args){

new TestExtend();

}

编译错误，无法覆盖。要完全一样。或者参数不一样。就不是重写了。都可以编译通过。

21

public class TestExtend {

public static void main(String[] args){

String test= "abc";

test= test+test;

System.out.println(test);

}

}

输出为abcabc

22

类的继承关系中,其中 parent代表父类，son代表子类。

Parent = son; 但是parent不能强制转化为son，如果强制转化，可以骗过编译器，但执行时会出错。

23

Static final可以在静态区中初始化。但不能在构造方法中初始化。

1>

访问控制：

Public : 对于public描述符，你只需要记住一条，你在哪都可以访问。

Private: private描述符表示该成员只能在该类的内部使用，我们需要重点理解的是“在该类的内部”，意思是只要是在定义该成员的类的内部(类的内部是一个空间范围名词，只要是在{}之间的代码都算作是在类的内部).

Protected 无访问控制：至于protected描述符和package-private，则只要是在该类所在包内部，也可以随便使用。

注：比package-private作用范围更强一点，protected描述符修饰的字段还能够被其他包中它的子类所访问，一定要注意在“类的内部被访问”和“被类使用”的区别，被其他包中它的子类使用，表明该成员只能被子类使用，而不是在该子类中使用，而一旦继承，父类也不能访问自己的protected成员.

方法：在重置方法时，子类的方法不能比超类的方法存取范围小。

2

Final 修饰的变量一定要初始化，当然可以在构造方法初始化，但不能在方法内初始化。

但是如果常量是静态的，那么就不能在构造方法中初始化，必须在定义它的时候初始化或者在静态块中初始化。

3

Abstract 类里面也可能有main函数，而且可以运行。

实现接口的类必须在类中给出接口中所有的方法定义，因为接口中的方法都是public，所以，必须在实现方法时加上public关键字

抽象类可以实现接口，可以实现也可以不实现其中的方法。

异常：

（1）除o会抛出异常，但浮点数除零，那么就不会产生异常了。

（2）局部变量一定要初始化，但成员变量不要。