皇天
皇天

Java SE-13-基础练习题

前言

部分练习题摘录自：Sun-Java程序员认证考试题库

部分练习题加入了自己的解析

若对JavaSE某些知识点不熟悉，可以看下我有关JavaSE知识点总结的文章

还未整理完，待更

若有错误或补充，欢迎私信

一、Java入门

  1. 下列哪项不是JDK所包含的内容？（选一项）C

    A. Java编程语言
B. 工具及工具的API
C. Java EE扩展API
D. Java平台虚拟机

  2. 下列关于JDK、JRE和JVM的描述。哪项正确？D

    A. JDK中包含了JRE，JVM中包含了JRE
B. JRE中包含了JDK，JDK中包含了JVM
C. JRE中包含了JDK，JVM中包含了JRE
D. JDK中包含了JRE，JRE中包含了JVM

  3. 下列哪个工具可以编译java源文件？A

    A. javac
B. jdb
C. javadoc
D. junit

  4. JDK工具javadoc的作用是哪项？A

    A. 生成Java文档
B. 编译Java源文件
C. 执行Java类文件
D. 测试Java代码

  5. 以下哪些包是Java标准库中常用的包？（选三项）ACD

    A. java.lang
B. javax.servlet.http
C. java.io
D. java.sql

  6. 使用JDK工具生成的Java文档的文件格式是？D

    A. XML格式
B. 自定义格式
C. 二进制格式
D. HTML格式

  7. 以下关于JVM的叙述，哪项正确？（选两项）AC

    A. JVM运行于操作系统之上，它依赖于操作系统
B. JVM运行于操作系统之上，它与操作系统无关
C. JVM支持Java程序运行，它能够直接运行Java字节码文件
D. JVM支持Java程序运行，它能够直接运行Java源代码文件

注：Java跨平台，但每一种操作系统都有自己对应的JVM

  8. 以下关于支持Java运行平台的叙述，哪项错误？C

    A. Java可在Solaris平台上运行
B. Java可在Windows平台上运行
C. Java语言与平台无关。Java程序的运行结果依赖于操作系统
D. Java语言与平台无关。Java程序的运行结果与操作系统无关

  9. 以下关于Applet和Java程序之间关系的叙述，哪项错误？B

    A. 一个Applet就是一段Java程序
B. Applet是一种特殊的Java程序，它需要运行在Web服务器上
C. Applet是一种特殊的Java程序，它需要运行在Web浏览器上
D. Applet是一种Java SE平台的应用程序

  10. 以下关于Java HotSpot的描述，哪两项错误？（选两项）AD

    A. JavaHotSpot是一种热编译技术，在编译Java源程序时会被使用
B. Java HotSpot是一种热编译技术，在运行Java代码时会被使用
C. Java HotSpot是一种热编译技术，它只对程序的部分字节码进行优化
D. Java HotSpot是一种热编译技术，它会对程序的全部字节码进行优化

  11. 环境变量PATH中含有多个路径时，路径和路径之间可以用哪项来隔开？A

    A. ;
B. ,
C. *
D. |

  12. CLASSPATH中的"."的含义是哪项？B

    A. 省略号
B. 当前目录
C. 所有目录
D. 上级目录

  13. JVM在执行一个Java类时，大致采用以下过程？D

    A. 执行类中的代码->装载类->校验类
B. 校验类->装载类->执行类中的代码
C. 装载类->执行类中的代码->校验类
D. 装载类->校验类->执行类中的代码

注：考察类加载

  14. 当运行个Java程序时，传递参数的格式是哪项？C

    A. java 类名 参数1, 参数2
B. javac 类名 参数1 参数2
C. java 类名 参数1 参数2
D. java 类名 参数1 + 参数2

  15. 以下关于Java文件名的叙述，正确的有？（选两项）AB

    A. Java源文件的扩展名应为.java
B. Java源文件的文件名应与文件中的类名一致
C. Java字节码文件的扩展名应为.java
D. 一个Java源文件中只能包含一个Java类

二、数据类型和运算符

  1. 下列哪项不属于Java语言的基本数据类型？B

    A. int
B. String
C. double
D. boolean

  2. 下列哪项不是int类型的字面量？A

    A. \u03A6
B. 077
C. 0xABBC
D. 20

  3. 下列哪项不是有效的标识符？B

    A. userName
B. 2test
C. $change
D. _password

  4. 下列哪项是Java语言中所规定的注释样式？（选三项）ACD

    A. // 单行注释
B. --单行注释
C. /*
    * 单行或多行注释
    */
D. /**
    * 文档注释
    */

  5. 下列哪项不是Java语言的关键字？B

    A. goto
B. sizeof
C. instanceof
D. volatile

  6. 现有如下五个声明：哪行无法通过编译？D

    Line1: int a_really_really_really_long_variable_name = 5;
Line2: int _hi = 6;
Line3: int big = Integer.getInteger("7");
Line4: int $dollars = 8;
Line5: int %opercent = 9;

A. Line1
B. Line3
C. Line4
D. Line5

  7. 下面程序结果为：D

    class Top {
    static int x = 1;

    public Top(int y) {
        x *= 3;
    }
}

class Middle extends Top {
    // 由于父类有了有参构造就不会默认提供无参构造
    // 因此子类所有构造中需要显示调用父类有参构造
    public Middle() {
        x += 1;
    }

    public static void main(String[] args) {
        Middle m = new Middle();
        System.out.println(x);
    }
}

A. 1
B. 2
C. 3
D. 编译失败

  8. 下面程序结果为：A

    class Passer f {
    static final int x = 5;

    public static void main(String[] args) {
        new Passer().go(x);
        // 打印的是成员变量x
        System.out.print(x);
    }

    void go(int x) {
        // 打印的是值传递过来的x
        System.out.print(x++);
    }
}

A. 55
B. 56
C. 65
D. 66

  9. 下面程序结果为：B

    class Wrench {
    public static void main(String[] args) {
        Wrench w = new Wrench();
        Wrench w2 = new Wrench();
        // 返回w赋给w2
        w2 = go(w, w2);
        System.out.print(w2 == w);
    }

    static Wrench go(Wrench wrl, Wrench wr2) {
        Wrench wr3 = wrl;
        wrl = wr2;
        wr2 = wr3;
        // w3只赋值一次，值为wrl
        return wr3;
    }
}

A. false
B. true
C. 编译失败
D. 运行的时候有异常抛出

  10. 下面程序结果为：A

    class Wrench2 {
    int size;

    public static void main(String[] args) {
        Wrench2 w = new Wrench2();
        w.size = 11;
        Wrench2 w2 = go(w, w.size);
        System.out.print(w2.size);
    }

    // s为值传递
    static Wrench2 go(Wrench2 wr, int s) {
        s = 12;
        return wr;
    }
}

A. 11
B. 12
C. 编译失败
D. 运行的时候有异常抛出

  11. 下面程序哪一句是错误的？B

    class Test2 {
    public static void main(String[] args) {
        short a, b, c;
        a = 1;
        b = 2;
        // short + short在运算时会提升为int
        c = a + b;
        a += 2;
    }
}

A. a = 1;
B. c = a + b;
C. a += 2;
D. short a, b, c;

  12. 表达式：1 - 2 / 5 + 2 * 5的结果是哪项？D

    A. 10.6
B. 9.8
C. 9
D. 11

  13. sl的结果是哪项：A

    String s = "123";
String sl = s + 456;

A. 123456
B. 579
C. 编译错误
D. 运行时抛出异常

  14. 基本数据类型float的包装类是哪项？C

    A. Integer
B. Double
C. Float
D. Character

  15. 下面程序结果为：D

    class Test4 {
    public static void main(String[] args) {
        boolean x = true;
        boolean y = false;
        short z = 42;
        // true && true; y被赋值为true; 执行完方法体后z的值为44
        if ((z++ == 42) && (y = true)) z++;
        // false || true; z的值为46
        if ((x = false) || (++z == 45)) z++;
        System.out.println("z=" + z);
    }
}

A. z=42
B. z=44
C. z=45
D. z=46

三、流程控制与数组

  1. 下面程序结果为：D

    class TestApp {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i == 3)
                break;
            System.out.print(i);
        }
    }
}

A. 0123
B. 012456789
C. 0123456789
D. 012

  2. 下面程序结果为：B

    class TestApp {
    public static void main(String[] args) {
        int x = 6;
        if (x > 1)
            System.out.println("x>l");
        else if (x > 5)
            System.out.println("x>5");
        else if (x < 10)
            System.out.println("x5
B. x>1
C. x<10
D. x<29

  3. 下面程序结果为：C

    class TestApp {
    public static void main(String[] args) {
        int[] myarray = {10, 11, 12, 13, 14};
        int sum = 0;
        for (int x : myarray)
            sum += x;
        System.out.println("sum=" + sum);
    }
}

A. sum=10
B. sum=70
C. sum=60
D. 运行时抛出异常

  4. 下列有关数组的声明中，正确的是哪项？（选两项）CD

    A. int s[ 10];
B. int[10]s;
C. int[] s = {1, 2, 3, 4, 5};
D. int s[];

  5. 已知数组array，其最后一个元素的下标是？B

    A. array.size
B. array.length - 1
C. array.size - 1
D. array.length

  6. 下面程序结果为：B

    class TestApp {
    public static void main(String[] args) {
        int x = 5;
        switch (x) {
            case 1:
            case 2:
            case 3:
                System.out.println("一季度");
                break;
            case 4:
            case 5:
            case 6:
                System.out.println("二季度");
                break;
            default:
                System.out.println("三季度以上");
                break;
        }
    }
}

A. 一季度
B. 二季度
C. 三季度以上
D. 无输出

  7. 为将数组myArray的长度由3改为6，现采取以下编码：D

    int[] myArray = new int[3];
// 改变了myArray的引用而已
myArray = new int[6];

A. 数组myArray的长度已由3改为6，其中前3个元素的值不变，后3个元素的值为空
B. 数组myArray的长度已由3改为6，其中前3个元素的值不变，后3个元素需再经过初始化后才能使用
C. 数组myArray的长度没有变化
D. 数组myArray的长度已由3改为6，原来3个元素的值全部丢失

  8. 下面程序结果为：A

    class Ifs {
    public static void main(String[] args) {
        boolean state = false;
        int i = 2;
        // true && true; i = 4, state = true
        if ((++i > 2) && (state = true))
            i++;
        // true || false; i = 6
        if ((++i > 4) || (state = false))
            i++;
        System.out.println(i);
    }
}

A. 6
B. 5
C. 4
D. 编译失败

  9. 下面程序结果为：C

    public class Tester {
    public static void main(String[] args) {
        int x = 5;
        Integer x1 = x;
        // 5在byte区间内，因此x2会使用x1的缓存，不会new，因此x2和x1为同一个对象
        Integer x2 = x;
        // Integer会自动拆箱成int
        int x3 = new Integer(5);
        // x, x1, x2, x3值均为5

        // Integer重写了equals
        System.out.print(x1.equals(x)); // true
        // Integer与int进行==比较时，Integer会拆箱成一个int
        System.out.print(x1 == x); // true
        System.out.print(x2.equals(x1)); // true
        System.out.print(x2 == x1); // true
        System.out.print(x2 == x3); // true
        System.out.print(x2.equals(x3)); // true
    }
}

A. 编译失败
B. falsefalsetruetruetruetrue
C. truetruetruetruetruetrue
D. falsefalsetruetruetruefalse
E. truefalsetruefalsefalsetrue
F. 运行时异常被抛出

  10. 下面程序结果为：A

    class Rectangle {
    public static void main(String[] args) {
        int[] x = {1, 2, 3};
        // 2 > 1因此x[1]值为x[2]=3
        x[1] = (x[1] > 1) ? x[2] : 0;
        System.out.println(x[1]);
    }
}

A. 3
B. 2
C. 1
D. 0

  11. 下面程序结果为：C

    class Output {
    public static void main(String[] args) {
        int i = 5;
        System.out.print("4" + i + "");
        System.out.print(i + 5 + "7");
        System.out.println(i + "8");
    }
}

A. 9 9722
B. 9 55758
C. 45 10758
D. 45 9722

  12. 以下哪种初始化数组的方式是错误的？C

    A. String[] names = {"zhang", "wang", "li"};
B. String names[] = new String[3];
   names[0] = "zhang";
   names[1] = "wang";
   names[2] = "li";
C. String[3] names = {"zhang", "wang", "li"};
D. 以上皆正确

  13. 下面程序结果为：A

    class WhileTests {
    public static void main(String[] args) {
        int x = 5;
        // 先++x为6，>4不会进入循环体，会直接输出
        while (++x < 4) {
            --x;
        }
        System.out.println("x=" + x);
    }
}

A. x=6
B. x=5
C. x=2
D. 编译失败

  14. 下面程序结果为：B

    class Test2 {
    public static void main(String[] args) {
        boolean x = true;
        boolean y = false;
        short z = 20;
        // true && true; y=true, z=21
        if ((x == true) && (y = true)) z++;
        // true然后短路; z=22
        if ((y == true) || (++z == 22)) z++;
        System.out.println("z=" + z);
    }
}

A. z=21
B. z=22
C. z=23
D. z=24

  15. 下面程序结果为：B

    class Foo {
    public static void main(String[] args) {
        int x = 0;
        int y = 4;
        for (int z = 0; z < 3; z++, x++) {
            /*
            z   x   y
            0   0   4
            1   1   5
            2   2   6
            3   3   8
             */
            // &不会短路
            if (x > 1 & ++y < 10)
                y++;
        }
        System.out.println(y);
    }
}

A. 7
B. 8
C. 10
D. 12

四、封装

  1. 下列有关类、对象和实例的叙述，正确的是哪一项？D

    A. 类就是对象，对象就是类，实例是对象的另一个名称，三者没有差别
B. 对象是类的抽象，类是对象的具体化，实例是对象的另一个名称
C. 类是对象的抽象，对象是类的具体化，实例是类的另一个名称
D. 类是对象的抽象，对象是类的具体化，实例是对象的另一个名称

  2. 下列类Account的构造方法中，声明正确的是？A

    A. Account(String name) {}
B. Account(String name)
C. Account(name) ()
D. NewAccount(String name) {}

  3. 类Account中字段声明正确的是哪项？C

    A. class Account {
       name;
       amount;
   }
B. class Account {
       String name = 1.0;
       double amount = "Mike";
   }
C. class Account {
       String name;
       double amount;
   }
D. class Account {
       String name = "Mike",
       double amount = 1000.0;
   }

  4. 类Account中方法声明正确的是哪一项？C

    A. class Account {
       deposit();
   }
B. class Account {
       void deposit();
   }
C. class Account {
       void deposit() {}
   }
D. class Account {
       void deposit{}
   }

  5. 下列有关类声明的代码片段，哪一项是正确的？A

    A. package school;
   import java.sql.*;
   class Student {
   }
   
B. import java.sql.*;
   package school;
   class Student {
   }
   
C. package school;
   class Student {
   }
   import java.sql.*;
   
D. package school;
   import java.sql.*;
   private String name;
   class Student {
   }

  6. 有关new关键字的描述正确的是哪项？C

    A. 创建对象实例的时候可以不使用new关键字
B. new所创建的对象不占用内存空间
C. new会调用类的构造器来创建对象
D. new所创建的对象一定存在引用变量

  7. 下列哪些是方法public int add(int a)的重载方法？（选三项）ACD

    A. public int add(long a);
B. public void add(int a);
C. public void add(long a);
D. public int add(float a);

  8. 我们定义一个Account类来描述银行账户，银行账户有账户名、金额等属性特征，同时有存款、取款等行为特征，下述代码适合描述的是哪项？C

    A. class Account {
       String name; // 账户
       String amount; // 金额
       Account(String name) {
       }
       void deposit(double mount) { // 存款
       }
       void withdraw(double mount) { // 取款
       }
   }
B. class Account {
       String name; // 账户
       double amount; // 金额
       Account(double amount) {
       }
       void deposit(double mount) { //存款
       }
       void withdraw(double mount) { //取款
       }
   }
C. class Account {
       String name; // 账户
       double amount; // 金额
       Account(String name) {
       }
       void deposit(double mount) { // 存款
       }
       void withdraw(double mount) { // 取款
       }
   }
D. class Account {
       String name; // 账户
       double amount; // 金额
       Account(String name) {
       }
       void deposit() { // 存款
       }
       void withdraw() { // 取款
       }
   }

  9. 下面程序结果为：C

    class Banana2 {
    static int x = 2;
    public static void main(String[] args) {
        int x = 2;
        Banana2 b = new Banana2();
        // 传递的是局部的x
        b.go(x);
    }
    static {
        x += x;
    }
    void go(int x) {
        ++x;
        System.out.println(x);
    }
}

A. 7
B. 5
C. 3
D. 2

  10. 可以添加多少个修饰符来封装下面的类？D

    /**
 * 权限 final
 * 权限 abstract
 * 若是内部类还可以加static
 */
class TestFoo {
    int x;
    String y;
    int getX() {
        return x;
    }
    String getY() {
        return y;
    }
    void setX(int x) {
        int Z = 7;
        this.x = x;
    }
}

A. 5
B. 4
C. 3
D. 2

  11. 正确使用下列枚举类型的语句是哪项？B

    public enum Direction {
    EAST, SOUTH, WEST, NORTH
}

// EAST需要通过Direction来调用，且变量名不能和类型一样
Direction Direction = EAST;
// 正确
Direction direction = Direction.WEST;
// 枚举的成员也是该枚举类型
int a = Direction.NORTH;
// 不能把int型赋值给枚举
Direction direction = 2;

A. 第一句
B. 第二句
C. 第三句
D. 第四句

  12. 在注释处插入哪项代码，可以使程序正常编译和执行？C

    定义类：
package utils;
public class Rep {
    public static String twice(String s) {
        return s + s;
    }
}
再定义另一个类Demo：
// insert code here
public class Demo {
    public static void main(String[] args) {
        System.out.println(twice("Hello"));
    }
}

A. import utils.*;
B. import utils.Rep.*;
C. import static utils.Rep.twice;
D. static import utils.Rep.twice;

  13. 在Here处可以访问的变量是哪些？（选三项）ABD

    public class TestDemo {
    private int x = 2;
    static int y = 3;
    public void method() {
        final int i = 100;
        // 局部内部类只能访问final的局部变量，在JDK1.8之后，若没有加final则会默认加上
        int j = 10;
        class Cinner {
            public void mymethod() {
                // Here
            }
        }
    }
}

A. x
B. y
C. j
D. i

  14. 哪三个必须加入到类Test中，以使其通过编译？（选三项）BCD

    包结构：
com
|---X
|   |---Alpha.class
|   |
|   |---y
|       |---Beta.class
|
|---Gamma.class
类：
class Test {
    Alpha a;
    Beta b;
    Gamma c;
}

A. package y;
B. package com;
C. import com.x.y.*;
D. import com.x.*;

  15. 哪两项分别插入到类Find的注释处将编译并产生输出“doX”？（选两项）CD

    2个文件：
package x;
public class X {
    public static void doX() {
        System.out.print("doX");
    }
}
和
class Find {
    public static void main(String[] args) {
        // insert code here
    }
}

A. doX();
B. X.doX();
C. x.X.doX();
D. x.X myX = new x.X();myX.doX();

五、继承

  1. 下列关于继承优点的叙述正确的是哪几项？（选三项）ABD

    A. 可以创建更为特殊的类型
B. 消除重复代码
C. 执行效率高
D. 便于维护

  2. 在子类中调用父类中被覆盖的方法时需要使用哪项关键字？B

    A. this
B. super
C. new
D. 以上都不是

  3. 下列哪个声明是正确的覆盖了父类的change方法？C

    public class Parent {
    public void change(int x) {
    }
}

public class Child extends Parent {
    // 覆盖父类change方法
}

A. protected void change(int x) {}
B. public void change(int x, int y) {}
C. public void change(int x) {}
D. public void change(String s) {}

注：子类重写时访问权限不能比父类的低

  4. 如果想要一个类不能被任何类继承的话，需要使用哪个关键字来修饰该类？D

    A. abstract
B. new
C. static
D. final

  5. 为了使得System.out.println()输出对象引用的时候得到有意义的信息，我们应该覆盖Object的哪个方法？B

    A. equals
B. toString
C. hashCode
D. notify

  6. 下列哪项是正确的？C

    public class Pet {}
public class Cat extends Pet {}
执行代码：
Cat c = new Cat();
// 子类可以转为父类
Pet p = (Pet) c;

A. Pet p = (Pet) c运行错误
B. Pet p = (Pet) c编译错误
C. Pet p = (Pet) c正常执行
D. 以上都不对

  7. 程序输出的内容是哪项？D

    public class Pet {
    public void speak() {
        System.out.print("pet");
    }
}
public class Cat extends Pet {
    public void speak() {
        System.out.print("Cat");
    }
}
public class Dog extends Pet {
    public void speak() {
        System.out.print("Dog");
    }
}
执行代码：
Pet[] p = {new Cat(), new Dog(), new Pet()};
for (int i = 0; i < p.length; i++)
    p[i].speak();

B. Cat Cat Cat
C. Cat Dog Dog
D. Cat Dog Pet

  8. 下面哪一项是正确的？D

    class Dog {}

class Harrier extends Dog {}

class DogTest {
    public static void main(String[] args) {
        Dog dl = new Dog();
        Harrier hl = new Harrier();
        Dog d2 = hl;
        Harrier h2 = (Harrier) d2;
        // d2为Dog类型，不能把父类赋值给子类
        Harrier h3 = d2;
    }
}

A. 2个Dog对象被创建
B. 2个Harrier对象被创建
C. 3个Harrier对象被创建
D. 编译失败

  9. 下面程序结果为：C

    class Cat {
    Cat(int c) {
        System.out.print("cat" + c + " ");
    }
}
class SubCat extends Cat {
    SubCat(int c) {
        super(5);
        System.out.print("cable");
    }
    SubCat() {
        this(4);
    }
    public static void main(String[] args) {
        /**
         * 调用子类无参构造
         * 子类无参构造中调用了子类有参构造
         * 子类有参构造先调用了父类有参构造，先输出：cat5 
         * 然后输出cable
         */
        SubCat s = new SubCat();
    }
}

A. cat5
B. cable
C. cat5 cable
D. cable cat5

  10. 下面程序结果为：A

    class Guy {
    String greet() {
        return "hi";
    }
}
class Cowboy extends Guy {
    String greet() {
        return "howdy";
    }
}
class Surfer extends Guy {
    String greet() {
        return "dude! ";
    }
}
class Greetings {
    public static void main(String[] args) {
        Guy[] guys = {new Guy(), new Cowboy(), new Surfer()};
        for (Guy g : guys)
            System.out.print(g.greet());
    }
}

A. hi howdy dude!
B. 运行时异常被抛出
C. 第7行出现一个错误，编译失败
D. 第8行出现一个错误，编译失败

  11. 将下面四个方法分别插入到注释处，有几个可以通过编译？D

    class Over {
    int dolt(long x) {
        return 3;
    }
}
class Under extends Over {
    // insert code here
}
四个方法：
// 子类方法，没有重写
short dolt(int y) {return 4;}
// 子类方法，没有重写
int dolt(long x, long y) {return 4;}
// 子类方法，没有重写
private int dolt(short y) {return 4;}
// 子类重写父类方法
protected int dolt(long x) {return 4;}

A. 1
B. 2
C. 3
D. 4

  12. 下面程序结果为：D

    class Beverage {
    Beverage() {
        System.out.print("beverage ");
    }
}
class Beer extends Beverage {
    public static void main(String[] args) {
        Beer b = new Beer();
    }
    public int Beer(int x) {
        // 对构造的调用：只能出现在其他构造的第一句
        this();
        System.out.print("beerl");
        return 0;
    }
    public Beer() {
        System.out.print("beer2 ");
    }
}

A. beerl beverage
B. beer2 beverage
C. beverage beer2 beerl
D. 编译失败

  13. 下面程序结果为：C

    class Bird {
    void talk() {
        System.out.print("chirp ");
    }
}
class Parrot2 extends Bird {
    protected void talk() {
        System.out.print("hello ");
    }
    public static void main(String[] args) {
        Bird[] birds = {new Bird(), new Parrot2()};
        for (Bird b : birds)
            b.talk();
    }
}

A. chirp chirp 
B. hello hello 
C. chirp hello 
D. 编译错误

  14. 下面四个声明分别插入到注释处，有几个可以通过通过？C

    class SuperFoo {
    SuperFoo doStuff(int x) {
        return new SuperFoo();
    }
}
class Foo extends SuperFoo {
    // insert code here
}
四个声明：
Foo doStuff(int x) {
    return new Foo();
}
// 父类不能被赋值给子类
Foo doStuff(int x) {
    return new SuperFoo();
}
// 子类可以赋值给父类
SuperFoo doStuff(int x) {
    return new Foo();
}
SuperFoo doStuff(int y) {
    return new SuperFoo();
}

A. 1
B. 2
C. 3
D. 4

  15. 下列选项分别插入到注释处，哪两项允许代码编译并产生“bok choy”输出结果？（选两项）AD

    class HorseRadish {
    // insert code here
    protected HorseRadish(int x) {
        System.out.println("bok choy");
    }
}
class Wasabi extends HorseRadish {
    public static void main(String[] args) {
        Wasabi w = new Wasabi();
    }
}

A. protected HorseRadish() {this(42);}
B. protected HorseRadish() {}
C. // just a comment
D. protected HorseRadish() {new HorseRadish(42);}

注：要编译通过必须插入一个无参构造；要产生“bok choy”，则无参构造中需调用有参构造

六、抽象类与接口

  1. 下列有关抽象类的叙述正确的是哪项？B

    A. 抽象类中一定含有抽象方法
B. 抽象类的声明必须包含abstract关键字
C. 抽象类既能被实例化也能被继承
D. 抽象类中不能有构造方法

  2. 下列有关抽象方法叙述正确的是哪项？（选两项）BD

    A. 抽象方法和普通方法一样，只是前面多加一个修饰符asbtract
B. 抽象方法没有方法体
C. 抽象方法可以包含存任何类中
D. 包含抽象方法的类的具体子类必须提供具体的覆盖方法

  3. 下列有关接口的叙述错误的是哪项？D

    A. 接口中只能包含抽象方法和常量
B. 一个类可以实现多个接口
C. 类实现接口时必须实现其中的方法
D. 接口不能被继承

  4. 下列关于接口的定义哪项是正确的？C

    A. interface C {int a;} // 常量需要被初始化
B. public interface A implements B {} // 类实现接口，接口继承接口
C. public interface A {int a();}
D. abstract interface D {} // 定义接口不能使用abstract

  5. 以下三个接口声明分别插入到注释处，有多少个可以编译？C

    interface Animal {
    void eat();
}
// insert code here
public class HouseCat implements Feline {
    public void eat() {
    }
}
三个接口声明：
interface Feline extends Animal {}
interface Feline extends Animal {void eat();}
// 接口中只能是抽象方法
interface Feline extends Animal {void eat() {}}

A. 0
B. 1
C. 2
D. 3

  6. 以下六个声明分别插入到注释处，有多少行可以编译？B

    interface Color {}
interface Weight {}
//insert code here
六个声明：
class Boat extends Color, extends Weight {}
class Boat extends Color and Weight {}
class Boat extends Color, Weight {}
class Boat implements Color, implements Weight {}
class Boat implements Color and Weight {}
class Boat implements Color, Weight {}

A. 0
B. 1
C. 2
D. 3

注：类是实现接口，实现多个接口时以","分割

  7. 以下四个声明分别插入到注释处，有几个可以通过编译？C

    abstract class Color {
    protected abstract String getRGB();
}
public class Blue extends Color {
    // insert code here
}
四个声明：
public String getRGB() {
    return "blue";
}
String getRGB() {
    return "blue";
}
private String getRGB() {
    return "blue";
}
protected String getRGB() {
    return "blue";
}

A. 0
B. 1
C. 2
D. 3

注：子类重写时访问权限不能比父类的低

  8. 以下四个声明分别插入到注释处，有几个可以通过编译？D

    abstract class Color2 {
    //insert code here
}
public class Blue2 extends Color2 {
    public String getRGB() {
        return "blue";
    }
}
四个声明：
public abstract String getRGB();
abstract String getRGB();
private abstract String getRGB();
protected abstract String getRGB();

A. 0
B. 1
C. 2
D. 3

private和abstract不能一起用，因为矛盾

  9. 下面程序结果为：C

    class Top {
    static int x = 1;
    public Top() {
        x *= 3;
    }
}
class Middle extends Top {
    public Middle() {
        // super();x=3
        x += 1;
        // x=4
    }
    public static void main(String[] args) {
        Middle m = new Middle();
        System.out.println(x);
    }
}

A. 2
B. 3
C. 4
D. 编译失败

  10. 下面程序结果为：D

    两个文件：
package x;
public class X {
    public static void doX() {
        System.out.print("doX ");
    }
}
和
import x.X;
class Find {
    public static void main(String[] args) {
        X myX = new X();
        // 对象调用方法，输出doX
        myX.doX();
        // 类调用静态方法，输出doX
        X.doX();
        // 类调用静态方法，输出doX
        x.X.doX();
        x.X myX2 = new x.X();
        // 对象调用方法，输出doX
        myx2.doX();
    }
}

A. X myX = new X();行出现一个错误，编译失败
B. X.doX();行出现一个错误，编译失败
C. x.X.doX();行出现一个错误，编译失败
D. doX doX doX doX

  11. 下面程序结果为：C

    class Tree {
    private static String tree = "tree ";
    String getTree() {
        return tree;
    }
}
class Elm extends Tree {
    private static String tree = "elm ";
    public static void main(String[] args) {
        new Elm().go(new Tree());
    }
    void go(Tree t) {
        // Tree的getTree()返回tree
        // Elm.tree为elm
        // tree先在本类成员找，为elm
        // new Elm().getTree()调用父类方法，返回tree
        String s = t.getTree() + Elm.tree + tree + (new Elm().getTree());
        System.out.println(s);
    }
}

A. elm elm elm elm
B. tree elm elm elm
C. tree elm elm tree
D. tree elm tree elm

  12. 以下五个声明分别插入到注释处，有几个可以通过编译？C

    interface Animal {
    void eat();
}
//insert code here
public class HouseCat extends Feline {
    public void eat() {
    }
}
五个声明：
// 通过
abstract class Feline implements Animal {}
// 不通过，类中抽象方法要用abstract声明
abstract class Feline implements Animal {void eat();}
// 不通过，类中抽象方法要用abstract声明
abstract class Feline implements Animal {public void eat();}
// 通过
abstract class Feline implements Animal {public void eat() {}}
// 通过
abstract class Feline implements Animal {abstract public void eat();}

A. 1
B. 2
C. 3
D. 4

  13. 下面程序结果为：D

    interface I {void go();}
abstract class A implements I {}
class C extends A {
    // 接口中方法为public，实现类重写后也要是public
    void go() {}
}
A. 代码通过编译
B. 由于x interface I {void go();}行的错误导致编译失败
C. 由于abstract class A implements I {}行的错误导致编译失败
D. 由于void go() {}行的错误导致编译失败

  14. 下列类定义中正确使用Data和Info的是哪项？B

    interface Data {public void load();}
abstract class Info {public abstract void load();}

// 类实现接口不是继承
A. public class Employee implements Info extends Data {
       public void load() {/*do something*/}
   }
// 正确
B. public class Employee extends Inf implements Data {
       public void load() {/*do something*/}
   }
// 在Data中load不是静态方法
C. public class Employee implements Inf extends Data {
       public void Data.load() {/*do something*/}
       public void load() {/*do something*/}
   }
// 在Data和Info中load不是静态方法
D. public class Employee extends Inf implements Data {
       public void Data.load() {/*do something*/}
       public void Info.load() {/*do something*/}
   }

  15. 下列代码正确的是哪项？C

    A. public class Session implements Runnable, Clonable {
       // 没有方法体
       public void run();
       public Object clone();
   }
// 类实现接口，不是继承接口
B. public class Session extends Runnable, Cloneable {
       public void run() {/*do something*/}
       public Object clone() {/*make a copy*/}
   }
// 正确
C. public abstract class Session implements Runnable, Clonable {
       public void run() {/*do something*/}
       public Object clone() {/*make a copy*/}
   }
// 语法错误，只能用一个implements
D. public class Session implements Runnable, implements Clonable {
       public void run() {/*do something*/}
       public Object clone() {/*make a copy*/}
   }

七、多态

  1. 下列关于多态的叙述正确的是哪项？（选两项）AC

    A. 父类的引用指向子类的实例是一种多态
B. 子类的引用指向子类的实例是一种多态
// 接口的实例即接口实现类的实例
C. 接口的引用指向实现该接口类的实例是一种多态
D. 抽象类的引用指向抽象类的实例是一种多态

  2. Java中方法绑定有哪些形式？（选两项）AB

    A. 编译时刻绑定
B. 运行时刻绑定
C. 静态绑定
D. 私有绑定

  3. 表达式"hello" instanceof String返回的值是哪项？A

    A. true
B. false
C. 1
D. 0

  4. 求平方根方法public static double sqrt(double a)可以传递的参数类型有哪些？（选三项）ABD

    A. byte
B. float
C. String
D. long

  5. 涉及类MyClass的方法签名是public void find(MyClass a)，那么该方法可接收的实际参数的类型可以是哪些？（选两项）AB

    A. MyClass类的类型
B. MyClass子类的类型
C. Object类型
D. 所有接口

  6. 使用下列哪些关键字可以判定实参的具体类型？C

    A. as
B. is
C. instanceof
D. extends

  7. 下面程序结果为：C

    现有：
class Pencil {
    public void write(String content) {
        System.out.println("Write" + content);
    }
}
class RubberPencil extends Pencil {
    public void erase(String content) {
        System.out.println("Erase" + content);
    }
}
执行下列代码：
Pencil pen = new RubberPencil();
pen.write("Hello");
// 编译时pen是Pencil类型，没有erase方法
pen.erase("Hello");

A. Write Hello
   Erase Hello
B. Erase Hello
   Write Hello
C. 编译错误
D. 运行时抛出异常

  8. 下面程序结果为：B

    现有：
class Pencil {
    public void write(String content) {
        System.out.println("Write" + content);
    }
}
class RubberPencil extends Pencil {
    public void write(String content) {
        System.out.println("Rubber Write" + content);
    }
    public void erase(String content) {
        System.out.println("Erase " + content);
    }
}
执行下列代码：
Pencil pen = new RubberPencil();
// 非静态成员方法执行时看右边
pen.write("Hello");

A. Write Hello
B. Rubber Write Hello
C. 编译错误
D. 运行时抛出异常

  9. 下列哪些方法是在编译时刻绑定的？（选三项）ABC

    A. 静态方法
B. private方法
C. final方法
D. 非private方法

  10. 下面程序结果为：D

    现有：
class Pencil {
    public void write(String content) {
        System.out.println("Write" + content);
    }
}
class RubberPencil extends Pencil {
    public void write(String content) {
        System.out.println("Rubber Write" + content);
    }
    public void erase(String content) {
        System.out.println("Erase " + content);
    }
}
执行下列代码：
Pencil pen = new Pencil();
// 本体为父类，强转为子类会在运行时抛出类转换异常
((RubberPencil) pen).write("Hello");

A. Write Hello
B. Rubber Write Hello
C. 编译失败
D. 运行时抛出异常

  11. 下面程序结果为：B

    class TestA {
    public void start() {
        System.out.println("TestA");
    }
}
public class TestB extends TestA {
    public void start() {
        System.out.println("TestB");
    }
    public static void main(String[] args) {
        /*
        相当于：
        TestA testA = new TestB();
        testA.start();
         */
        ((TestA) new TestB()).start();
    }
}

A. TestA
B. TestB
C. 编译失败
D. 运行时抛出异常

  12. 下面程序结果为：A

    class A {public String name = "a";}
class B extends A {public String name = "b";}
执行下列代码：
A a = new B();
// 成员变量看左边
System.out.println(a.name);

A. a
B. b
C. 编译失败
D. 运行时抛出异常

  13. 下列哪行代码插入到注释处，将抛出java.lang.ClassCaseException异常？B

    interface F {}
class A implements F {}
class B extends A {}
class C extends B {
    public static void main(String[] args) {
        B b = new B();
        // insert code here
    }
}

A. A a = b;
// b本体是B，转为子类C会抛出类转换异常
B. F f = (C) b;
C. F f = (A) b;
D. B bb = (B) (A) b;

注：父类不能赋值给子类，子类可以赋值给父类

  14. 下面程序结果为：B

    class Guy {
    String greet() {
        return "hi";
    }
}
class Cowboy extends Guy {
    String greet() {
        return "howdy";
    }
}
class Wrangler extends Cowboy {
    String greet() {
        return "orch!";
    }
}
class Greetings2 {
    public static void main(String[] args) {
        Guy g = new Wrangler();
        Guy g2 = new Cowboy();
        Wrangler w2 = new Wrangler();
        // 非静态成员方法看右边
        System.out.print(g.greet() + g2.greet() + w2.greet());
    }
}

A. hi hi ouch!
B. ouch! howdy ouch!
C. hi howdy ouch!
D. 编译失败
E. 运行的咐候有异常抛出

  15. 下列哪些是正确的？（选三项）AEF

    现有：
class ClassA {}
class ClassB extends ClassA {}
class ClassC extends ClassA {}
以及：
ClassA p0 = new ClassA();
ClassB p1 = new ClassB();
ClassC p2 = new ClassC();
ClassA p3 = new ClassB();
ClassA p4 = new ClassC();

// 子类B赋值给父类A
A. p0 = p1;
// C赋值给B，C和B没关系，错误
B. p1 = p2;
// 父类A赋值给子类C，错误
C. p2 = p4;
// 本体B强转为C，C和B没关系，错误
D. p2 = (ClassC) p1;
// 本体B强转为B
E. p1 = (ClassB) p3;
// 本体C强转为C
F. p2 = (ClassC) p4;

八、异常

  1. Java语言中异常的分类是哪项？B

    A. 运行时异常和异常
B. 受检异常和非受检异常
C. 错误和异常
D. 错误和运行时异常

  2. 所有异常的父类是哪项？A

    A. Throwable
B. Error
C. RuntimeException
D. Exception

注：Error错误和Exception异常都继承了Throwable

  3. 关于try...catch...finally结构，描述正确的是哪项？（选两项）AC

    A. 可以有多个catch
B. 只能有一个catch
C. 可以没有catch
D. finally必须有

注：try必须有，catch和finally只能省略一个

  4. 下列属于非受检异常的是哪项？CD

    A. SQLException
B. IOException
C. NullPointerException
D. OutOfMemoryError

  5. 假设有自定义异常类ServiceException，那么抛出该异常的语句正确的是哪项？B

    A. raise ServiceException
B. throw new ServiceException()
C. throw ServiceException
D. throws ServiceException

  6. 在方法的声明中，要求该方法必须抛出异常时使用哪个关键字？D

    A. throw
B. catch
C. finally
D. throws

  7. 下面程序结果为：D

    class Number {
    public static void main(String[] aras) {
        try {
            System.out.print(Integer.parseInt("forty"));
        } catch (RuntimeException r) {
            System.out.print("runtime");
        } catch (NumberFormatException e) {
            // 由于多态，父类异常可以抓住子类异常，因此这里执行不到
            System.out.print("number");
        }
    }
}

A. number
B. runtime
C. forty number
D. 编译失败

  8. 如果调用topGo()，则结果为：B

    void topGo() {
    try {
        middleGo();
    } catch (Exception e) {
        System.out.print("catch");
    }
}
void middleGo() throws Exception {
    // 抛出Exception，后面不执行
    go();
    System.out.print("late middle");
}
void go() throws Exception {
    throw new Exception();
}

A. late middle
B. catch
C. late middle catch
D. catch Iate middle

  9. 下面哪两行分别插入到注释处会导致输“oops”？（选两项）AC

    class Calc {
    public static void main(String[] args) {
        try {
            int x = Integer.parseInt("42a");
            //insert code here
            System.out.print("oops");
        }
    }
}

A. }catch(IllegalArgumentException e){
B. }catch(IllegalStateException c){
C. }catch(NumbelFormatException n){
D. }catch(ClassCastException c){

注：NumberFormatException继承了IllegalArgumentException

  10. 下面程序可能会产生哪两项结果？（选两项）BC

    class Flow {
    public static void main(String[] args) {
        try {
            System.out.print("before");
            doRiskyThing();
            System.out.print("after ");
        } catch (Exception fe) {
            System.out.print("catch");
        }
        System.out.println(" done");
    }
    public static void doRiskyThing() throws Exception {
        // this code returns unless it throws an Exception
    }
}

A. before catch
// 没发生异常
B. before after done
// 发生异常
C. before catch done
D. before after catch

  11. 下面程序结果为：C

    class Birds {
    public static void main(String[] args) {
        try {
            throw new Exception();
        } catch (Exception e) {
            try {
                throw new Exception();
            } catch (Exception e2) {
                System.out.print("inner ");
            }
            System.out.print("middle ");
        }
        System.out.print("outer");
    }
}

A. inner outer
B. middle outer
C. inner middle outer
D. 编译失败

  12. 下面程序结果为：B

    class Parser extends Utils {
    public static void main(String[] args) {
        try {
            // 使用子类的getlnt，但没发生异常
            System.out.print(new Parser().getlnt("42"));
        } catch (NumberFormatException n) {
            System.out.println("NFExc");
        }
    }
    // 父类虽没抛出异常，但子类可以抛出运行时异常
    int getlnt(String arg) throws NumberFormatException {
        return Integer.parseInt(arg);
    }
}
class Utils {
    int getlnt(String arg) {
        return 42;
    }
}

A. NFExc
B. 42
C. 42NFExc
D. 编译失败

  13. 下面程序结果为：D

    class Parser extends Utils {
    public static void main(String[] args) {
        try {
            System.out.print(new Parser().getlnt("42"));
        } catch (Exception e) {
            System.out.println("Exc");
        }
    }
    // 重写时父类没抛出异常，则子类不能抛出编译时异常
    int getlnt(String arg) throws Exception {
        return Integer.parseInt(arg);
    }
}
class Utils {
    int getlnt(String arg) {
        return 42;
    }
}

A. 42
B. Exc
C. 42Exc
D. 编译失败

  14. 为使下列代码通过编译，需要在哪个方法上加入声明throws Exception？D

    class Propeller2 {
    public static void main(String[] args) {
        new Propeller2().topGo();
    }
    void topGo() {
        middleGo();
    }
    void middleGo() {
        go();
        System.out.println("late middle");
    }
    void go() {
        throw new Exception();
    }
}

A. go
B. middleGo、go
C. topGo、middleGo、go
D. main、topGo、middleGo、go

注：不断上抛，直到被catch抓住，或交给JVM

  15. 下面程序结果为：C

    class Parser extends Utils {
    public static void main(String[] args) {
        try {
            System.out.print(new Parser().getlnt("42"));
        } catch (Exception e) {
            System.out.println("Exc");
        }
    }
    int getlnt(String arg) throws Exception {
        return Integer.parseInt(arg);
    }
}
class Utils {
    int getlnt() {
        return 42;
    }
}

A. 42Exc
B. Exc
C. 42
D. 编译失败

九、多线程机制

  1. 线程由以下哪些部分组成？（选三项）ABD

    A. 虚拟的CPU
B. CPU执行的代码
C. 支持代码工作的数据
D. 进程

  2. 创建线程的时候必须实现哪项接口？A

    A. Runnable
B. Thread
C. Run
D. Start

  3. 启动一个线程的方法是哪项？C

    A. join()
B. run()
C. start()
D. sleep()

  4. 当一个处于阻塞状态的线程解除阻塞后，它将回到哪个状态？D

    A. 运行中状态
B. 结束状态
C. 新建状态
D. 可运行状态

  5. 可以通过继承哪个类来创建线程？A

    A. Thread
B. Runnable
C. Start
D. Run

  6. 为了保证方法的线程安全，声明方法的时候必须用哪个修饰符？D

    A. new
B. transient
C. void
D. synchronized

  7. 线程的默认优先级是哪项？C

    A. 0
B. 1
C. 5
D. 10

  8. 下面程序结果为：D

    class Thread2 implements Runnable {
    // 子类实现方法时访问权限不能比父类的低
    void run() {
        System.out.print("go");
    }
    public static void main(String[] args) {
        Thread2 t2 = new Thread2();
        Thread t = new Thread(t2);
        t.start();
    }
}

A. go
B. 运行时异常被抛出
C. 代码运行，无输出结果
D. 编译失败

  9. 程序员想要创建一个名为MyThread的类以便在main方法中用Thread实例化。对于下面三行有几行是正确的？A

    // 实现Runnable或Callable也可以
MyThread必须继承Thread
MyThread必须实现Thread
// 也可以覆盖Callable的V call() throws Exception;
MyThread必须覆盖public void run()

A. 0
B. 1
C. 2
D. 3

  10. 下面程序结果为：A

    class ThreadBoth extends Thread implements Runnable {
    public void run() {
        System.out.print("hi ");
    }
    public static void main(String[] args) {
        Thread tl = new ThreadBoth();
        Thread t2 = new Thread(tl);
        tl.run();
        t2.run();
    }
}

A. hi hi
B. hi
C. 编译失败
D. 运行时异常被抛出

  11. t是一个合法的Thread对象的引用，并且t的合法run()方法如下，则哪一个是结果？C

    t的合法run()方法：
public void run() {
    System.out.print("go");
}
及：
t.start();
// 一个线程只能启动一次
t.start();
// 一个普通的函数调用
t.run();

A. go go
B. go go go
C. go之后跟着一个异常
D. go go之后跟着一个异常

  12. 下面程序结果为：C

    class ThreadExcept implements Runnable {
    public void run() {
        throw new RuntimeException("exception ");
    }
    public static void main(String[] args) {
        // 抛出异常，没有处理就交给jvm
        // 不会影响主线程
        new Thread(new ThreadExcept()).start();
        try {
            int x = Integer.parseInt(args[0]);
            // 先睡眠x毫秒，然后输出main
            Thread.sleep(x);
            System.out.print("main");
        } catch (Exception e) {
        }
    }
}
和命令行：
java ThreadExcept 1000

A. main
B. 编译失败
C. java.lang.RuntimeException: exception main
D. 代码运行，但没有输出

  13. 哪一个插入到注释处，最有可能产生输出rmrmrmrm？E

    class Order2 implements Runnable {
    public void run() {
        for (int x = 0; x < 4; x++) {
            try {
                Thread.sleep(100);
            } catch (Exception e) {
            }
            System.out.print("r");
        }
    }
    public static void main(String[] args) {
        Thread t = new Thread(new Order2());
        t.start();
        for (int x = 0; x < 4; x++) {
            // insert code here
            System.out.print("m");
        }
    }
}

A. Thread.sleep(1);
B. Thread.sleep(100);
C. Thread.sleep(1000);
// sleep方法会抛出异常
D. try {Thread.sleep(1);} catch (Exception e) {}
// 当两个线程睡眠时间相同时，最有可能按顺序执行，输出rmrmrmrm
E. try {Thread.sleep(100);} catch (Exception e) {}
F. try {Thread.sleep(1000);} catch (Exception e) {}

  14. 以下哪两项是正确的？（选两项）BF

    class Waiting implements Runnable {
    boolean flag = false;
    public synchronized void run() {
        if (flag) {
            flag = false;
            System.out.print("1 ");
            try {
                this.wait();
            } catch (Exception e) {
            }
            System.out.print("2 ");
        } else {
            flag = true;
            System.out.print("3 ");
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
            }
            System.out.print("4 ");
            notify();
        }
    }
    public static void main(String[] args) {
        Waiting w = new Waiting();
        /*
        此线程先执行，由于同步，其他线程在此期间进不来
        先判断flag为false，将flag置为true
        先输出3，然后睡眠2秒，sleep不会释放锁对象
        睡眠后输出4，然后执行notify()
         */
        new Thread(w).start();
        /*
        上面线程先执行，将flag置为了true，
        此线程判断为true，然后将flag置为false
        然后输出1，等待
        因为上面线程已经执行完了，因此此线程不会被唤醒
        程序陷入死锁
         */
        new Thread(w).start();
    }
}

A. 代码输出1 3 4
B. 代码输出3 4 1
C. 代码输出1 2 3 4
D. 代码输出1 3 4 2
E. 代码运行完毕
F. 代码不会完成

  15. 下面程序可产生哪两项结果？（选两项）AD

    class Order implements Runnable {
    public void run() {
        try {
            Thread.sleep(2000);
        } catch (Exception e) {
            System.out.print("in");
        }
    }
    public static void main(String[] args) {
        Thread t = new Thread(new Order());
        // 开启线程，会先睡眠2秒
        /*
        若睡眠时，main还没拿到CPU
        且t线程再次执行时出现异常，则先输出in
         */
        t.start();
        // 先输出pre
        System.out.print("pre ");
        try {
            // t执行完main才能执行，过程可能抛出异常，输出in
            t.join();
        } catch (Exception e) {
        }
        // 最后执行post
        System.out.print("post");
    }
}

A. pre in post
B. pre in
C. in post pre
D. in pre post
E. pre post in

十、输入输出流

  1. 下列哪项是Java语言中所定义的字节流？D

    A. Output
B. Reader
C. Writer
D. InputStream

  2. 在输入流的read方法返回哪个值的时候表示读取结束？C

    A. 0
B. 1
C. -1
D. null

  3. 为了从文本文件中逐行读取内容，应该使用哪个处理流对象？A

    A. BufferedReader
B. BufferedWriter
C. BufferedInputStream
D. BufferedOutputStream

注：BufferedReader有readLine()方法

  4. 为了实现自定义对象的序列化，该自定义对象必须实现哪个接口？B

    A. Volatile
B. Serializable
C. Runnable
D. Transient

  5. 以下关于File类的叙述，哪两项正确？（选两项）AD

    A. File类位于java.io包中
B. 创建一个File类的实例将导致打开指定文件进行读写
C. File实例不能用于封装目录
D. File实例封装了指定文件的信息

  6. 删除File实例所对应文件的方法是？C

    A. mkdir
B. exists
C. delete
D. isHidden

  7. 下面程序结果为：B

    import java.util.*;
class ScanStuff {
    public static void main(String[] args) {
        String s = "x,yy,123";
        // 构造一个新的Scanner，它生成的值是从指定字符串扫描的
        // Scanner(String source)
        Scanner sc = new Scanner(s);
        // 将字符串中的字符逐个输出
        while (sc.hasNext())
            System.out.print(sc.next() + " ");
    }
}

A. x yy
B. x,yy,123
C. x yy 123
D. x,yy
E. 编译失败
F. 运行的时候有异常抛出

  8. 哪一行代码插入到注释处将循环通过一个文本文件并从文本域中每次输出一行？D

    现有：
一f对一个java.io.File型实例的合法引用
一fr对一个java.io.FileReader型实例的合法引用
一br对一个java.io.BufferedReader型实例的合法引用
和：
String line = null;
    //insert code here
    System.out.println(line);
}

A. while ((line = f.read()) != null) {
B. while ((line = fr.read()) != null) {
C. while ((line = br.read()) != null) {
D. while ((line = br.readLine()) != null) {
E. while ((line = fr.readLine()) != null) {
F. while ((line = f.readLine()) != null) {

注：readLine()是BufferedReader的方法

  9. 下面哪一项正确？B

    int x = reader.read();

A. 阅读器不是FileReader或者BufferedReader类型
B. 阅读器可以是FileReader或者BufferedReader类型
C. 阅读器可以是FileReader类型，但不能是BufferedReader类型
D. 阅读器可以是BufferedReader类型，但不能是FileReader类型

  10. 下面哪一项正确？D

    String s = "write a line to a file";
w.print(s + "\n");

A. w即可以是PrintWriter类型，也可以是BufferedWriter类型
B. w即不可以是PrintWriter类型，也不可以是BufferedWriter类型
C. w可以是BufferedWriter类型，但不可以是PrintWriter类型
D. w可以是PrintWriter类型，但不可以是BufferedWriter类型

  11. 下面哪两个是合法的？（选两项）CF

    现有：
f是一个合法的java.io.File实例的引用
fr是一个合法的java.io.FileReader实例的引用
br是一个合法的java.io.BufferedReader实例的引用

// File(File parent, String child)
A. File f2 = new File(f);
// FileReader构造不可以传FileReader
B. FileReader fr2 = new FileReader(fr);
// FileReader构造可以传File
C. FileReader fr2 = new FileReader(f);
// FileReader构造不可以传BufferedReader
D. FileReader fr2 = new FileReader(br);
// BufferedReader只能传递Reader及其子类
E. BufferedReader br2 = new BufferedReader(f);
F. BufferedReader br2 = new BufferedReader(fr);

  12. 以下哪一项无效？D

    现有：
f是一个对java.io.File实例的合法引用
fw是一个对java.io.FileWriter实例的合法引用
bw足一个对java.io.BufferedWriter实例的合法引用

// PrintWriter(File file)
A. PrintWriter prtWtr = new PrintWriter(f);
// PrintWriter(Writer out)
B. PrintWriter prtWtr = new PrintWriter(fw);
// PrintWriter(Writer out)
C. PrintWriter prtWtr = new PrintWriter(bw);
// BufferedReader只能传递Reader及其子类
D. BufferWriter bufWtr = new BufferedWritr(f);
E. BufferWriter bufWtr = new BufferedWriter(fw);
F. BufferWriter bufWtr = new BufferedWriter(bw);

  13. 下面程序结果为：E

    import java.io.PrintWriter;
class DoFormat {
    public static void main(String[] args) {
        int x = 42;
        int y = 12345;
        float z = 7;
        System.out.format("-%4d- ", x);
        System.out.format("-%4d- ", y);
        // 应该是%4.1f
        System.out.format("-%4.1d-", z);
    }
}

A. 编译失败
B. -42--1234-- 7.0-
C. -  42--1234-- 7.0-
D. -  42--12345-- 7.0-
E. 运行时异常被抛出

  14. 如果试图序列化一个Ford实例，结果为：C

    class Car implements Serializable {}
class Ford extends Car {}

A. 编译失败
B. 两个对象被序列化
C. 一个对象被序列化
D. 运行时异常被抛出

一个Ford

如果子类实现Serializable接口而父类未实现时，父类不会被序列化；
如果父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口。

  15. 如果Pet实例被序列化，则多少对象将被序列化？E

    class Pet implements Serializable {
    Collar c = new Collar();
}
class Collar implements Serializable {
    CollarPart cpl = new CollarPart();
    CollarPart cp2 = new CollarPart();
}
class CollarPart implements Serializable {}

A. 0
B. 1
C. 2
D. 3
E. 4
F. 5

一个pet，一个Collar，两个CollarPart

当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化

十一、使用泛型和集合框架

  1. 集合API中Set接口的特点是哪项？D

    A. 不允许重复元素，元素有顺序
B. 允许重复元素，元素无顺序
C. 允许重复元素，元素有顺序
D. 不允许重复元素，元素无顺序

  2. 实现了Set接口的类是哪项？C

    A. ArrayList
B. HashTable
C. HashSet
D. Collection

  3. 表示键值对概念的接口是哪项？D

    A. Set
B. List
C. Collection
D. Map

  4. List接口的特点是哪项？C

    A. 不允许重复元素，元素无顺序
B. 不允许重复元素，元素无顺序
C. 允许重复元素，元素有顺序
D. 允许重复元素，元素无顺序

  5. 下列哪些项是泛型的优点？（选两项）AC

    A. 不用向下强制类型转换
B. 代码容易编写
C. 类型安全
D. 运行速度快

  6. 创建一个只能存放String的泛型ArrayList的语句是哪项？B

    A. ArrayList al = new ArrayList();
B. ArrayList al = new ArrayList();
// 创建集合时不写泛型，则可以存储任意引用类型数据
C. ArrayList al = new ArrayList();
// List是接口
D. ArrayList al = new List();

  7. 下面程序结果为：C

    public class Demo {
    public static void main(String[] args) {
        List a1 = new ArrayList();
        a1.add("l");
        a1.add("2");
        a1.add("2");
        a1.add("3");
        System.out.println(a1);
    }
}

A. [1, 2, 3]
B. [1, 2, 3, 3]
C. [1, 2, 2, 3]
D. [2, 1, 3, 2]

  8. 哪一行插入到注释处将导致输出“abc"？D

    import java.util.*;
class ForInTest {
    static List list = new ArrayList();
    public static void main(String[] args) {
        list.add("a");
        list.add("b");
        list.add("c");
        //insert code here
        System.out.print(o);
    }
}

A. for (Iterator o : list.iterator(); o.hasNext(); )
B. for (Iterator o : list)
C. for (Object o : list.iterator())
D. for (Object o : list)

增强for格式：for (元素类型 变量名 : 数组名或集合对象) {}

  9. 下面程序结果为：E

    import java.util.*;
class AddStuff2 {
    public static void main(String[] args) {
        // TreeSet内的元素有一定的顺序
        TreeSet t = new TreeSet();
        if (t.add("one "))
            if (t.add("two "))
                if (t.add("three "))
                    t.add("four ");
        for (String s : t)
            System.out.print(s);
    }
}

A. one
B. one three two
C. one two three
D. one two three four
E. four one three two
F. 编译失败

  10. 哪两个是同步的？（选两项）BC

    A. java.util.TreeSet
B. java.util.Hashtable
C. java.util.Vector
D. java.util.LinkedList

  11. 哪两个是合法的？（选两项）BE

    list是一个合法的集合引用
getCollection()返回一个合法集合的引用

A. for (Object o ; list)
B. for (Object o : getCollection())
C. for (Object o : list.iterator())
D. for (Iterator i; list.iterator(); i.hasNext())
E. for (Iterator i = list.iterator(); i.hasNext(); )

  12. 哪一组匹配是对的？B

    现有如下类型：
a - java.util.Hashtable
b - java.util.List
c - java.util.ArrayList
d - java.util.SortedSet
和定义：
1 - 使用本接口，允许用户控制集合中每个元素的插入位置。b
2 - 使用本集合，确保用户可以按照递增或元素的自然顺序遍历集合。d
3 - 本具体类型允许空元素及基于索引的访问。c
4 - 本集合是同步的。a

A. 2描述d；3描述b。
B. 1描述b；3描述C。
C. 3描述a；4描述b。
D. 4描述a；2描述C。

  13. 四个代码片段分别插入到注释处，哪项可以编译？A

    现有：
import java.util.*;
class AddStuff {
    public static void main(String[] args) {
        TreeSet s = new TreeSet();
        s.add("one");
        s.add("two");
        //insert code here
        for (String s2 : sorted)
            System.out.print(s2 + " ");
    }
}
四个代码片段：
// 创建集合时不写泛型，则可以存储任意引用类型数据，而下面要求String
s1: SortedSet sorted = s.tailSet(s.first());
s2: SortedSet sorted = s.tailSet(s.first());
s3: SortedSet sorted = (SortedSet) s.tailSet(s.first());
// 泛型不存在继承关系
// 相当于把SortSet赋值给了SortSet，错误
s4: SortedSet sorted = (SortSet) s.tailSet(s.first());

A. s2
B. s1
C. s2和s3
D. s2和s4
E. s2, s3和s4
F. sl, s2, s3和s4
 

  14.  
    注释处插入哪一项将输出abc？D
     
    class ForInTest {
    static List list = new ArrayList();
    static List getList() {
        return list;
    }
    public static void main(String[] args) {
        list.add("a");
        list.add("b");
        list.add("c");
        // insert code here
        System.out.print(o);
    }
}

// 题中list中存储的是String
A. for (char o : list)
B. for (Object o : o.getList())
C. for (Object o : getList() ; )
D. for (Object o : getList())
E. for (Object o : o.getList() ; )

     
    15. 

  15.  
    下列选项分别插入到注释处，哪三行允许代码编译？（选三项）BDF
     
    import java.util.*;
class FindStuff {
    public static void main(String[] args) {
        //insert code here
        c.put("X", 123);
    }
}

// SortedMap是抽象类，不能实例化
A. Map c = new SortedMap();
B. HashMap c = new HashMap();
// Hashtable和HashMap没关系
C. HashMap c = new Hashtable();
D. SortedMap c = new TreeMap();
// ArrayList没有put方法
E. ArrayList c = new ArrayList();
F. Map c = new LinkedHashMap();

     
    16. 







    



    


    


    




    

    你可能感兴趣的:(Java SE-13-基础练习题)
    

    

    

      

    • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）
华为OD题库
华为od链表java

      须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
      

      • 

    • 学习JavaEE的日子 Day32 线程池
A 北枝
学习JavaEE学习java-eejava线程池

      Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
      

      • 

    • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？
AaronWang94
shirojavajava安全开发语言

      请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
      

      • 

    • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？
大龄下岗程序员
mysqljavamysqlspring

      Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
      

      • 

    • 3、JavaWeb-Ajax/Axios-前端工程化-Element
所谓远行Misnearch
#JavaWeb前端ajaxelementuijava前端框架

      P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
      

      • 

    • 枚举使用笔记
万变不离其宗_8
项目笔记笔记

      1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
      

      • 

    • Python dict字符串转json对象，小数精度丢失问题
朝如青丝 暮成雪
jsonpython

      一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
      

      • 

    • java实体中返回前端的double类型四舍五入（格式化）
婲落ヽ紅顏誶
java

      根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f
      

      • 

    • Java中HashMap底层数据结构及主要参数?
山间漫步人生路
java数据结构开发语言

      在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
      

      • 

    • Java学习笔记01
.wsy.
日常java学习笔记

      1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
      

      • 

    • Java回溯知识点（含面试大厂题和源码）
一成码农
java面试开发语言

      回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
      

      • 

    • Azkaban各种类型的Job编写
__元昊__

      一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
      

      • 

    • java基础相关面试题详细总结
。。。。。96
java开发语言

      1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
      

      • 

    • javascript 日期转换为时间戳，时间戳转换为日期的函数
cdcdhj
javascript学习日记javascript开发语言ecmascript

      日期转化为时间戳，主要用valueOf()来进行转化为毫秒时间戳，getTime()IOS系统无法解析转换，所以都有valueOf()letgetTimestampOrDate=function(timestamp){lettimeStamp='';constregex=/^\d{4}(-|\/)\d{2}(-|\/)\d{2}$/;constregex2=/^\d{4}(-|\/)\d{2}(-
      

      • 

    • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法
杰哥在此
Java系列javajvm算法面试

      Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
      

      • 

    • COMP315 JavaScript Cloud Computing for E Commerce
zhuyu0206girl
javascript开发语言ecmascript

      Assignment1:Javascript1IntroductionAcommontaskincloudcomputingisdatacleaning,whichistheprocessoftakinganinitialdatasetthatmaycontainerroneousorincompletedata,andremovingorfixingthoseelementsbeforeform
      

      • 

    • JSON与AJAX：网页交互的利器
入冉心
jsonajax前端

      在现代Web开发中，JSON（JavaScriptObjectNotation）和AJAX（AsynchronousJavaScriptandXML）是两项不可或缺的技术。它们共同为网页提供了动态、实时的数据交互能力，为用户带来了更加流畅和丰富的体验。本文将详细介绍JSON和AJAX的概念、原理，并通过代码示例展示它们在实际开发中的应用。一、JSON：轻量级的数据交换格式JSON是一种轻量级的数据
      

      • 

    • 程序员开发技术整理
laizhixue
学习前端框架

      前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
      

      • 

    • javascript的数据类型及转换
田小田txt

      一、JavaScript数据类型：共有string，number，boolean，object，function五种数据类型；其中Object，Date，Array为对象型；2个不包含任何值的数据类型：null，undefined。二、Typeof查看数据类型：typeof"John"//返回stringtypeof3.14//返回numbertypeofNaN//返回numbertypeoffa
      

      • 

    • java线程之Lock的使用
dimdark

      目标:大致介绍一下java.util.concurrent.locks包下的类,接口及其常用方法1.Lock接口Lock接口使用Lock接口的最佳模式:publicvoidmethod()throwInterruptedException{try{lock.lock();//lock.lockUninterruptibly();}finally{lock.unlock();}}用户必须手动释放Lo
      

      • 

    • 第六届蓝桥杯大赛软件赛省赛Java 大学C组题解
爱跑步的程序员~
刷题蓝桥杯省赛

      文章目录A隔行变色思路解题方法复杂度CodeB立方尾不变思路解题方法复杂度CodeC无穷分数思路解题方法复杂度CodeD奇妙的数字思路解题方法复杂度CodeE移动距离思路解题方法复杂度CodeF垒骰子思路解题方法复杂度CodeA隔行变色思路这是一个简单的计数问题。我们需要找出21到50之间的奇数数量。奇数行将被染成蓝色，偶数行将被染成白色。解题方法我们可以使用一个for循环从21遍历到50，然后使
      

      • 

    • Java学习笔记04：Java_数组
JasonYangQ
Javajava

      文章目录1.数组1.1数组介绍1.2数组的定义格式1.2.1第一种格式1.2.2第二种格式1.3数组的动态初始化1.3.1什么是动态初始化1.3.2动态初始化格式1.3.3动态初始化格式详解1.4数组元素访问1.4.1什么是索引1.4.2访问数组元素格式1.4.3示例代码1.5内存分配1.5.1内存概述1.5.2java中的内存分配1.9数组的静态初始化1.9.1什么是静态初始化1.9.2静态初始
      

      • 

    • 【设计模式】Java 设计模式之桥接模式（Bridge）
新手村长
Java设计模式设计模式java桥接模式

      桥接模式（BridgePattern）是结构型设计模式的一种，它主要解决的是抽象部分与实现部分的解耦问题，使得两者可以独立变化。这种类型的设计模式属于结构型模式，因为该模式涉及如何组合接口和它们的实现。将抽象部分与实现部分分离，使它们都可以独立地变化。一、桥接模式概述桥接模式的主要思想是将抽象与实现进行解耦，使得二者可以独立进行变化。在桥接模式中，抽象部分和实现部分被分离出来，抽象部分定义了一个抽
      

      • 

    • 基于SSM+Vue企业销售培训系统 企业人才培训系统 企业课程培训管理系统 企业文化培训班系统Java
计算机程序老哥

      作者主页：计算机毕业设计老哥有问题可以主页问我一、开发介绍1.1开发环境开发语言：Java数据库：MySQL系统架构：B/S后端：SSM(Spring+SpringMVC+Mybatis)前端：Vue工具：IDEA或者Eclipse，JDK1.8，Maven二、系统介绍2.1图片展示注册登录页面：登陆.png前端页面功能：首页、培训班、在线学习、企业文化、交流论坛、试卷列表、系统公告、留言反馈、个
      

      • 

    • java selenium 元素点击不了
马达马达达
selenium测试工具

      最近做了一个页面爬取，很有意思被机缘巧合下解决了。这个元素很奇怪，用xpath可以定位元素，但是就是click()不了。试过了网上搜的一些办法：//尝试一WebElementa_tag=driver.findElement(By.xpath("xxx"));a_tag.click();//点击不了，卡住//尝试二WebDriverWaitwait=newWebDriverWait(driver,1
      

      • 

    • 【Java初阶（三）】方法的使用
PU-YUHAN
Java从入门到精通java开发语言递归方法

      ❣博主主页:33的博客❣▶文章专栏分类:Java从入门到精通◀我的代码仓库:33的代码仓库目录1.前言2.方法的概念2.1方法定义2.2实参和形参的关系3.方法的重载3.1方法重载的概念4.递归4.1递归的概念4.2递归过程分析4.3递归练习5.总结1.前言在前面的学习中，我们已经学习了Java的部分知识，包括数据类型与变量，运算符，分支与循环以及输入和输出这些基础知识，我们继续对Java的学习进
      

      • 

    • 解析XML文件的几种方式？
人生在勤，不索何获
xml

      在Java中解析XML文件可以通过多种方式完成，其中最常用的有DOM（DocumentObjectModel）、SAX（SimpleAPIforXML）和StAX（StreamingAPIforXML）。每种方式有其特点和适用场景。1.DOM解析DOM解析是一种将整个XML文档加载到内存中，构造成一个树形结构，然后你可以很方便地访问任何数据节点的方法。这种方法适用于需要频繁读写操作的场景。impo
      

      • 

    • javascript实现SM2加密解密
人生在勤，不索何获
javascript前端jquery

      前提JavaWeb环境前端代码window.sm2=function(t){functioni(e){if(r[e])returnr[e].exports;varn=r[e]={i:e,l:!1,exports:{}};returnt[e].call(n.exports,n,n.exports,i),n.l=!0,n.exports}varr={};returni.m=t,i.c=r,i.d=fu
      

      • 

    • Vue：为什么要使用v-cloak
刻刻帝的海角
vue.js前端javascript

      Vue.js是一种流行的JavaScript框架，它使我们能够构建交互性强大的用户界面。在Vue.js中，v-cloak是一个指令，用于解决在页面加载时出现的闪烁问题。本文将介绍如何使用v-cloak及代码来优化Vue.js应用程序的渲染效果。引言当我们使用Vue.js构建应用程序时，有时会遇到一个问题：在页面加载时，由于Vue.js需要一定的时间来解析和渲染模板，会导致页面上显示出未经处理的Mu
      

      • 

    • JavaScript快速入门笔记之二（变量、常量、数据类型）
eshineLau
前端开发javascript笔记前端

      JavaScript快速入门笔记之二（变量、常量、数据类型）1、变量何时使用变量：程序中的一切数据都要保存在变量中，反复使用如何使用变量：2种情况：赋值和取值赋值：2步：1.1创建变量：——声明——创建一个新的空变量语法：var变量名;强调：仅声明，未赋值的变量，默认值是undefined命名：1.不能以数字开头2.不能用保留字。3.一般采用驼峰命名1.2赋值：将数据保存到变量中语法：变量名=数据
      

      • 

    • web前段跨域nginx代理配置
刘正强
nginxcmsWeb

      nginx代理配置可参考server部分
server {
        listen       80;
        server_name  localhost;

      

      • 

    • spring学习笔记
caoyong
spring

      一、概述
    a>、核心技术 : IOC与AOP
b>、开发为什么需要面向接口而不是实现
    接口降低一个组件与整个系统的藕合程度，当该组件不满足系统需求时，可以很容易的将该组件从系统中替换掉，而不会对整个系统产生大的影响
c>、面向接口编口编程的难点在于如何对接口进行初始化,(使用工厂设计模式) 
      

      • 

    • Eclipse打开workspace提示工作空间不可用
0624chenhong
eclipse

      做项目的时候，难免会用到整个团队的代码，或者上一任同事创建的workspace，
1.电脑切换账号后，Eclipse打开时，会提示Eclipse对应的目录锁定，无法访问，根据提示，找到对应目录，G:\eclipse\configuration\org.eclipse.osgi\.manager，其中文件.fileTableLock提示被锁定。
解决办法，删掉.fileTableLock文件，重
      

      • 

    • Javascript 面向对面写法的必要性？
一炮送你回车库
JavaScript

      现在Javascript面向对象的方式来写页面很流行，什么纯javascript的mvc框架都出来了：ember
这是javascript层的mvc框架哦,不是j2ee的mvc框架
 
我想说的是，javascript本来就不是一门面向对象的语言，用它写出来的面向对象的程序，本身就有些别扭，很多人提到js的面向对象首先提的是：复用性。那么我请问你写的js里有多少是可以复用的，用fu
      

      • 

    • js array对象的迭代方法
换个号韩国红果果
array

      1.forEach 该方法接受一个函数作为参数， 对数组中的每个元素
使用该函数  return 语句失效
function square(num) {
print(num, num * num);
}
var nums = [1,2,3,4,5,6,7,8,9,10];
nums.forEach(square);
2.every 该方法接受一个返回值为布尔类型
      

      • 

    • 对Hibernate缓存机制的理解
归来朝歌
session一级缓存对象持久化

      在hibernate中session一级缓存机制中，有这么一种情况：
问题描述：我需要new一个对象，对它的几个字段赋值，但是有一些属性并没有进行赋值，然后调用
session.save()方法，在提交事务后，会出现这样的情况：
1：在数据库中有默认属性的字段的值为空
2：既然是持久化对象，为什么在最后对象拿不到默认属性的值？
通过调试后解决方案如下：
对于问题一，如你在数据库里设置了
      

      • 

    • WebService调用错误合集
darkranger
webservice

       Java.Lang.NoClassDefFoundError: Org/Apache/Commons/Discovery/Tools/DiscoverSingleton
调用接口出错，
一个简单的WebService
import org.apache.axis.client.Call;import org.apache.axis.client.Service;
首先必不可
      

      • 

    • JSP和Servlet的中文乱码处理
aijuans
Java Web

      JSP和Servlet的中文乱码处理
前几天学习了JSP和Servlet中有关中文乱码的一些问题，写成了博客，今天进行更新一下。应该是可以解决日常的乱码问题了。现在作以下总结希望对需要的人有所帮助。我也是刚学，所以有不足之处希望谅解。
一、表单提交时出现乱码：
在进行表单提交的时候，经常提交一些中文，自然就避免不了出现中文乱码的情况，对于表单来说有两种提交方式：get和post提交方式。所以
      

      • 

    • 面试经典六问
atongyeye
工作面试

      题记：因为我不善沟通，所以在面试中经常碰壁，看了网上太多面试宝典，基本上不太靠谱。只好自己总结，并试着根据最近工作情况完成个人答案。以备不时之需。
以下是人事了解应聘者情况的最典型的六个问题：
1 简单自我介绍
关于这个问题，主要为了弄清两件事，一是了解应聘者的背景，二是应聘者将这些背景信息组织成合适语言的能力。
我的回答：(针对技术面试回答，如果是人事面试，可以就掌
      

      • 

    • contentResolver.query()参数详解
百合不是茶
androidquery()详解

      收藏csdn的博客,介绍的比较详细,新手值得一看 1.获取联系人姓名
一个简单的例子，这个函数获取设备上所有的联系人ID和联系人NAME。
[java] 
view plain
copy  
public void fetchAllContacts() {  
   
      

      • 

    • ora-00054:resource busy and acquire with nowait specified解决方法
bijian1013
oracle数据库killnowait

              当某个数据库用户在数据库中插入、更新、删除一个表的数据，或者增加一个表的主键时或者表的索引时，常常会出现ora-00054:resource busy and acquire with nowait specified这样的错误。主要是因为有事务正在执行（或者事务已经被锁），所有导致执行不成功。
1.下面的语句
      

      • 

    • web 开发乱码
征客丶
springWeb

      以下前端都是 utf-8 字符集编码
一、后台接收
1.1、 get 请求乱码
get 请求中，请求参数在请求头中；
乱码解决方法：
a、通过在web 服务器中配置编码格式：tomcat 中，在 Connector 中添加URIEncoding="UTF-8"；
1.2、post 请求乱码
post 请求中，请求参数分两部份，
1.2.1、url？参数，
      

      • 

    • 【Spark十六】： Spark SQL第二部分数据源和注册表的几种方式
bit1129
spark

      Spark SQL数据源和表的Schema
case class
apply schema
parquet
json
JSON数据源 准备源数据
{"name":"Jack", "age": 12, "addr":{"city":"beijing&
      

      • 

    • JVM学习之:调优总结 -Xms -Xmx -Xmn -Xss
BlueSkator
-Xss-Xmn-Xms-Xmx

       
堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。典型设置：
java -Xmx355
      

      • 

    • jqGrid 各种参数 详解(转帖)
BreakingBad
jqGrid

       
jqGrid 各种参数 详解 分类： 
源代码分享 
个人随笔请勿参考 
解决开发问题 2012-05-09 20:29   84282人阅读  
评论(22)  
收藏  
举报
jquery
服务器
parameters
function
ajax
string   
      

      • 

    • 读《研磨设计模式》-代码笔记-代理模式-Proxy
bylijinnan
java设计模式

      声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/*
* 下面
      

      • 

    • 应用升级iOS8中遇到的一些问题
chenhbc
ios8升级iOS8

      1、很奇怪的问题，登录界面，有一个判断，如果不存在某个值，则跳转到设置界面，ios8之前的系统都可以正常跳转，iOS8中代码已经执行到下一个界面了，但界面并没有跳转过去，而且这个值如果设置过的话，也是可以正常跳转过去的，这个问题纠结了两天多，之前的判断我是在
-(void)viewWillAppear:(BOOL)animated
 中写的，最终的解决办法是把判断写在
-(void
      

      • 

    • 工作流与自组织的关系？
comsci
设计模式工作

        目前的工作流系统中的节点及其相互之间的连接是事先根据管理的实际需要而绘制好的，这种固定的模式在实际的运用中会受到很多限制，特别是节点之间的依存关系是固定的，节点的处理不考虑到流程整体的运行情况，细节和整体间的关系是脱节的，那么我们提出一个新的观点，一个流程是否可以通过节点的自组织运动来自动生成呢？这种流程有什么实际意义呢？
  这里有篇论文，摘要是：“针对网格中的服务
      

      • 

    • Oracle11.2新特性之INSERT提示IGNORE_ROW_ON_DUPKEY_INDEX
daizj
oracle

      insert提示IGNORE_ROW_ON_DUPKEY_INDEX
转自：http://space.itpub.net/18922393/viewspace-752123
在 insert into tablea ...select * from tableb中，如果存在唯一约束，会导致整个insert操作失败。使用IGNORE_ROW_ON_DUPKEY_INDEX提示，会忽略唯一
      

      • 

    • 二叉树:堆
dieslrae
二叉树

          这里说的堆其实是一个完全二叉树,每个节点都不小于自己的子节点,不要跟jvm的堆搞混了.由于是完全二叉树,可以用数组来构建.用数组构建树的规则很简单:
    一个节点的父节点下标为: (当前下标 - 1)/2
    一个节点的左节点下标为: 当前下标 * 2 + 1
  &
      

      • 

    • C语言学习八结构体
dcj3sjt126com
c

      为什么需要结构体，看代码
# include <stdio.h>
struct Student //定义一个学生类型，里面有age, score, sex, 然后可以定义这个类型的变量
{
int age;
float score;
char sex;
}
int main(void)
{
struct Student st = {80, 66.6,
      

      • 

    • centos安装golang
dcj3sjt126com
centos

      #在国内镜像下载二进制包
wget -c  http://www.golangtc.com/static/go/go1.4.1.linux-amd64.tar.gz
tar -C /usr/local -xzf go1.4.1.linux-amd64.tar.gz
 
#把golang的bin目录加入全局环境变量
cat >>/etc/profile<
      

      • 

    • 10.性能优化-监控-MySQL慢查询
frank1234
性能优化MySQL慢查询

      1.记录慢查询配置
show variables where variable_name like 'slow%' ; --查看默认日志路径
查询结果：--不用的机器可能不同
slow_query_log_file=/var/lib/mysql/centos-slow.log
修改mysqld配置文件：/usr /my.cnf[一般在/etc/my.cnf，本机在/user/my.cn
      

      • 

    • Java父类取得子类类名
happyqing
javathis父类子类类名

       
在继承关系中，不管父类还是子类，这些类里面的this都代表了最终new出来的那个类的实例对象，所以在父类中你可以用this获取到子类的信息！
 
package com.urthinker.module.test;
import org.junit.Test;
abstract class BaseDao<T> {
public void 
      

      • 

    • Spring3.2新注解@ControllerAdvice
jinnianshilongnian
@Controller

      @ControllerAdvice，是spring3.2提供的新注解，从名字上可以看出大体意思是控制器增强。让我们先看看@ControllerAdvice的实现：
 
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Co
      

      • 

    • Java spring mvc多数据源配置
liuxihope
spring

      转自：http://www.itpub.net/thread-1906608-1-1.html
1、首先配置两个数据库
<bean id="dataSourceA" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close&quo
      

      • 

    • 第12章 Ajax（下）
onestopweb
Ajax

      index.html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
      

      • 

    • BW / Universe Mappings
blueoxygen
BO

       
BW Element
OLAP Universe Element
Cube  Dimension
Class
Charateristic
A class with dimension and detail objects (Detail objects for key and desription)
Hi
      

      • 

    • Java开发熟手该当心的11个错误
tomcat_oracle
java多线程工作单元测试

      #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收
测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
      

      • 

    • 推行国产操作系统的优劣
yananay
windowslinux国产操作系统

      最近刮起了一股风，就是去“国外货”。从应用程序开始，到基础的系统，数据库，现在已经刮到操作系统了。原因就是“棱镜计划”，使我们终于认识到了国外货的危害，开始重视起了信息安全。操作系统是计算机的灵魂。既然是灵魂，为了信息安全，那我们就自然要使用和推行国货。可是，一味地推行，是否就一定正确呢？
先说说信息安全。其实从很早以来大家就在讨论信息安全。很多年以前，就据传某世界级的网络设备制造商生产的交
      

      •