网上看到的一篇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）局部变量一定要初始化，但成员变量不要。