3月份准备面试第二套题

Java语言中下面那个可以用作正确的变量名称？

A.name B.3D C.implements D.extends

下列标识符（名字）命名原则中，正确的是( )
A. 类名的首字母小写

B. 变量和方法名的首写字母大写
C. 接口名的首写字母小写

D. 常量完全大写

Java程序的执行过程中用到一套JDK工具，其中java.exe是指( )
A.Java文档生成器 B.Java解释器
C.Java编译器 D.Java类分解器

解析：
Java编译器：将Java源文件（.java文件）编译成字节码文件（.class文件，是特殊的二进制文件，二进制字节码文件）。javac.exe可以简单看成是Java编译器。

Java解释器：是JVM的一部分。Java解释器用来解释执行Java编译器编译后的程序。java.exe可以简单看成是Java解释器。

​

JDBC中，用于表示数据库连接的对象是

A．Statement　B．Connection　C. DriverManager　D．PreparedStatement

JDBC中，用于调用存储过程的对象是:
A.ResultSet
B.DriverManager
C.CallableStatemet
D.PreparedStatement

下列说法正确的是？

A.一个文件里可以存在两个public修饰的类

B，final修饰的类可以被继承

C，子类不可以访问父类非public和protected修饰的属性（子类可以访问父类public和protected修饰的属性）

D,构造函数可以被重写（override）

解析：protected的意思是本包可以访问，子类可以继承。

下列哪一项的叙述是正确的？

A，声明抽象方法，大括号可有可无

B，abstract修饰符可以修饰字段、方法、和类

C，声明抽象方法不可写出大括号

D，抽象方法的body部分必须用一对大括号{ }包住

解析：abstract是抽象的意思,在java中,规定只能修饰类或者方法,所以不能修饰属性。

// 这就是一个抽象类，abstract类不一定有abstract方法，但abstract方法所在类一定是abstract类
//因为可能含未为实现的抽象方法，所以抽象类不能被实例化

abstract class Animal {
    String name;
    int age;
    // 动物会叫
    public abstract void cry(); //把相同但不确定的方法提取出来，子类继承后由子类具体实现
}

// 
// 当继承的父类是抽象类时，需要将抽象类中的所有抽象方法全部实现。
class cat extends Animal {
    // 实现父类的cry抽象方法
    public void cry() {
        System.out.println("猫叫:");
    }
}

下面的程序输出结果为？

public static void main(String[] args) {
int x=-3;
int y=-10;
System.out.println(y%x);
}

A,-1 B,2 C,1 D,3

计算方法：先忽略除数和被除数的符号，按正数取模，结果与被除数同号

（ ）类是所有异常类的父类

A,Throwable B,Error C,Exception D,AWTError

解析：Thorwable类（表示可抛出）是所有异常和错误的父类

Error是程序无法处理的错误，它是由JVM产生和抛出的，比如OutOfMemoryError、ThreadDeath等。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。
Exception是程序本身可以处理的异常，这种异常分两大类运行时异常和非运行时异常（编译时异常）。程序中应当尽可能去处理这些异常。

Java异常体系架构图

已知如下类说明，如下那个使用是正确的？

public class Test{
private float f=1.0f;
int m=12;
static int n=1;
public static void main(String[] args) {
Test t=new Test();
//some code…
}
}
A，t.f B,this.n C,Test.n D,Test.m

Java访问修饰符包括private（仅在本类中被访问），default（默认值，在同一个包中可被访问），protected（在同一个包或子类中可被访问）和public（无限制）

Java应用开发中字符集编码通常情况下优先采用以下那种？

A，UTF-8 B, iso8859-1 C,GB2312 D,ASCII

Java访问限定的修饰符不包括？

A，public B，private C，default D，final

下列会触发JVM垃圾回收的是（）？

A，当新对象生成，并且在Eden申请空间失败时

B，Old区被写满

C，在循环中创建大量对象

D，使用Class.forName加载外部类

解析：一般情况下，当新对象生成，并且在Eden申请空间失败时，就会触发Scavenge GC，对Eden区域进行GC，清除非存活对象，并且把尚且存活的对象移动到Survivor区。然后整理Survivor的两个区。这种方式的GC是对年轻代的Eden区进行，不会影响到年老代。因为大部分对象都是从Eden区开始的，同时Eden区不会分配的很大，所以Eden区的GC会频繁进行。因而，一般在这里需要使用速度快、效率高的算法，使Eden去能尽快空闲出来。

以下程序的运行结果？

class Person{
    public Person(){
        System.out.println("this is a Person");
    }
}
public class Teacher extends Person{
    private String name="tom";
    public Teacher(){
        System.out.println("this is a Teacher");
        super; //应位于构造器的第一行
    }
    public static void main(String[] args) {
        Teacher teacher=new Teacher();
        System.out.println(this.name); //静态方法中不能使用this
    }
}

A，运行出错 B，编译有两处错误

C，this is a Person this is a teacher tom

D，this is a teacher this is a Person tom

2. 如下代码

  public class Test {
      public int aMethod() {
          static int i = 0;//此处有错误
          i++;
          return i;
      }
      public static void main (String args[]) {
          Test test = new Test();
          test.aMethod();
          int j = test.aMethod();
          System.out.println(j);
      }
  }

输出结果是什么？
A. 0
B. 1
C. 2
D. 编译失败

下面程序输出结果为？

class HelloA{
    public HelloA() {
        System.out.println("HelloA"); //父类构造方法
    }
    {
        System.out.println("I'm A class"); //父类构造代码块
    }
    static{
        System.out.println("static A"); //父类静态成员
    }
}
public class HelloB extends HelloA{
    public HelloB() {
        System.out.println("HelloB"); //子类构造方法
    }
    {
        System.out.println("I'm B class"); //子类构造代码块
    }
    static{
        System.out.println("static B"); //子类静态成员
    }
    public static void main(String[] args) {
        new HelloB();
    }
}

答案：static A static B I’m A class HelloA I’m B class HelloB

解析：加载顺序如下：

       Java程序（初始化）的执行顺序（或使用new关键字时类的执行顺序）：
       父类静态变量 ----> 父类静态代码块 ----> 子类静态变量 ----> 子类静态代码块 ----> 父类非静态变量 ----> 父类构造代码块（非静态代码块） ----> 父类构造方法 ----> 子类非静             态变量 ----> 子类构造代码块（非静态代码块） ----> 子类构造方法

将整数数组（7-6-3-5-4-1-2）按照堆排序的方式进行排序，请问在第一轮排序结束以后，数组的顺序是（）？

A，5-4-3-2-1-6-7 B，1-2-3-4-5-6-7

C，2-6-3-5-4-1-7 D，6-5-3-2-4-1-7

构造函数什么时候被调用（）？

A，创建对象时 B，使用对象的变量时

C，调用对象方法时 D，类定义时

以下所列的HTTP协议的状态码，表示内部服务器错误的是（）？

A，402 B，404 C，500 D，501

解析：200 - 请求成功， 301 - 资源（网页等）被永久转移到其它URL，404 - 请求的资源（网页等）不存在，500 - 内部服务器错误

有如下程序段：total最终值为？

int total=0;
for (int i = 0; i < 4; i++) {
    if(i==1)continue;
    if(i==2)break;
    total+=i;
}

A,1 B,0 C,6 D,3

下列关于整型类型的说法中，正确的是（）？

A，short类型的数据存储顺序先低后高

B，Integer.MAX_VALUE表示整型最大值

C，Long.MIN_VALUE表示整型最大值

D，long类型表示数据范围和int类型一样

在使用super和this关键字的时候，以下描述正确的是（）？

A，在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过

B，super()和this()不一定要放在构造方法内第一行

C，this()和super()可以同时出现在一个构造函数中

D，this()和super()可以在static环境中使用，包括static方法和static语句块

解析：

调用super()和this()必须写在子类构造方法的第一行，否则编译不通过。

每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。

super()和this()类似,区别是super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。

尽管可以用this()调用一个构造器，但却不能调用两个,即this()和super()不能同时出现在一个构造函数里面。

23.以下程序代码的输出是

public class test {
    public static void main (String args[]) {
        System.out.printIn (6 ^ 3);
    }
}

A．3 B．5 C．6 D．11

解析：

按位与 &：全1为1， 其他的为0

按位或 |：全0为0，其他为1

异或 ^：相同为0，不同为1

6 ==> 00000110
3 ==> 00000011
6^3 ==> 00000101=5

24.下面哪项不是response对象的方法( )
A. setContentType(String contentTypestr)
B. setHeader(String headername,String headervalue)
C. getParameter(String str)
D. sendError(int errorcode)

25.下面哪项不属于SQL语句的子类( D )
A. 数据定义语言(DDL)
B. 数据查询语言(DQL)
C. 事务控制语言(TCL)
D. 数据插入语言 (DIL)

26. 按照学生平均成绩(avg_grade) 将students表中的数据检索出来，下面SQL语句正确的是( 多选)
    A) SELECT * FROM students ORDER BY avg_grade
    B) SELECT * FROM students GROUP BY avg_grade ASC
    C) SELECT * FROM students ORDER BY avg_grade DESC
    D) SELECT * FROM students ORDER by avg_grade asc

27.不能用来修饰interface的有（多选 ）
A．private B．public C．protected D．static

28.下面的语句中正确的表达式为
A．byte b = 128;
B．boolean n = null;
C．double d = 0.9239d;
D．float f = 0.9239;

解析：

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

byte：长度1字节（8位），最大值127（2^{7-1），最小值-128（-2}7），默认值0，128超出表示范围

boolean：值只能为true或false，默认值false

float：赋值格式为x.xxf，默认值0.0f，后面必须加f，double则可加可不加d，因为虚拟机默认浮点型为double类型

long：赋值格式为xxxL（不区分大小写），默认值0L

29.以下程序代码的输出是

public class test {
    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);//  |的操作中 methodB（）会运行
        b = i< 10 || methodB (8);//  ||的操作中 methodB（）不会运行
    }
    public static void main (String args[] ）{
        methodA (0);
        System.out.println(j);
    }
 }

A．0 B．4 C．8 D．12 E．不能编译通过
解析：

boolean类型既可以使用&&和||做逻辑运算，也可以使用&和|做逻辑运算，但前者是经过优化的（执行短路运算），后者未优化。

使用逻辑或|做逻辑运算时，m1() | m2()中，当m1()为true时，依然会执行后面的m2()函数。这是与逻辑或||的区别。

method(8);没有执行

30.有可能引发StackOverflowError的原因可能是

A，缺少内存

B，写数据到不可用内存地址

C，递归调用

D，数组索引超出边界

解析：经典栈溢出StackOverflowError问题，递归或者是死循环，造成大量的线程，在栈中每一个线程对应一个栈帧，当线程越来越多时，发生栈溢出

31.下面哪个流类属于面向字符的输入流( )

A、BufferedWriter

B、FileInputStream

C、ObjectInputStream

D、InputStreamReader

解析：

Java的IO操作中有面向字节(Byte)和面向字符(Character)两种方式。
面向字节的操作为以8位为单位对二进制的数据进行操作，对数据不进行转换，这些类都是InputStream和OutputStream的子类。
面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。

Java流类图结构：

32.下列哪个叙述是正确的（）

A.final类可以有子类。

B.abstract类中只可以有abstract方法。

C.abstract类中可以有非abstract方法，但该方法不可以用final修饰。

D.不可以同时用final和abstract修饰同一个方法。

E.允许使用static修饰abstract方法。
解析：

用final修饰的类是不允许被继承的，A错误
abstract类中也可以有普通成员方法，B错误
abstract类中的非abstract方法是可以用final修饰的，而abstract方法是不可以被final修饰的，C错误

不允许使用final、static修饰abstract方法，E错误。

33.当检索一个压缩文件时，首先要建立压缩文件输入流对象，该对象（）

A、以选中的压缩文件为参数

B、以FileInputStream对象为参数

C、以InputStreamReader对象为参数

D、以BufferedReader对象为参数

在java.io包中提供了对压缩文件进行操作的能力。它是通过压缩文件输入流与压缩文件输出流来实现的，其分别继承自InflaterInputStream与DeflaterOutputStream。

在创建压缩文件输入流时，其初始化参数是一个FileInputStream类的实例。

34.下面关于InputStream类的说法不正确的是：
A、InputStream是抽象类
B、InputStream是字节流
C、InputStream是输入流
D、InputStream是InputStreamReader的父类

35.下列关于内部类的说法不正确的是 ( )

A，内部类的类名只能在定义它的类或程序段中或在表达式内部匿名使用

B，内部类可以使用它所在类的静态成员变量和实例成员变量

C，内部类不可以用abstract修饰符定义为抽象类

D，内部类可作为其他类的成员，而且可访问它所在类的成员

解析：

内部类不仅可以用abstract修饰定义为抽象类，也可以用private或protected定义，所以选项C说法错误。

36.下列哪个方法可以用来加载JDBC驱动程序？
A、类java.sql.DriverManager 的getDriver方法
B、类java.sql.DriverManager 的getDrivers方法
C、类java.sql.Driver的connect方法
D、类java.lang.Class的forName方法

37.下面哪项可以得到数组元素的个数，Java中定义数组名为abc
A、abc.length()
B、abc.length
C、len(abc)
D、ubound(abc)

38.通过流的read()方法读取数据，如何判断流结尾？
A、返回-1表示流结尾
B、返回null表示流结尾
C、返回0表示流结尾
D、遇到流结尾将抛出异常

39.在JDBC编程中执行完下列SQL语句：SELECT name, rank, serialNo FROM employee，能得到rs的第一列数据的代码是哪一个？
A、rs.getString(0);
B、rs.getString(name);
C、rs.getString(1);
D、rs.getString(“ename”);

40.如果为下列预编译SQL的第三个问号赋值，那么正确的选项是哪一个？
UPDATE emp SET ename=?,job=?,salary=? WHERE empno=? ;
A、pst.setInt(“3”,2000);
B、pst.setInt(3,2000);
C、pst.setFloat(“empno”,20);
D、pst.setString(“salary”,“2000”);

41.下列语句序列执行后，k 的值是
int x=6, y=10, k=5;
switch( x % y )
{
case 0: k=xy;
case 6: k=x/y;
case 12: k=x-y;
default: k=xy-x;
}
A、60
B、5
C、0
D、54

42.下列Java代码，运行的结果为( C )

public class Cat{
    private String name = “猫咪”;
    public void Cat() {
        System.out.println(“大家好,我是” + name);
    }
    public static void main(String[] args) {
        Cat cat = new Cat();
    }
}

A、发生编译错误，提示构造函数错误
B、程序可正常运行，输出结果：大家好，我是猫咪
C、程序可正常运行，但什么都不输出
D、程序运行时出现异常
解析：

构造函数没有返回值，cat()函数用void的修饰后不能作为构造函数，只作为普通函数，被调用后才执行。

其实普通的类方法是可以和类名同名的，和构造方法唯一的区分就是，构造方法没有返回值。

43.关于静态的描述错误的有
A、在内存中只有一份，供所有对象公用，起到全局的作用
B、静态成员变量/类变量只初始化一次，就是在类刚刚加载的时候
C、每次在创建对象，静态变量和方法都重新加载并分配新的堆内存
D、它们不能以任何方式引用this 或super
解析：

静态变量只在类加载时初始化一次，存放在JVM内存的方法区中

44.下列代码输出的结果是:
String name=“NASDAQ欢迎你”;
String newName=name.substring(4,7);
System.out.println(newName);
A、DAQ
B、SDAQ欢
C、AQ欢迎
D、AQ欢

解析：

substring(起始索引：从0开始——包括，结束索引：不包括)

45.以下对重载描述错误的是（）
A、方法重载只能发生在一个类的内部
B、构造方法不能重载
C、重载要求方法名相同，参数列表不同
D、方法的返回值类型不是区分方法重载的条件

46.以下对自定义异常描述正确的是（）
A、自定义异常必须继承Exception
B、自定义异常可以继承自Error
C、自定义异常可以更加明确定位异常出错的位置和给出详细出错信息
D、程序中已经提供了丰富的异常类，使用自定义异常没有意义

47.要删除book表中书籍(bookName)是”java”的记录，以下代码正确的是（）
String sql=”delete from book where bookName=?”;
PreparedStatement pst=con.preparedStatement(sql);
——————————
pst.execute();
A、pst.setString(1,”java”);
B、pst.setString(0,”java”);
C、pst.setInt(0,”java”);
D、以上选项都不正确

48.获取ResutlSet对象rst的第一行数据，以下正确的是（）
A、rst.hashNext();
B、rst.next();
C、rst.first();
D、rst.nextRow();

49、以下负责建立与数据库连接的是（）
A、Statement
B、PreparedStatement
C、ResultSet
D、DriverManager

50、使用JDBC连接数据库的顺序是（）
A) 加载驱动
B) 导入驱动包
C) 发送并处理SQL语句
D) 建立于数据库的连接
E 关闭连接
A、B、A、D、C、E
B、B、A、C、D、E
C、B、D、A、C、E
D、B、D、C、A、E

51.Java线程之间可以通过以下哪些方法实现通信(多选 )
A、wait()
B、notifyOne()
C、notify()
D、notifyAll()

52.下面哪些是Thread类的方法（多选）

A start() B run() C exit() D getPriority()

解析：看Java API docs吧：http://docs.oracle.com/javase/7/docs/api/，exit()是System类的方法，如System.exit(0)

53.下面程序的运行结果：（）

public static void main(String args[]) {
    Thread t = new Thread() {

        public void run() {
            pong();
        }
    };

    t.run();
    System.out.print("ping");

}

static void pong() {

    System.out.print("pong");

}

A pingpong B pongping C pingpong和pongping都有可能 D 都不输出

解析：这里考的是Thread类中start()和run()方法的区别了。start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程，进而调用run()方法来执行任务，而单独的调用run()就跟调用普通方法是一样的，已经失去线程的特性了。因此在启动一个线程的时候一定要使用start()而不是run()。

54.下列说法正确的是（多选）

A LinkedList继承自List

B AbstractSet继承自Set

C HashSet继承自AbstractSet

D WeakMap继承自HashMap

解析：下面是一张下载的Java中的集合类型的继承关系图，一目了然。

55.Java接口的修饰符可以为（多选）

A private B protected C final D abstract

解析：

接口的方法默认是public abstract；

接口中不可以定义变量即只能定义常量(加上final修饰就会变成常量)。所以接口的属性默认是public static final 常量，且必须赋初值。

注意：final和abstract不能同时出现。

56.不通过构造函数也能创建对象吗（）

A 是 B 否

解析：Java创建对象的几种方式（重要）：

(1) 用new语句创建对象，这是最常见的创建对象的方法。
(2) 运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
(3) 调用对象的clone()方法。
(4) 运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。

(1)和(2)都会明确的显式的调用构造函数 ；(3)是在内存上对已有对象的影印，所以不会调用构造函数 ；(4)是从文件中还原类的对象，也不会调用构造函数。

57.ArrayList list = new ArrayList(20);中的list扩充几次（）

A 0 B 1 C 2 D 3

解析：这里有点迷惑人，大家都知道默认ArrayList的长度是10个，所以如果你要往list里添加20个元素肯定要扩充一次（扩充为原来的1.5倍），但是这里显示指明了需要多少空间，所以就一次性为你分配这么多空间，也就是不需要扩充了。

58.下面哪些是对称加密算法（多选）

A DES B AES C DSA D RSA

解析：常用的对称加密算法有：DES、3DES、RC2、RC4、AES

常用的非对称加密算法有：RSA、DSA、ECC

使用单向散列函数的加密算法：MD5、SHA

59.阅读Shape和Circle两个类的定义。在序列化一个Circle的对象circle到文件时，下面哪个字段会被保存到文件中？ ( )

class Shape {   
    public String name;
}
class Circle extends Shape implements Serializable{
    private float radius;

    transient int color;

    public static String type = "Circle";
}

A name

B radius

C color

D type

解析：

这里有详细的解释：http://www.cnblogs.com/lanxuezaipiao/p/3369962.html

60.下面的方法，当输入为2的时候返回值是多少?（）

public static int getValue(int i) {
    int result = 0;
    switch (i) {
        case 1:
            result = result + i;
        case 2:
            result = result + i * 2;
        case 3:
            result = result + i * 3;
    }
    return result;
}

A0 B2 C4 D10

解析：注意这里case后面没有加break，所以从case 2开始一直往下运行。

61.下面程序能正常运行吗（）

public class NULL {
    public static void haha(){
        System.out.println("haha");
    }
    public static void main(String[] args) {
        ((NULL)null).haha();
    }
}

A，能 B，不能

解析：输出为haha，因为null值可以强制转换为任何java类类型,(String)null也是合法的。但null强制转换后是无效对象，其返回值还是为null，而static方法的调用是和类名绑定的，不借助对象进行访问所以能正确输出。反过来，没有static修饰就只能用对象进行访问，使用null调用对象肯定会报空指针错了。这里和C++很类似。

62.getCustomerInfo()方法如下，try中可以捕获三种类型的异常，如果在该方法运行中产生了一个IOException，将会输出什么结果（）

public void getCustomerInfo() {
    try {

        // do something that may cause an Exception

    } catch (java.io.FileNotFoundException ex) {

        System.out.print("FileNotFoundException!");

    } catch (java.io.IOException ex) {

        System.out.print("IOException!");

    } catch (java.lang.Exception ex) {

        System.out.print("Exception!");

    }

}

A IOException!

BIOException!Exception!

CFileNotFoundException!IOException!

DFileNotFoundException!IOException!Exception!

解析：

考察多个catch语句块的执行顺序。当用多个catch语句时，catch语句块在次序上有先后之分。从最前面的catch语句块依次先后进行异常类型匹配，这样如果父异常在子异常类之前，那么首先匹配的将是父异常类，子异常类将不会获得匹配的机会，也即子异常类型所在的catch语句块将是不可到达的语句。所以，一般将父类异常类即Exception老大放在catch语句块的最后一个。

63.下面代码的运行结果为：（）

import java.io.*;
import java.util.*;

public class foo{
    public static void main (String[] args){

        String s;

        System.out.println("s=" + s);

    }
}

A 代码得到编译，并输出“s=”

B 代码得到编译，并输出“s=null”

C 由于String s没有初始化，代码不能编译通过

D 代码得到编译，但捕获到 NullPointException异常

解析：开始以为会输出null什么的，运行后才发现Java中所有定义的基本类型或对象都必须初始化才能输出值。

64.指出下列程序运行的结果 （）

public class Example {
    String str = new String("good");

    char[] ch = { 'a', 'b', 'c' };

    public static void main(String args[]) {

        Example ex = new Example();

        ex.change(ex.str, ex.ch);

        System.out.print(ex.str + " and ");

        System.out.print(ex.ch);

    }

    public void change(String str, char ch[]) {

        str = "test ok";

        ch[0] = 'g';

    }
}

A、 good and abc

B、 good and gbc

C、 test ok and abc

D、 test ok and gbc

解析：大家可能以为Java中String和数组都是对象所以肯定是对象引用，然后就会选D，其实这是个很大的误区：因为在java里没有引用传递，只有值传递

这个值指的是实参的地址的拷贝，得到这个拷贝地址后，你可以通过它修改这个地址的内容（引用不变），因为此时这个内容的地址和原地址是同一地址，

但是你不能改变这个地址本身使其重新引用其它的对象，也就是值传递

65.储蓄所有多个储户，储户在多个储户所存取款，储蓄所与储户之间是（）
A.一对一的联系
B.多对一的联系
C.一对多的联系
D.多对多的联系

66.视图是一个“虚表”，视图的构造基于（）
A.基本表或视图
B.视图
C.数据字典
D.基本表

67.设有关系R(A,B,C,D)及其上的函数相关性集合F={B→A,BC→D},那么关系R最高是（）
A.第一范式的
B.第二范式的
C.第三范式的
D.BCNF范式的
分析： 根据数据库三大范式的依赖性要求，从B,BC函数确定A和D这一点上,明显看出B,BC都有可能是主码. 若B是主码的话,仔细看会发现,F中竟然没有谁去函数确定C,这显然是说不通的,(因为C至少会被B这个主码函数确定); 若BC是主码,那么F中存在非主属性对候选码的部分依赖,不满足第二范式的要求,故为第一范式.

68.给定某java程序片段，该程序运行后，j的输出结果为（）

int i=1；
Int j=i++；
If（（j>++j）&&(i++==j)）{j+=i:}
System.out.println(j);

A .1
B. 2
C. 3
D. 4
分析： i++先引用后。++i 先增加后引用