文章标题

一、输入输出流

一个文件中的字符要写入另外一个文件，首先要实例化FileInputStream，如：
FileInputStream fin = new FileInputStream(this.filename);

二、重载和重写

1.重写

（1）又称“覆盖”
（2）子类覆盖父类遵循“两同两小一大”
两同：方法名相同，形参列表相同
两小：子类的返回值类型比父类更小或想等，子类方法声明抛出的异常类要比父类方法声明抛出的异常类要小或相等。
一大：子类的访问权限应比父类访问权限更大或相等。
（3）重写要求返回值类型一致。

2.重载

形参个数、顺序或类型必须有一个方面不相同。
例1：
对于如下代码段：

class A{    public A foo(){return this;}}class B extends A{    public A foo(){        return this;    }}class C extends B{    _______}

可以放入到横线位置，使程序正确编译运行，而且不产生错误的选项是（ ）
A.public void foo(){}
B.public int foo(){return 1;}
C.public A foo(B b){return b;}
D.public A foo(){return A;}

解析：A.参数列表相同，不为重载，void返回类型与父类不同，不为重写，故而错误
B.与A相同。
C.参数列表不同，为重载，故正确。
D.语法错误。

三、&、&&、|和||的语法

&：检查false，不具备短路功能，会检查每个条件。
&&：检查false，具备短路功能，一遇到false就跳出运行，返回false
|：检查true，不具备短路功能，会检查每个条件。
||：检查true，具备短路功能，一遇到true就跳出运行，返回true。
例1：
Consider the following code:

String s=null;

Which code fragments cause an object of type NullPointerException to be thrown?
A.if((s!=null)&(s.length()>0))
B.if((s!=null)&&(s.length()>0))
C.if((s==null)|(s.length()==0))
D.if((s==null)||(s.length()==0))
解析：答案AC
A.&检查false，s!=null为false，不具备短路，接着执行下一个条件，s.length()因为String s = null，所以会抛出NullPointerException异常。
B.&&检查false，s != null为false，具备短路，不执行下一个条件，不会抛出异常。
C.|检查true，s == null为true，不具备短路，接着执行下一个条件，s.length() == 0会抛出NullPointerException异常。
D.||检查true，s == null为true，具备短路，不执行下一个条件，不会抛出异常。

选择AC

四、Java Unicode编码

编码：就是一个编号（数字）到一个字符的一种映射关系，仅仅是一种一对一的映射关系，可以理解成一个很大的对应表格。Java默认的字符集是Unicode，占两个字节byte，一个字节=8个比特位，所以每个Unicode占16个比特位。
编码格式：编码格式就是序列化或存储编码的一种格式，包括gdk和UTF-8。
例1：
java 的字符类型采用的是 Unicode 编码方案，每个 Unicode 码占用（）个比特位。
A.8
B.16
C.32
D.64
解析：B
解释可以看上文概念介绍。

五、final、static基础知识

final可用于类、方法和变量，final经常和static一起使用来声明变量，final为Java保留的关键字，一旦引用声明作final，将不能再使用该引用，编译器会检查代码，如果试图将变量再次初始化，编译器将会报错。

final变量

凡是对成员变量或者本地变量(在方法中的或者代码块中的变量称为本地变量)声明为final的都叫作final变量。final变量经常和static关键字一起使用，作为常量。下面是final变量的例子：

public static final String LOAN = "loan";LOAN = new String("loan") //invalid compilation error

final变量是只读的。

final方法

final也可以声明方法。方法前面加上final关键字，代表这个方法不可以被子类的方法重写。如果你认为一个方法的功能已经足够完整了，子类中不需要改变的话，你可以声明此方法为final。final方法比非final方法要快，因为在编译的时候已经静态绑定了，不需要在运行时再动态绑定。下面是final方法的例子：

class PersonalLoan{    public final String getName(){        return "personal loan";    }}class CheapPersonalLoan extends PersonalLoan{    @Override    public final String getName(){        return "cheap personal loan"; //compilation error: overridden method is final    }}

final类

使用final来修饰的类叫作final类。final类通常功能是完整的，它们不能被继承。Java中有许多类是final的，譬如String, Interger以及其他包装类。下面是final类的实例：

final class PersonalLoan{    }    class CheapPersonalLoan extends PersonalLoan{  //compilation error: cannot inherit from final class}

final关键字的好处

下面总结了一些使用final关键字的好处

final关键字提高了性能。JVM和Java应用都会缓存final变量。
final变量可以安全的在多线程环境下进行共享，而不需要额外的同步开销。
使用final关键字，JVM会对方法、变量及类进行优化。

静态方法

通常在一个类中定义了静态方法static，那就是说，无需该类创建的对象调用。
声明为静态方法有以下几条限制：
1.仅能调用其他static方法。
2.只能访问static数据。
3.不能引用this或super。

class Simple {    static void go() {       System.out.println("Welcome");    }}public class Cal {    public static void main(String[] args) {       Simple.go();    }}

调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。

静态变量

声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了

class Value {    static int c = 0;    static void inc() {       c++;    }}public class Count2 {    public static void prt(String s) {       System.out.print(s);    }    public static void main(String[] args) {       Value v1, v2;       v1 = new Value();       v2 = new Value();       prt("v1.c=" + v1.c + "  v2.c=" + v2.c);       v1.inc();       prt(" v1.c=" + v1.c + "  v2.c=" + v2.c);    }}

结果：v1.c=0 v2.c=0 v1.c=1 v2.c=1
由此可以证明它们共享一块存储区。static变量有点类似于C中的全局变量的概念。

静态变量的调用问题

当类加载时，static静态方法随着类加载而初始化，此时实例对象还未被创建，但是非静态成员变量需要等到实例对象创建才会被初始化，所以静态方法不能调用非静态变量
例子如下：
阅读代码，以下说法正确的是?

public class Test{    public int x;    public static void main(String []args)    {        System. out. println("Value is" + x);    }}

A.程序会打出 “Value is 0”
B.程序会抛出 NullPointerException
C.非静态变量不能够被静态方法引用
D.编译器会抛出 “possible reference before assignment”的错误
解析：C

静态变量的初始化问题

该问题涉及父子类代码执行顺序问题，详见父子类代码执行顺序问题分析。

静态类

通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。

public class StaticCls {    public static void main(String[] args) {       OuterCls.InnerCls oi = new OuterCls.InnerCls();    }}class OuterCls {    public static class InnerCls {       InnerCls() {           System.out.println("InnerCls");       }    }} 

结果为：InnerCls

static和final一块用表示什么

static final用来修饰成员变量和成员方法，可简单理解为“全局常量”（Java中没有全局变量的概念）。
对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
对于方法，表示不可覆盖，并且可以通过类名直接访问。

六、抽象类与接口

抽象类方法默认修饰符为default

七、引用类型与值类型

引用类型表示你操作的数据是同一个，也就是说当你传一个参数给另一个方法时，你在另一个方法中改变这个变量的值，那么调用这个方法是传入的变量的值也将改变.
值类型表示复制一个当前变量传给方法，当你在这个方法中改变这个变量的值时，最初生命的变量的值不会变.
通俗说法: 值类型就是现金，要用直接用；引用类型是存折，要用还得先去银行取现。—-(摘自网上)

基本数据类型常被称为四类八种

四类： 1.整型 2，浮点型 3，字符型 4，逻辑型

八种：
1.整型4种 byte，short，int，long
2.浮点型2种 float，double
3.字符型1种 char
4.逻辑型1种 boolean

引用类型

除了四类八种基本类型外，所有的类型都称为引用类型（Array也为应用类型）
例：
下面属于java引用类型的有？
A.String
B.byte
C.char
D.Array
解析：AC
解答看上文概念介绍。

值传递

基本数据类型赋值都属于值传递,值传递传递的是实实在在的变量值,是传递原参数的拷贝,值传递后，实参传递给形参的值，形参发生改变而不影响实参。

引用传递

引用类型之间赋值属于引用传递。引用传递传递的是对象的引用地址,也就是它的本身(自己最通俗的理解)。引用传递：传的是地址，就是将实参的地址传递给形参，形参改变了，实参当然被改变了，因为他们指向相同的地址。
引用和我们的指针差不多,但是它不又不需要我们去具体的操作

内存分配

一个具有值类型（value type）的数据存放在栈内的一个变量中。即是在栈中分配内存空间，直接存储所包含的值，其值就代表数据本身。值类型的数据具有较快的存取速度。

一个具有引用类型（reference type）的数据并不驻留在栈中，而是存储于堆中。即是在堆中分配内存空间，不直接存储所包含的值，而是指向所要存储的值，其值代表的是所指向的地址。当访问一个具有引用类型的数据时，需要到栈中检查变量的内容，该变量引用堆中的一个实际数据。引用类型的数据比值类型的数据具有更大的存储规模和较低的访问速度。

java 中的垃圾回收机制

当一个堆内存中的对象没有被栈内存中表示地址的值“引用”时，这个对象就被称为垃圾对象，它无法被使用但却占据着内存中的区域，好比这样：
String s = new String(“person”); s = new String(“man”); s本来是指向堆内存中值为person的对象的，但是s突然讨厌person了，它指向了堆内存中的man对象了，person就像一个孤儿一样被s遗弃了，但是person比孤儿还要惨，因为没有什么能找的到它，除了位高权重的‘垃圾回收器’，不过被当官的找到往往没什么好事，尤其是这个‘垃圾回收器’，它会豪不留情把‘垃圾’们清理走，并且无情的销毁，以便释放内存。

八、线程的使用

线程的启动方式只能通过start这种方式启动才能真正的实现多线程的效果，如果是手动调用run方法和普通方法调用没有区别
例：
以下程序的运行结果是？

A.foobar
B.barfoo
C.foobar或者barfoo都有可能
D.Bar
E.Foo
F.程序无法正常运行
解析：答案A

九、Java异常处理机制

RuntimeException

RuntimeException异常为运行时异常，由程序运行时抛出，不需要try-catch，例子：
关于异常的编程，以下描述错误的是：（ ）
A.在有除法存在的代码处，抛不抛出异常均可
B.int i=Integer.parseInt(”123a”);将产生NumberFarmatException
C.int a[]=null; a[0]=1; 将产生ArraylndexOutOfBoundsException
D.输入输出流编程中，读和写时都必须抛出IOException
解析：C
A.除数为0的异常属于ArrithmeticException，而该异常属于RuntimeException，运行可抛出，不需要try-catch。
C会抛出NullPointerException.

catch异常父子类顺序

所有异常都是Exception的子类。
比如用Exception
因为所有异常都是Exception的子类,如果你把Exception放在前边捕获,后边的catch将永远不会执行
例子：
在异常处理中，若try中的代码可能产生多种异常则可以对应多个catch语句，若catch中的参数类型有父类子类关系，此时应该将父类放在后面，子类放在前面。
A.正确
B.错误
解析：A

十、import问题

例子如下：
要导入java/awt/event下面的所有类，叙述正确的是？()
A.import java.awt.*和import java.awt.event.*都可以
B.只能是import java.awt.*
C.只能是import java.awt.event.*
D.import java.awt.*和import java.awt.event.*都不可以
解析：C