一.题型结构及分值

1. 选择题 (15*2)
2. 判断题 (10*1)
3. 阅读程序题 (3*5+2*10)
4. 程序设计题 (1*5+2*10)

二.考试范围
Java教材的第1章 到 第8章，包括：
□ Java语言的基本特点，以及Java虚拟机。
□ Java基本语法（数据类型，运算符，控制语句）
□ Java面向对象编程，包括多态、访问和非访问修饰符、抽象类、接口和包，会使用它们进行编程。
□ Java I/O编程，会使用这些I/O类，包括：System I/O类，FileInputStream/FileOutputStream类，FileReader/FileWriter类，
   File类。

□ Java异常处理，会使用try-catch-finally语句块捕获常见的异常。如，算术异常（ArithmeticException），
    数组下标越界异常（ArrayIndexOutOfBoundsException），
    文件未找到异常（FileNotFound），
    I/O异常（IOException），
    中断异常（InterruptedException），
    SQL异常（SQLException），
    以及顶级异常（Exception）。

三. 例题
（1）编程概念题

2. pubpc class Something {
   void doSomething () {
       private String s = "";
       int l = s.length();
     }
}
有错吗?

• 答案: 错。局部变量前不能放置任何访问修饰符 (private，pubpc，和protected)。final可以用来修饰局部变量
(final如同abstract和strictfp，都是非访问修饰符，strictfp只能修饰class和method而非variable)。

3. abstract class Something {
   private abstract String doSomething();
}

• 这好像没什么错吧?

• 答案: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstract
method封锁起来呢? (同理，abstract method前不能加final)。

4. pubpc class Something {
   pubpc int addOne(final int x) {
       return ++x;
   }
}

有错吗？
5. class Something {
    final int i;
    pubpc void doSomething() {
        System.out.println(“i = ” + i);
    }
}

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

6. pubpc class Something {
     pubpc static void main(String[] args) {
        Something s = new Something();
        System.out.println(“return ” + doSomething());
    }
    pubpc String doSomething() {
        return “Do something ...”;
    }
}

• 看上去很完美？

• 答案: 错。看上去在main里调用doSomething没有什么问题，毕竟两个methods都在同一个class里。但仔细看，main是static的。static method不能直接call non-static methods。可改成“System.out.println(”return “ + s.doSomething());”。同理，static method不能直接访问non-static instantce variable。

7. 如果Something类的文件名叫OtherThing.java
class Something {
    private static void main(String[] things) {     
        System.out.println(“Do something ...”);
    }
}

在源文件命名上有问题吗？

• 答案: 正确。一般不要求Java的Class名字必须和其文件名相同，一个例外就是pubpc class的名字必须和文件名相同。

8. interface  A{
   int x = 0;
}
class B{
   int x =1;
}
class C extends B implements A {
   pubpc void pX(){
      System.out.println(x);
   }
   pubpc static void main(String[] args) {
      new C().pX();
   }
}

程序能正常运行吗？

• 答案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，两个x都匹配。对于父类的变量,可以用super.x来明确，而接口的属性默认隐含为 pubpc static final，所以可以通过A.x来明确。

9. interface Playable {
    void play();
}

• interface Bounceable {
    void play();
}

• interface Rollable extends Playable, Bounceable {
    Ball ball = new Ball("PingPang");
}

• class Ball implements Rollable {
    private String name;
    pubpc String getName() {
        return name;
    }
    pubpc Ball(String name) {
        this.name = name;       
    }
   pubpc void play() {
        ball = new Ball(“Football”);
        System.out.println(ball.getName());
    }
}    上述代码有问题吗？

• 答案: 错。
• 问题出在interface Rollable里的语句：Ball ball = new Ball(“PingPang”);
   实际上，该变量ball默认为pubpc static final修饰。
   但是，在Ball类的Play()方法中，语句ball = new Ball("Football");
   改变了ball的引用，这与final类型的object是不能被改变引用相冲突！因此编译器将在ball = new Ball(”Football“); 显示有错。

10.继承时候类的执行顺序，问将会输出什么?
package test;    ///父类
pubpc class  FatherClass {
    pubpc FatherClass()   {
 System.out.println("FatherClass Create");
 }
}

• 
package test;     //子类
import test.FatherClass;
pubpc class  ChildClass extends FatherClass  {
    pubpc ChildClass()  {
  System.out.println("ChildClass Create");
 }
 pubpc static void main(String[] args)   {
  FatherClass fc = new FatherClass();
  ChildClass cc = new ChildClass();
 }
}

• 输出结果：
FatherClass Create
FatherClass Create
ChildClass Create

（2）基础概念题

11. 在java中，语句:
  int score[3 ]={2,3,4};

正确吗？

12. java语句：
   String p1=“This is a string”;
   String p2=“This is a string”;
可以用语句：
 if(p1==p2) 判断两个字符串的内容相等吗？

13. java线程有哪几种状态？

14. FileInputStream类可以用来处理字符数据吗？

15. IOException异常一定要捕获吗？

16. Applet类需要编写main方法吗？

17.作用域pubpc，private，protected，以及default时的区别。
答：区别如下：
作用域       当前类 同一包  不同包的子类  不同包的非子类
pubpc             √      √                 √            √
protected       √      √                 √            ×
default       √      √                  ×      ×   
private            √      ×                 ×           ×

不写时默认为default。

18. &和&&的区别
答：就运算符“&”而言，要看参与该运算的变量的类型来决定是位运算还是逻辑全与运算！
   当变量是逻辑类型时，执行逻辑全与运算符，否则执行位与运算；运算符“&&”是逻辑短路与运算符。

19. 语句
•  short s1 = 1; s1 = s1 + 1;有什么错？

•  short s1 = 1; s1 += 1;有什么错？

答：short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）short s1 = 1; s1 += 1;（可以正确编译）

20. Overload和Override的区别。Overload方法是否可以改变返回值的类型？

• 答：方法的重写Override和重载Overload是Java多态性的不同表现。重写Override是父类与子类之间多态性的一种表现，重载Overload是一个类中多态性的一种表现。
• 如果在子类中定义某方法与其父类有相同的名称和参数（包括返回值），就说该方法被重写 (Override)。子类的对象使用这个方法时，将调用子类中的定义。
• 如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overload)。Overload方法是可以改变返回值的类型。

21. abstract class和interface有什么区别？

• 答：
• 声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。
• 不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。

• 接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。
   接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即由程序体给出）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态绑定将生效。

22. abstract的method是否可同时是static，是否可同时是native，是否可同时是synchronized？
答：都不能。
 

23. try { }里有一个return语句，那么紧跟在这个try后的finally { }里的code会不会被执行？什么时候被执行？在return前还是后？

24. char型变量中能不能存储一个中文汉字?为什么?
答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占2个字节，所以放一个中文是没问题的。

25. float型float f=3.4是否正确?
答:不正确。精度不准确,应该用强制类型转换，如下所示：
   float f=(float)3.4;
或者
   float f= 3.4f;

26. STRING与STRINGBUFFER的区别
答：STRING的长度是不可变的，STRINGBUFFER的长度是可变的。如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法。

27. String是最基本的数据类型吗？
答：基本数据类型包括byte、int、char、long、float、double、boolean和short。
而java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类。

28. int 和 Integer 有什么区别
答：Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。
原始类型封装类, boolean- Boolean，char- Character，byte- Byte，short- Short，int- Integer，long- Long，float- Float，double- Double。

29. java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？
答：字节流，字符流。字节流继承于InputStream、OutputStream，字符流继承于Reader、Writer。在java.io包中还有许多其他的流，主要是为了提高性能和使用方便。

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

31. 说出一些常用的类、包，请各列举5个。
答：常用的类：BufferedReader  BufferedWriter  FileReader  FileWirter  String  Integer
常用的包：java.lang  java.awt  java.io  java.util        java.sql java.net

– 当一个重载方法被调用时，Java 用参数的类型和（或）数量来表明实际调用的重载方法的版本。因此，每个重载方法的参数的类型和（或）数量必须是不同的。虽然每个重载方法可以有不同的返回类型，但返回类型并不足以区分所使用的是哪个方法。当Java 调用一个重载方法时，参数与调用参数匹配的方法被执行。
• 编辑本段|回到顶部例子说明与解析
• 编辑本段|回到顶部构造函数重载
–       【介绍定义】
–          在Java 中，同一个类中的2个或2个以上的方法可以有同一个名字，只要它们的参数声明不同即可。在这种情况下，该方法就被称为重载（overloaded ），这个过程称为方法重载（method overloading ）。方法重载是Java 实现多态性的一种方式。如果你以前从来没有使用过一种允许方法重载的语言，这个概念最初可能有点奇怪。但是你将看到，方法重载是Java 最激动人心和最有用的特性之一。
–         【参数类型说明】 
–     当一个重载方法被调用时，Java 用参数的类型和（或）数量来表明实际调用的重载方法的版本。因此，每个重载方法的参数的类型和（或）数量必须是不同的。虽然每个重载方法可以有不同的返回类型，但返回类型并不足以区分所使用的是哪个方法。当Java 调用一个重载方法时，参数与调用参数匹配的方法被执行。
–        【例子说明及解析】
– 下面是一个说明方法重载的简单例子：
– // Demonstrate method overloading.
class OverloadDemo {
void test() {
System.out.println("No parameters");
}

– // Overload test for one integer parameter.
void test(int a) {
System.out.println("a: " + a);
}

– // Overload test for two integer parameters. void test(int a，int b) { System.out.println("a and b: " + a + " " + b);}
– // overload test for a double parameter
– double test(double a) {
– System.out.println("double a: " + a);
– return a*a; }}
– class Overload {
– pubpc static void main(String args[]) {
OverloadDemo ob = new OverloadDemo();
double result;

– // call all versions of test()ob.test();ob.test(10);ob.test(10，20);result = ob.test(123.25);System.out.println("Result of ob.test(123.25): " + result);
– }
}

– 该程序产生如下输出：
– No parameters
– a: 10
a and b: 10 20
double a: 123.25
Result of ob.test(123.25): 15190.5625

– 从上述程序可见，test()被重载了四次。第一个版本没有参数，第二个版本有一个整型参数，第三个版本有两个整型参数，第四个版本有一个double 型参数。由于重载不受方法的返回类型的影响，test()第四个版本也返回了一个和重载没有因果关系的值。

TAG: JavaJAVAjava