面试题
此处，Something类的文件名叫OtherThing.java
class Something {
public static void main(String[] something_to_do) {
System.out.println("Do something ...");
}
}
上述程序是否可以正常编译、运行？

面试排错1：
    public class Something {
        public int addOne(final int x) {
            return ++x;
// return x + 1;
        }
    }

面试排错2：
public class Something {
    public static void main(String[] args) {
        Other o = new Other();
        new Something().addOne(o);
    }
    public void addOne(final Other o) {
// o = new Other();
        o.i++;
    }
}
class Other {
    public int i;
}

面试排错3：
interface A {
    int x = 0;
}
class B {
    int x = 1;
}
class C extends B implements A {
    public void pX() {
        System.out.println(x);//编译不通过，因为编译器不知道x是A的还是B
    }
    public static void main(String[] args) {
        new C().pX();
    }
}

// 补足代码；调用两个函数，要求用匿名内部类

package com.jerry.exer1;
/**
 * @author jerry_jy
 * @create 2022-09-30 11:11
 */
interface Inter {
    void show(int a, int b);
    void func();
}
class Demo {
    public static void main(String[] args) {
        // 补足代码；调用两个函数，要求用匿名内部类
        Inter in = new Inter() {
            public void show(int a, int b) {
            }
            public void func() {
            }
        };
        in.show(4, 5);
        in.func();
    }
}

main()方法
选择题
class Test {
  public static void main(String[] args) {
    String foo = args[1];
    String bar = args[2];
    String baz = args[3];
  }
}
d:\>java Test Red Green Blue 
what is the value of baz? （G）
  A. baz has value of "" 
  B. baz has value of null 
  C. baz has value of "Red" 
  D. baz has value of "Blue" 
  E. baz has value of "Green" 
  F. the code does not compile 
  G. the program throw an exception 

接口
选择题:
1)下面关于接口的说法中不正确的是（C）。
A．接口中所有的方法都是抽象的
B．接口中所有的方法都是public访问权限
C．子接口继承父接口所用的关键字是implements
D．接口是Java中的特殊类，包含常量和抽象方法
2)Java语言接口间的继承关系是（A）。
A．单继承   B．多重继承      C．不能继承      D．不一定
3)一个类实现接口的情况是（A）。
A．一次可以实现多个接口        B．一次只能实现一个接口
C．不能实现接口            D．不一定

填空题 
1)__interface___是声明接口的关键字，可以把它看成一个特殊类。接口中的数据成员默认的修饰符是___ public static final __，接口中的成员方法默认的修饰符是__ public abstract ___。
2)如果实现某接口的类不是abstract的抽象类，则在类的定义部分必须该接口的所有抽象方法；如果实现某接口的类是abstract的抽象类，则它可以该接口所有的方法。但是对于这个抽象类任何一个非抽象的子类而言，它们父类所实现的接口中的所有抽象方法以及自身所实现接口中的抽象方法都必须有实在的。

补全代码

interface Inter {
  void show(int a, int b);
  void func();
}
class Demo {
  public static void main(String[] args) {
    // 补足代码；调用两个函数，要求用匿名内部类
    Inter in = new Inter() {
      public void show(int a, int b) {
      }
      public void func() {
      }
    };
    in.show(4, 5);
    in.func();
  }
}

abstract class 和interface 有什么区别? 

答：声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法
接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口

接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?
答案是：   接口可以继承接口。抽象类可以实现(implements)接口，
抽象类可继承实体类，但实体类必须不能是如下两种情况之一：   
1，final修饰符修饰的类是不能的
2，如果此实体类有且仅有私有的构造函数也是不能的。

是否能通过编译？
interface  A{
   int x = 0;
}
class B{
   int x =1;
}
class C extends B implements A {
   public void pX(){
      System.out.println(x);  //super.x   A.x
   }
   public static void main(String[] args) {
      new C().pX();
   }
}
答案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，
两个x都匹配（就象在同时import java.util和java.sql两个包时直接声明Date一样）。对于父类的变量,可以用super.x来明确，
而接口的属性默认隐含为 public static final.所以可以通过A.x来明确。

写出程序结果
interface A{}  
class B implements A{
public String func(){
return "func";
}
}
class Demo{
public static void main(String[] args){
A a=new B();
System.out.println(a.func());
}
}
编译失败：因为A接口中并未定义func方法。

如下代码是否可以编译通过，如果可以，运行结果是什么？
interface A{
  int x = 0;
}
class B{
  int x = 1;
}
class C extends B implements A{
  public void printX(){
    System.out.println(x);
  }
  public static void main(String[] args) {
    new C().printX();
  }
}
答案：编译错误
System.out.println(x);报错，x有歧义

内部类
选择题
public class OuterClass { 
  private double d1 = 1.0; 
    //insert code here 
} 
You need to insert an inner class declaration at line 3. Which two inner class declarations are 
valid?(Choose two.) 
A. class InnerOne{
     public static double methoda() {return d1;}
   } 
B. public class InnerOne{
     static double methoda() {return d1;}
   } 
C. private class InnerOne{
     double methoda() {return d1;}
   } 
D. static class InnerOne{
     protected double methoda() {return d1;}
   } 
E. abstract class InnerOne{
     public abstract double methoda();
   } 
说明如下：
一.静态内部类可以有静态成员，而非静态内部类则不能有静态成员。 故 A、B 错
二.静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量；return d1 出错。 
故 D 错
三.非静态内部类的非静态成员可以访问外部类的非静态变量。 故 C 正确
四.答案为C、E 

Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)
答：匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现

Static Nested Class 和 Inner Class的不同
答：Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。
Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。
注： 静态内部类（Inner Class）意味着
1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

写出程序结果
class TD {
  int y = 6;
  class Inner {
    static int y = 3;
    void show() {
      System.out.println(y);
    }
  }
}
class TC {
  public static void main(String[] args) {
    TD.Inner ti = new TD().new Inner();
    ti.show();
  }
}
编译失败，非静态内部类中不可以定义静态成员。
内部类中如果定义了静态成员，该内部类必须被静态修饰。

补足代码
interface Test {
  void func();
}
class Demo {
  public static void main(String[] args) {
    // 补足代码；(匿名内部类)
//    new Demo().show(new Test() {
//      public void func() {
//
//      }
//    });
  }
  void show(Test t) {
    t.func();
  }
}

判断题
1)内部类（可以/不可以）了解外部类
2)静态内部类用修饰。
3)外部类（可以/不可以）通过类名访问静态内部类里的静态成员（变量和方法）
4)外部类（可以/不可以）通过类名访问非静态内部类里的成员（变量和方法）
5)非静态内部类可以访问外部类的成员，也能访问外部类的成员
6)静态内部类可以访问外部类的成员，不能访问外部类的成员
7)非静态内部类（可以/不可以）用static修饰她的成员（变量和方法）

纠错体
已知有下面类的说明：
public class First {
  Privateinta;
  static int b = 5;
  public class Contents{
    public int c;
    static int d;
    public void f(){
      System.out.println(a);
      System.out.println(b);
    }
  }
  static class Titles{
    public int e;
    static int f;
    public void show(){
      System.out.println(a);
      System.out.println(b);
    }
  }
  public void getInnerClassDate(){
    System.out.println(c);//
    System.out.println(d);//
    System.out.println(e);//
    System.out.println(f);//
  }
  public static void main(String[] args) {
  }
}
1)这个类定义有问题吗？如果有请找出。
2)在main方法中如何获得两个内部类的实例对象？并且访问内部类的方法，请写出代码

抽象类与抽象方法
abstract 的method 是否可同时是static，是否可同时是native，是否可同时是synchronized？
答：都不能

抽象类和抽象方法之间的关系
定义抽象类和抽象方法的关键字是（abstract）。抽象类中（）（可以/不可以）有抽象方法，（）（可以/不可以）有普通方法（）（可以/不可以）有属性；一个类中定义了抽象方法，那这个类（）（必须/不必须）用abstract修饰，即抽象类。

判断题
abstract class Name {
   private String name;
   public abstract boolean isStupidName(String name) {}
}
这有何错误?
答案: 错。abstract method必须以分号结尾，且不带花括号。

是否可以通过编译？
abstract class Something {
   private abstract String doSomething ();
}
答案: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstract method封锁起来呢? (同理，abstract method前不能加final)。

static的使用
是否可以从一个static方法内部发出对非static方法的调用？
答：不可以,如果其中包含对象的method()；不能保证对象初始化.

编译是否通过？
public class Something {
     public static void main(String[] args) {
        Something s = new Something();
        System.out.println("s.doSomething() returns " + doSomething());
    }
    public String doSomething() {
        return "Do something ...";
    }
}
 看上去很完美。
答案: 错。看上去在main里call doSomething没有什么问题，毕竟两个methods都在同一个class里。
但仔细看，main是static的。static method不能直接call non-static methods。
可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。
同理，static method不能访问non-static instant variable。

写出程序结果  
public class Demo {
  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);
  }
}

答案：// 4

final关键字
谈谈final, finally, finalize的区别(后面异常中讲finally)
答：final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载
finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）
finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的

如下程序是否可通过编译？
public class Something {
   public int addOne(final int x) {
       return ++x;
   }
}
这个比较明显。
答案: 错。int x被修饰成final，意味着x不能在addOne method中被修改。

如下程序是否可通过编译？
public class Something {
   public static void main(String[] args) {
       Other o = new Other();
       new Something().addOne(o);
   }
   public void addOne(final Other o) {
       o.i++;
   }
}
class Other {
   public int i;
}
和上面的很相似，都是关于final的问题，这有错吗?
答案: 正确。在addOne method中，参数o被修饰成final。如果在addOne method里我们修改了o的reference
(比如: o = new Other();)，那么如同上例这题也是错的。但这里修改的是o的member vairable
(成员变量)，而o的reference并没有改变。

是否可以通过编译？
class Something {
    int i;
    public void doSomething() {
        System.out.println("i = " + i);
    }
} 
答案: 正确。输出的是"i = 0"。int i属於instant variable (实例变量，或叫成员变量)。instant variable有default value。
int的default value是0。

是否可以通过编译？
接上题
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;"。

代码块
以下代码的运行结果是？
public class Test {
  static int x, y, z;
  static {
    int x = 5;
    x--;
  }
  static {
    x--;
  }
  public static void main(String[] args) {
    System.out.println("x=" + x);
    z--;
    method();
    System.out.println("result:" + (z + y + ++z));
  }
  public static void method() {
    y = z++ + ++z;
  }
}
答案：
x=-1
result:3