第 1 章 Java入门
第 2 章 Java基础
第 2 章 Java基础（2）
- 1. a[0].length
- 2.错题
第 4 章类与对象第一单元
第 4 章类与对象第二单元
第 5 章子类与继承第一单元
第 5 章子类与继承第二单元
- 1.[编程题] 困难（100分）
第 6 章接口与继承
- 1.访问权限
- 2.错题
第 7 章内部类与异常类
- 1.错题

第 1 章 Java入门

1.如何分辨主类

类的名字和文件名一致，并且包含main函数的类，叫做主类

2.关于类的public修饰符

1 .如果文件中只有一个类，文件名必须与类名一致，有没有public修饰都可以

2 .一个Java文件中最多只能有一个public类

3 .如果文件中不止一个类，而且有public类，文件名必须与public类名一致

例如：

public class Cat {
     public void cry() {
        System.out.println("maiomaio");
       }
}
class E {
   public static void main(String args[]) {
       System.out.println("ok");
   }
}

源文件的名字必须是Cat.java

4 .如果文件中不止一个类，而且没有public类，文件名可与任一类名一致。

3.main方法返回值类型

这个main()方法的声明为：

public static void main(String args[])

必须这么定义，这是Java的规范。

为什么要这么定义，和JVM的运行有关系。

当一个类中有main()方法，执行命令“java 类名”则会启动虚拟机执行该类中的main方法。

由于JVM在运行这个Java应用程序的时候，首先会调用main方法，调用时不实例化这个类的对象，而是通过类名直接调用因此需要是限制为public static。

对于java中的main方法，jvm有限制，不能有返回值，因此返回值类型为void。

4.代码风格

(1)独行风格（Allmans风格）

当代码量较小时适合使用“独行”风格，代码布局清晰，可读性强

class Allmans
{
    public static void main(String args[])
    {
        int sum=0,i=0,j=0;
        for(i=1;i<=100;i++)
        {
            sum=sum+i;
        }
        System.out.println(sum);
    }
}

(2)行尾风格（Kernighan风格）

当代码量较大时使用“独行”风格将导致代码的左半部分出现大量的左、右大括号，导致代码清晰度下降

class Kernighan {
    public static void main(String args[]) {
        int sum=0,i=0,j=0;
        for(i=1;i<=100;i++) {
            sum=sum+i;
        }
        System.out.println(sum);
    }
}

5.开发步骤

1) 编写源文件:扩展名必须是 .java。

2) 编译Java源程序:用Java编译器（javac.exe）编译源文件，得到字节码文件。

3) 运行Java程序:使用Java解释器（java.exe）来解释执行字节码文件。

6.错题

7 . [单选题]容易（3分）

下列哪个叙述是正确的?

A. 源文件名字必须是java

B. 如果源文件中有多个类，这些类可以都不是public类

C. 如果源文件中只有一个类，这个类必须是public类

D. 如果源文件中只有一个类，这个类必须是主类

答案： C. 如果源文件中只有一个类，这个类必须是public类

25 . [判断题]容易（2分）

出现如图1_4的错误提示，说明程序中语句要求的分号不正确：

编辑源文件时，是在非英文输入法状态下输入的分号，而不是英文输入法下输入的分号

D: \00> javac Hello.java

Hello.java:8: 错误: 非法字符:’\uff1b'

        System. out. println("你好")；

1个错误

D: \00>

答案： 正确

28 . [判断题]普通（2分）

下列源文件People.java中People是主类

class Hello {
    public void speak() {
        System.out.println("wangwang");
    }
}
public class People {
    public void main(String args[]) {
        System.out.println("你好");
    }
}

答案： 错误

分析：

public void main(String args[])

中少了static，正确代码如下：

public static void main(String args[])

第 2 章 Java基础

1.关键字

(1)小写

用来标识类名、变量名、方法名、类型名、数组名、文件名的有效字符序列称为标识符

简单地说，标识符就是一个名字。

Java语言规定标识符不能是关键字

关键字都是小写的

(2)implements(执行)

implements是在java程序中一个类实现接口类时用的关键字。

Object implements Object 如java 中定义的接口Animal ,实现接口的类定义如下：

public class Tiger implements Animal{

}

(3)import

C/C++ 的 #include会把所包含的内容在编译时添加到程序文件中，而java的import则不同。

Java 对象名称分为包（package）名和类（class）名两部分

package名称就像是我们的姓，而class名称就像是我们的名字。

比如说java.lang.String，就指明了String类是属于java.lang这个包的。

可是现在问题来了，有的包名非常的长，使用某些类的时候就要写一大串的代码，看起来非常不简洁也降低开发效率，于是Sun公司就引入了import。

在Java文件开头的地方使用import 导入某些类，java文件开头的地方，先说明会用到那些类别。

接着我们就能在代码中只用类名指定某个类，无需写包名。

2.变量类型占用内存

(1)整数类型:

byte型变量，内存分配给1个字节（byte）,占8位 (-128~127)

short型变量，内存分配给2个字节（byte）,占16位

int型变量，内存分配给4个字节（byte）,占32位

long型变量，内存分配给8个字节（byte）,占64位

(2)浮点类型:

float型变量，内存分配给4个字节（byte）,占32位

double型变量，内存分配给6个字节（byte）,占64位

(3)字符类型

char型变量，内存分配给2个字节（byte）,占16位

(4)布尔类型

boolean型变量，占1位

3.float常量后缀

float常量后面必须要有后缀f或F

浮点类型默认是double

所以float a = 1.19;这样是错的，不能从double转换成float

4.Unicode码范围(十六进制)

char类型的范围用Unicode来表示是从\u0000——\uFFFF，可以识别65536个字符

5.unsigned

在C/C++中char型等价于整型数据，占一个字节，8个比特位。在语言中默认的就是signed char ，其范围

对应整数-128~+127，而unsigned char代表的是无符号的字符型，对应的整数范围为0~255.

unsigned在Java 中不是关键字

跟 C 语言不同，Java 中没有 unsigned 类型，这点可能让很多人都有过困扰。

那如果碰到确实需要用到 unsigned 类型的情况怎么办呢？通常的办法就是用更大一号的类型来处理，

数组属于引用型变量，两个相同类型的数组如果具有相同的引用，它们就有完全相同的元素。

数组属于引用型变量，因此两个相同类型的数组如果具有相同的引用，它们就有完全相同的元素。例如，对于

int a[] = {1,2,3},b[]={4,5};

a=b;

那么，a的元素就和b的元素相同，

a[]=b[]={4.5};

6.错题

1 . [多选题]容易（2分）

哪些叙述是正确的?(多选)

A. int [] a,b[];是声明了1个int型一维数组a和1个int型二维数组b。

B. float a[20];是正确的数组声明。

C. boolean yes = false;是正确的boolean变量声明。

D. 1e2和2.05E2都是double型常量。

答案： ACD

分析：

A.嵌套二维数组

C.yes不是关键字

D.默认double类型

13 . [单选题]容易（2分）

下列哪项是Java语言规定的关键字？

A. NULL

B. sizeof

C. friend

D. extends

答案： D

16 . [单选题]容易（2分）

下列哪项是Java语言规定的关键字？

A. run

B. import

C. Int

D. implement

答案： B

分析：

B.在Java文件开头的地方使用import 导入某些类

D. 应该是implements

26 . [单选题]容易（2分）

下列哪项字符序列可以作为标识符？

A. true

B. default

C. _int

D. good-class

答案： C

分析：
A. 标识符不能是true、false和null（尽管true、false和null不是关键字）
D. 标识符由字母、下划线、美元符号和数字组成，长度不受限制

45 . [判断题]容易（2分）

1e2是int型常量。

正确错误

答案： 错误
分析：1e2是double型常量

46 . [判断题]普通（2分）

1e是10的1次幂（1次方）。

正确错误

答案： 错误
分析：单独的1e是非法的。

后面有整数。比如1e-5 1e10这样的。科学计数法表示的浮点数，double类型。

47 . [判断题]容易（2分）

e1是10的1次幂（1次方）。

正确错误

答案： 错误
分析：e大小写都可以，需要注意的是e前面必须有一个数字，不然的话就非法表达

第 2 章 Java基础（2）

1. a[0].length

对于 int [][] a ={{1,2,3},

                  {4,5,6,7}};a[0].length的值是3，a[1].length的值是4.

2.错题

1 . [单选题]普通（3分）

哪个叙述是错误的?

A. int [] a,b[];是声明了1个int型一维数组a和1个int型二维数组b。

B. float a[20];是正确的数组声明。

C. boolean yes = false;是正确的boolean变量声明。

D. 1e2和2.05E2都是double型常量。

答案： B

分析：

A. int [] a;

int [] b[];

2. [单选题]普通（3分）

哪个叙述是错误的?

A. System是关键字。

B. _class可以作为标识符。

C. char型字符在Unicode表中的位置范围是0至65535。

D. 对于int a[] = new int[3];a.length的值是3。

答案： A

分析：

A.System不是java关键字，只是java.lang包里提供了这个类，我们也可以自己创建类名为System。

3. [单选题]普通（3分）

下列哪项字符序列可以是标识符？

A. true

B. default

C. _int

D. good-class

答案： C

分析：

6. [单选题]普通（3分）

以下哪一项是正确的char型变量的声明？

A. char ch = “R”;

B. char ch = ‘\‘

C. char ch = ‘ABCD’;

D. char ch = “ABCD”;

答案： B

分析：char用单引号

第 4 章类与对象第一单元

1.默认值

(1)成员变量有默认值

class E {
  int  x;
  long y;
}

(2)在类中不能对成员变量直接赋值

class E {
  int  x;
  long y;
  y=1;//错误
}

成员变量属于对象，对它的赋值只能由对象来操作，在类中单独对其赋值，会报错。

(3)局部变量没有默认值

局部变量没有默认值，因此在使用局部变量之前，必须保证局部变量有具体的值

class InitError {
   int x = 10,y;      //y的默认值是0
    void f() {
       int m;         //m没有默认值，但编译无错误
       x = y+m;    //无法通过编译，因为在使用m之前未指定m的值
    }
}

2.static静态变量

在声明成员变量时，用关键字static给予修饰的称作类变量，否则称作实例变量

（类变量也称为static变量，静态变量）

3.静态成员函数

静态成员函数不能访问非静态成员函数和非静态数据成员

(静态函数只能能访问静态)

非静态成员函数可以任意地访问静态成员函数和静态数据成员

1、static成员的所有者是类本身和对象，但是多有对象拥有一样的静态成员。从而在定义对象是不能通过构造函数对其进行初始化。

2、静态成员不能在类定义里边初始化，只能在class body外初始化。

4.new对象

1.为成员变量分配内存，并指定默认值。

2.初始化成员变量，即用户声明成员变量时给定的默认值。

3.执行构造方法。

4.计算出一个引用值。

5.protected修饰成员变量或方法

访问限制修饰符有private、protected和public，都是Java的关键字，用来修饰成员变量或方法

6.private修饰成员变量或方法

private修饰的成员变量和方法称为私有变量和私有方法
对于私有成员变量或方法，只有在本类中创建该类的对象时，这个对象才能访问自己的私有成员变量和类中的私有方法
类的内部方法调用private方法

7.错题

9. [单选题]容易（3分）

下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？

class E {
  int  x;
  long y = x          //【1】
  y = x;              //【2】
  public void f(int n) {
     int m = 0;         //【3】 
     int t = n+m;      //【4】   
  } 
}

A. 【1】

B. 【2】

C. 【3】

D. 【4】

答案： B.

分析：

11. [单选题]普通（3分）

下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？

class E {
    int  x;                 
    public void f(int n) {
       int m;               //【1】
       int t = x+n;         //【2】  
       int y = x+m;         //【3】 
       m = 10;
       y = x+m;             //【4】   
   } 
}

A. 【1】

B. 【2】

C. 【3】

D. 【4】

答案： C

分析：局部变量没有默认值

        **int m;只是定义，可在下面语句赋值**

12. [单选题]容易（3分）

下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？

class E {
  int  x;             //【1】
  long y = x          //【2】
  public void f(int n) {
     int m ;         //【3】 
     int t = n+m;      //【4】   
  } 
}

A. 【1】

B. 【2】

C. 【3】

D. 【4】

答案： D

分析：局部变量没有默认值

        **int m;只是定义，可在下面语句赋值**

13. [单选题]普通（3分）

下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？

class E {
  int  x;            
  long y = x          //【1】
  public void f(int n) {
     int m ;          //【2】 
     int p = 0;
     int t = n+m;      //【3】 
     y = n+p;          //【4】   
  } 
}

A. 【1】

B. 【2】

C. 【3】

D. 【4】

答案： C

分析：局部变量没有默认值

        **int m;只是定义，可在下面语句赋值**

17. [单选题]容易（3分）

下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？

class Tom {
   int x;
   static int y; 
   void showXY(){
       System.out.printf("%d,%d\n",x,y);  
   }
   static void showY() {
       System.out.printf("%d\n",y);  
   }
}
public class E {
   public static void main(String aqgs[]){
       Tom.y = 300;  //【1】
       Tom cat = new Tom();
       cat.x = 100;   //【2】 
       Tom.showXY();  //【3】
       cat.showY();   //【4】

   }
}

A. 【1】

B. 【2】

C. 【3】

D. 【4】

答案： C

分析：Tom.showXY();是静态方法的用法

20. [单选题]普通（3分）

下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？

class A {
   int f(int x,int y){
      int x;      //【1】
      int m = y;  //【2】
      return m; 
   }
   int A(int m)   //【3】
   {
      return m;
   }
}
public class E {
    public static void main(String args[]) {
        A a = new A(); //【4】
    }
}

A. 【1】

B. 【2】

C. 【3】

D. 【4】

答案： A

分析：参数名字不可以和方法内的局部变量名字相同

        **参数也是局部变量**

21. [单选题]普通（3分）

下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？

class Tom {
     void  Tom()       //【1】
     { 
        System.out.print("ok");
     }
     Tom(byte m)       //【2】
     { 
        System.out.print("你好");
     }
     Tom(int m)       //【3】
     { 
        System.out.print(":"+m);
     }
}
public class E {
    public static void main(String args[]) {
        Tom a = new Tom(); //【4】
    }
}

A. 【1】

B. 【2】

C. 【3】

D. 【4】

答案： D

分析：void Tom()不算构造方法

23. [单选题]容易（3分）

下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？

package china.beijing;
package china.beijing;   //【1】
class People {
     static void  speak(){
         System.out.print("take care of");
     }
     void People(int m)   // B
     {
     }
}
public class E {
    public static void main(String args[]) {
        People zh = new People(); //【3】
        zh.speak();               //【4】
    }
}

A. 【1】

B. 【2】

C. 【3】

D. 【4】

答案： A

分析：

一个java文件只能有一个package而且只能写在第一行(除注释外)
一个.java文件可以有多个import

29. [单选题]普通（3分）

下列【1】、【2】、【3】、【4】注释标注的哪行代码有错误？

class Cat {
    int leg;
    static int water;
    void setLeg(int leg) {
       this.leg = leg;    //【1】
       this.water = 100;  //【2】
    }
    static void setWater(int water) {
       Cat.water = water;    //【3】
       leg = 4;              //【4】
    }
}

A. 【1】

B. 【2】

C. 【3】

D. 【4】

答案： D

分析：

(静态函数只能能访问静态)，leg是非静态

31. [单选题]普通（3分）

对于下列Hello类，哪个叙述是正确的？

class Hello {
    Hello(int m){    
    }     
    int Hello() {
        return 20;     
    }     
    hello() {    
    } 
}

A. Hello类有2个构造方法。

B. Hello类的int Hello()方法是错误的方法。

C. Hello类的int Hello()方法是错误的方法。

D. Hello无法通过编译，因为其中的hello方法的方法头是错误的（没有类型）。

答案： D

分析：

第 4 章类与对象第二单元

1.static

局部变量不可以用static修饰：

static是说明这个东西是属于整个类的
而局部变量的作用域只能在他所属的{}之内。不可能是属于类或对象的。
所以矛盾，故static不能修饰局部变量

2.package

package语句作为Java源文件的第一条语句

一个.java文件只能有一个package
一个.java文件可以有多个import

3.空对象

(1).一个引用变量没有通过new分配内存空间，这个对象就是空对象，Java使用关键字null表示空对象

(2).引用变量默认值是null。当试图调用一个空对象的实例变量或实例方法时，会抛出空指针异常 NullPointerException

4.构造函数权限

如果在类的修饰前是public则默认构造函数访问权限是 public，如果没有显示采用public修饰，则默认构造函数的访问权限是friendly

5.错题

7. [单选题]容易（4分）

下列哪个叙述是正确的？

A. private class Test是一个正确的类声明（不包括以后学习的内部类inner class）。

B. 类中的类变量（static）在该类被加载到内存时（即使该类未创建对象）就会被分配内存空间。

C. 习惯将类名的首字母小写。

D. 类中的重载方法的访问权限必须保持一致。比如，或者都是public方法，或者都是private方法。

答案： B.

分析：

A. 访问限制修饰符有private、protected和public，都是Java的关键字，用来修饰成员变量或方法

D. 方法重载指的是在同一个类中出现两个或两个以上的同名方法时，而且这些方法的参数列表不同

**方法重载与返回值的类型和修饰符无关。**

14. [单选题]容易（3分）

下列哪个叙述是正确的？

A. 对于友好类，用户定义的构造方法的访问权限也必须是public。

B. 组合关系也叫is a,属于强耦合关系。

C. 当方法被调用时，参数被分配内存空间，调用者向参数传递值，即方法被调用时，参数变量必须有具体的值。

D. private class Test是一个正确的类声明（不包括以后学习的内部类inner class）。

答案：C.

分析：

B. is a 继承关系？？？

27. [单选题]容易（3分）

下列哪个叙述是错误的？

A. 类中的重载方法的访问权限必须保持一致。比如，或者都是public方法，或者都是private方法。

B. 方法中声明的局部变量不可以用访问修饰符：public,proteced,private修饰。

C. 方法中声明的局部变量不可以用static修饰。

D. 方法中声明的局部变量的名字不可以和方法的参数的名字相同。

答案：A

分析：

29. [单选题]普通（3分）

下列【1】、【2】、【3】、【4】注释标注的哪行代码无编译错误，但运行时刻触发NullPointerException异常？

class Cat {
    int leg;
    static int water;
    void setLeg(int leg) {
       this.leg = leg;    //【1】
       this.water = 100;  //【2】
    }
    static void setWater(int water) {
       Cat.water = water;    //【3】
    }
}
public class E {
    public static void main(String args[]) {
        Cat cat = null;
        cat.setLeg(4); //【4】
    }
}

答案：【4】

分析：cat还没有new分配空间

第 5 章子类与继承第一单元

1.实例方法覆盖静态方法

class A {
   static int m;
   static void f(){
       m = 20 ;         
   } 
}
class B extends A {
   void f()              //【错误】
   {  m = 222 ;               
   } 
}
class E {
   public static void main(String args[]) {
      A.f();                
   }
}

单词“ static”是“ dynamic”的反义词。 所以不能覆盖静态方法的原因是因为静态成员上没有动态分派- 因为静态字面意思是“非动态”。 如果它们是动态调度的（因此可以被覆盖），那么static关键字将不再有意义。

2.抽象类方法

对于abstract方法，只允许声明，不允许实现，而且不允许使用final修饰abstract方法
如果一个类是abstract类的子类，它必须具体实现父类的所有的abstract方法

abstract class Takecare {
    protected void speakHello() {}    
    public abstract static void cry();  //2
    static int f(){ return 0 ;}        
    abstract float g();                
}

static是静态的，而abstract方法要在子类里实现

方法实现不能降级

3.错题

1.[单选题]普通（5分）

下列哪个叙述是正确的？

A. 子类继承父类的构造方法。

B. abstract类的子类必须是非abstract类。

C. 子类继承的方法只能操作子类继承和隐藏的成员变量。

D. 子类重写或新增的方法也能直接操作被子类隐藏的成员变量。

答案： C

分析：

3.[单选题]普通（5分）

假设C是B的子类，B是A的子类，cat是C类的一个对象，bird是B类的一个对象，下列哪个叙述是错误的？

A. cat instanceof B的值是true。

B. bird instanceof A的值是true。

C. cat instanceof A的值是true。

D. bird instanceof C的值是true。

答案： D

分析：

9.[单选题]普通（5分）

下列程序中注释的哪两个代码（1、2、3、4）是错误的（无法通过编译）？

class Father {
   private int money =12;
   float height;
   int seeMoney(){
      return money ;          //1
   } 
}
class Son extends Father {
   int height;
   int lookMoney() {
      int m = seeMoney();   //2
      return m;             
   }
}
class E {
   public static void main(String args[]) {
      Son erzi = new Son();
      erzi.money = 300;     //3
      erzi.height = 1.78F; //4
   }
}

A. 1

B. 2

C. 3

D. 4

答案： C D

分析：

D.Son类里height是int类型

15 . [判断题]容易（5分）

子类继承的方法所操作的成员变量一定是被子类继承或隐藏的成员变量。（）

答案：正确

第 5 章子类与继承第二单元

1.[编程题] 困难（100分）

设计一个动物声音“模拟器”，希望模拟器可以模拟许多动物的叫声，要求如下。

· 编写抽象类Animal

Animal抽象类有两个抽象方法cry()和getAnimalName()，即要求各种具体的动物给出自己的叫声和种类名称。

· 编写模拟器类Simulator

该类有一个playSound(Animal animal)方法，该方法的参数是Animal类型。即参数animal可以调用Animal的子类重写的cry()方法播放具体动物的声音，调用子类重写的getAnimalName()方法显示动物种类的名称。

· 编写Animal类的子类：Dog和Cat类

图5.18是Simulator、Animal、Dog、Cat的UML图。

清览题库Java题目笔记 - 图1

· 编写主类Application（用户程序）

在主类Application的main方法中至少包含如下代码：

Simulator simulator = new Simulator();

simulator.playSound(new Dog());

simulator.playSound(new Cat());

第 6 章接口与继承

1.访问权限

接口中只可以有常量,不能有变量
abstract类中即可以有常量也可以有变量

接口中的常量自动都是public、static，final
接口中的方法默认为public abstract；接口也产生class文件
接口中的方法不能被static和final修饰，因为类要重写所有接口中的方法
接口中没有构造函数，方法可以抛出异常

2.错题

2.[单选题]普通（5分）

将下列（A、B、C、D）哪个代码替换下列程序中的【代码】不会导致编译错误？

interface Com {
    int M = 200;
    int f();
}
class ImpCom implements Com {
 【代码】
}

A. public int f(){return 100+M;}

B. int f(){return 100;}

C. public double f(){return 2.6;}

D. public abstract int f();

答案： A

分析：

B. 默认权限是友好而接口的默认是public ，不能降级

C. 返回类型不能改

D. 一个非abstract类实现了某个接口，那么这个类必须重写该接口的所有abstract方法，即去掉abstract修饰给出方法体。

5 . [判断题]容易（5分）

Java8之后，接口中也能定义非抽象的不加default修饰的方法。（）

答案：错误

分析：

JDK8版本开始，允许使用default关键字

6 . [判断题]容易（5分）

Java8之后，接口中可以定义private方法。（）

答案：正确

分析：

17 . [判断题]普通（4分）

接口里也可以定义非abstract的方法（不加default修饰）。

答案：错误

分析：

第 7 章内部类与异常类

1.错题

1.[单选题]普通（5分）

下列哪个叙述是错误的？

A. 匿名类没有构造方法。

B. 编译器会给匿名类一个名字。

C. 匿名类一定是final类。

D. 匿名类一定是内部类。

答案： A

分析：

使用父类的构造方法

2.[单选题]普通（5分）

下列哪个叙述是错误的？

A. 非匿名内部类也可以有（内部）子类。

B. 内部类不可以是final类。

C. 不可能用匿名类声明对象，但却可以直接用匿名类创建一个对象。

D. 匿名子类（和子类有关的匿名类）可以继承父类的方法也可以重写父类的方法。

答案： B

分析：

声明内部类如同在类中声明方法或变量一样，一个类把内部类看作是自己的成员

4 . [判断题]容易（5分）

可以用private或protected修饰内部类。（）

答案：正确

分析：

10 . [判断题]容易（5分）

内部类不可以是final类。（）

答案：错误

分析：

10 . [判断题]容易（5分）

一个方法使用throw关键字声明要产生的若干个异常。（）

答案：错误

分析：

一个方法在声明时可以使用throwS关键字声明要产生的若干个异常

15 . [判断题]容易（5分）

内部类的外嵌类的成员变量在内部类中仍然有效。

答案：正确

分析：

外嵌类的成员变量在内部类中仍然有效，内部类中的方法也可以调用外嵌类中的方法。

16 . [判断题]容易（5分）

内部类中的方法也可以调用外嵌类中的方法。

答案：正确

分析：

17 . [判断题]容易（5分）

内部类的类体中不可以声明类变量和类方法。

答案：正确

分析：

19 . [判断题]容易（5分）

可以用private或protected修饰内部类。

答案：正确

分析：

清览题库Java题目笔记

第 1 章 Java入门

1.如何分辨主类

2.关于类的public修饰符

3.main方法返回值类型

4.代码风格

(1)独行风格（Allmans风格）

(2)行尾风格（Kernighan风格）

5.开发步骤

6.错题

7 . [单选题]容易 （3分）

25 . [判断题]容易 （2分）

28 . [判断题]普通 （2分）

第 2 章 Java基础

1.关键字

(1)小写

(2)implements(执行)

(3)import

2.变量类型占用内存

(1)整数类型:

(2)浮点类型:

(3)字符类型

(4)布尔类型

3.float常量后缀

4.Unicode码范围(十六进制)

5.unsigned

6.错题

1 . [多选题]容易 （2分）

13 . [单选题]容易 （2分）

16 . [单选题]容易 （2分）

26 . [单选题]容易 （2分）

45 . [判断题]容易 （2分）

46 . [判断题]普通 （2分）

47 . [判断题]容易 （2分）

第 2 章 Java基础（2）

1. a[0].length

2.错题

1 . [单选题]普通（3分）

2. [单选题]普通（3分）

3. [单选题]普通（3分）

6. [单选题]普通（3分）

第 4 章 类与对象 第一单元

1.默认值

(1)成员变量有默认值

(2)在类中不能对成员变量直接赋值

(3)局部变量没有默认值

2.static静态变量

3.静态成员函数

4.new对象

5.protected修饰成员变量或方法

6.private修饰成员变量或方法

7.错题

9. [单选题]容易 （3分）

11. [单选题]普通 （3分）

12. [单选题]容易 （3分）

13. [单选题]普通 （3分）

17. [单选题]容易 （3分）

20. [单选题]普通 （3分）

21. [单选题]普通 （3分）

23. [单选题]容易 （3分）

29. [单选题]普通 （3分）

31. [单选题]普通 （3分）

第 4 章 类与对象 第二单元

1.static

2.package

3.空对象

4.构造函数权限

5.错题

7. [单选题]容易 （4分）

14. [单选题]容易 （3分）

27. [单选题]容易 （3分）

29. [单选题]普通 （3分）

第 5 章 子类与继承 第一单元

1.实例方法覆盖静态方法

2.抽象类方法

3.错题

1.[单选题]普通 （5分）

3.[单选题]普通 （5分）

9.[单选题]普通 （5分）

15 . [判断题]容易 （5分）

7 . [单选题]容易（3分）

25 . [判断题]容易（2分）

28 . [判断题]普通（2分）

1 . [多选题]容易（2分）

13 . [单选题]容易（2分）

16 . [单选题]容易（2分）

26 . [单选题]容易（2分）

45 . [判断题]容易（2分）

46 . [判断题]普通（2分）

47 . [判断题]容易（2分）

第 4 章类与对象第一单元

9. [单选题]容易（3分）

11. [单选题]普通（3分）

12. [单选题]容易（3分）

13. [单选题]普通（3分）

17. [单选题]容易（3分）

20. [单选题]普通（3分）

21. [单选题]普通（3分）

23. [单选题]容易（3分）

29. [单选题]普通（3分）

31. [单选题]普通（3分）

第 4 章类与对象第二单元

7. [单选题]容易（4分）

14. [单选题]容易（3分）

27. [单选题]容易（3分）

29. [单选题]普通（3分）

第 5 章子类与继承第一单元

1.[单选题]普通（5分）

3.[单选题]普通（5分）

9.[单选题]普通（5分）

15 . [判断题]容易（5分）

第 5 章子类与继承第二单元

第 6 章接口与继承

2.[单选题]普通（5分）

5 . [判断题]容易（5分）

6 . [判断题]容易（5分）

17 . [判断题]普通（4分）

第 7 章内部类与异常类

1.[单选题]普通（5分）

2.[单选题]普通（5分）

4 . [判断题]容易（5分）

10 . [判断题]容易（5分）

10 . [判断题]容易（5分）

15 . [判断题]容易（5分）

16 . [判断题]容易（5分）

17 . [判断题]容易（5分）

19 . [判断题]容易（5分）