—————————————————— 以下选择的结果，皆是我选择错的—————————
    1、变量命名规范说法正确的是（）
    ●A.变量由字母，下划线，数字，$符号随意组合
    ○B.变量不能以数字作为开头
    ○C.A和a在Java中是同一个变量
    ○D.不同类型的变量，可以起相同的名字
    解析：
    变量名以字母、下划线或者美元符(4上面的￥)开头，不能以数字开头，后面跟字母、下划线、美元符、数字，变量名对大小写敏感，无长度限制。
    如果以数字为变量名开头，那么有可能会导致类型不匹配。
    2、下列JavaDOC注释正确的是（）
    ●A. /阿拓老师很帅/
    ○B. //阿拓老师很帅/
    ○C. /**阿拓老师很帅    /
    ○D. /阿拓老师很帅**/
    解析：
    java支持三种注释方式：
    // 单行
    用来简短描述某个变量或属性，程序块。
    /     多行 /
    进行多行简单注释，一般不使用
    /** 文档注释     /
    一般用来对类，接口，成员方法，成员变量，静态字段，静态方法，常量进行说明。
    javadoc工具将Java程序的源代码作为输入，输出一些包含程序注释的HTML文件。
    能够支持JavaDOC的注释是 /* /
    3、执行语句int a = ‘2’后，a的值是（）
    ○A.2
    ○B.50
    ○C.49
    ●D.0
    解析：
    int a 属于整型，‘2’属于char类型，当char类型赋值给int类型时，会先把’2’转换为对应的Ascll码，而’2’对应的ascll是50。
    4、下面哪个选项在编译时不会出现错误或警告（）
    ○A.float f=1.3;
    ○B.char c=’a’;
    ○C.byte b=200;
    ●D.boolean b=1;
    解析：
    A. flost f = 1.3; 这样虚拟机会默认为是 double 类型。flost f = 1.3f; 这样就没问题了。
    B. char c = ‘a’; char是表示的字符，定义用单引号，只能存储一个字符。
    C. byte b = 200; byte类型的取值范围是 -128-127。
    D. boolean b = 1; b是属于布尔类型，而1是整型。
    5、十进制16的十六进制表示形式是（）
    ○A.0X10
    ●B.0X16
    ○C.0XA
    ○D.016
    解析：
    十进制的16先转化为二进制，再将二进制转换为16进制
    十进制的16 —————> 10000 —————> 10
    (转二进制) 二进制 (转16进制)
    6、若下列所用变量均已经正确定义，以下表达式中不合法的是（）
    ●A.x>>3
    ○B.+++j
    ○C.a=x>y?x:y
    ○D.x%4
    解析：
    A. x>>3 // 右移运算符
    B.+++j // ++j 是有效的 但 +++j 就是无效的
    C. a=x>y?x:y // 三目运算
    D. x%4 // 取余
    7、为一个boolean类型变量赋值时，可以使用（）
    ●A.boolean = 1;
    ○B.boolean a = (9>=10);
    ○C.boolean a = “真”;
    ○D.boolean a == false;
    解析：
    A. boolean = 1; 没有定义变量名，且右边1是整型不能赋值给布尔型
    B. boolean a = (9>=10); 这是一个逻辑表达式，返回 true 或 false
    C. boolean a = “真”; 字符串类型不能赋值给 布尔型
    D. boolean a == false; ==两个等号是做判断用的，不是赋值
    8、以下代码，执行结果为（）
    public class Test{
    public static void main(String[] args){
    char c = 65;
    System.out.println(“c = “ + c);
    }
    }

    ●A. c = 65
    ○B. c = A
    ○C. 编译错误
    ○D. 执行错误
    解析：
    char是字符类型，会将赋值给自己的整性转换为对于的ascll码，而 ascll中 65 对应的就是 A
    9、在Java中下列关于自动类型转换说法正确的是（）【多选题】
    ●A. 基本数据类型和String相加结果一定是字符串型
    ●B. char类型和int类型相加结果一定是字符
    ●C. double类型可以自动转换为int
    ○D. char + int + double结果一定是double
    解析：
    A. 基本数据类型和String相加结果一定是字符串型
    // 因为+左右有一个String类的对象，而另一边不是，所以会将那个不是string的对象转换为string然后再连接。
    B. char类型和int类型相加结果一定是字符
    // char类型 和 int 类型相加时，char类型会将自己的值转换为 ascll码中对应的值(数字)
    C. double类型可以自动转换为int
    // int 类型是 4字节 double类型是8字节
    D. char + int + double结果一定是double
    char >>> int >>> double
    编译器编译时会自动进行数据类型匹配，将低精度的数据类型转换为高精度数据类型，以上三种中double精度最高，故最后结果是double类型的。
    10、下列输出结果是（）
    int a = 0;
    while(a<5){
    switch(a){
    case 0 :
    case 3 : a = a + 2;
    case 1 :
    case 2 : a = a + 3;
    default : a = a + 5;
    }
    }
    System.out.println(a);
    ○A. 0
    ●B. 5
    ○C. 10
    ○D. 其他
    解析：
    在 case 0: 的时候满足条件，但没有执行的语句就下一条无论满足或者不满足条件都强制执行一次，
    所以case 3:a = a + 2;语句能执行成功，这里 a 的值就是2了，然后 case 2: a = a+ 3 就满足条件继续执行，执行后 a 的值就是 5了，然后default又执行了一次 就变成了 10
    11、public static void main(String [] args){
    int x = 5;
    boolean b1 = true;
    boolean b2 = false;
    if((x == 4) && !b2)
    System.out.print(“1 “);
    System.out.print(“2 “);
    if((b2 = true) && b1)
    System.out.print(“3 “);
    }
    上述程序的执行结果是（）
    ○2
    ●3
    ○1 2
    ○2 3
    解析：
    第一个if为假，但后面两个语句并没有在 if的{ } 内，就第一条不运行，第二条运行。
    第二个if为真，后面的语句运行
    所以结果就是：2 3
    12、下列代码输出结果是（）
    int i = 10;
    while(i > 0){
    i = i++;
    if(i == 10){
    break;
    }
    }
    ○A.while循环执行10次
    ●B.死循环
    ○C.循环一次都不执行
    ○D.循环执行一次
    解析：
    因为i++有中间缓存变量。所以我的理解是 ：
    temp = i;
    i = i+1;
    i = temp;
    这里的 i 并没有改变，所以执行一次满足if条件就退出了。
    13、下面代码输出结果是（）
    int i = 0,s = 0;
    do{
    if(i%2 == 0){
    i++;
    continue;
    }
    i++;
    s = s + i;
    }while(i < 7);
    System.out.println(s);
    ○A. 16
    ○B. 12
    ○C. 28
    ●D. 21
    解析：
    i = 1 s = 0
    i = 2 s = 2
    i = 3 s = 2
    i = 4 s = 6
    i = 5 s = 6
    i = 6 s = 12
    i = 7 程序退出
    14、以下代码能够正确初始化(或默认初始化)数组的是（）
    ○A. int[] a;
    ○B. a = {1,2,3,4,5};
    ●C. int[] a = new int[5]{1,2,3,4,5};
    ○D. int[] a = new int[5];
    解析：
    A. int[] a; // 并没有初始化
    B. a = {1,2,3,4,5} // 没有定义a的数组类型，并方式不对
    C.int[] a = new int[5]{1,2,3,4,5} // 这里已经给数组赋值了，就不用再写[5]数组范围了
    D.int [] a = new int[5];
    15、定义了一维int型数组a[10]后，下面错误的引用是（）
    ○A.a[0] = 1;
    ○B.a[0] = 52;
    ○C.a[10] = 2;
    ●D.a[1] = a[2]     a[0];
    解析：
    C. a[10] = 2; // 题目定义的是int型数组 a[10]。那么下标最大是 9。但这里 a[10] = 2的意思是给该数组下标为10的赋值为2。
    16、执行完代码”int[] x = new int[25];”后，以下说法正确的是（）
    ○A.x[24]为0
    ○B.x[24]未定义
    ○C.x[25]为0
    ●D.x[0]为null
    解析：
    A. x[24]为0 // x[24] 的取值在该数组范围内，且因为数组是 int类型的，没有赋值的时候就为 0
    B. x[24]未定义 // 该数组定义的时候范围是 25 那么下标最大可取24
    C. x[25]为0 // 超出该定义的数组范围
    D. x[0]为null // 该数组是int类型，默认值为 0。如果是String类型那么默认值就是 null
    17、代码如下，选项说法正确的是（）
    public class ArrayTest {
    public static void main(String[] args) {
    int fl[], f2[];
    fl = new int[10];
    f2 = fl;
    System.out.println(“f2[0]=” + f2[0]);
    }
    }
    ○A.打印f2[0]=0
    ○B.打印f2[0]=NaN
    ●C.第3行会产生编译时异常
    ○D.第5行会产生编译时异常
    解析：
    这两个数组定义的都是 int 类型，int类型数组在取值范围内并未赋值的情况下，默认值为 0
    18、下列说法错误的有(多选题)
    ●A.数组是一种对象
    ●B.数组属于一种原生类
    ○C.int number = []{31,23,33,43,35,63};
    ○D.数组的大小可以任意改变
    解析：
    B. 数组属于一种原生类 // 数组是一个对象，不属于原生类
    原生类有 8种：int double boolean float byte short long char
    C. int number = [] {31,23,33,43,35,63} // 数组定义方式错误
    D. 数组的大小可以任意改变 // 数组的大小定义了就不能发生改变
    19、下面不是创建数组的正确语句的选项是（）
    ○A.float f[][] = new float[6][6];
    ○B.float []f = new float[6];
    ○C.float f[][] = new float[][6];
    ●D.float [][]f = new float[6][];
    解析：
    C. float f[][] = new float[][6] // 这是一个多维数组，但这里只给了二维数组定义范围，没有给一维数组定义范围。
    20、以下程序编译运行后的输出结果为（）
    public class Test{
    public int x,y;
    Test(int x,int y){
    this.x = x;
    this.y = y;
    }
    public static void main(String[] args){
    Test t1,t2;
    t1 = new Test(3,3);
    t2 = t1;
    t2.x = 5;
    t2 = new Test(4,4);
    System.out.print(t1.x + t2.x);
    }
    } 2 Points
    ○A.3 4
    ○B.5 4
    ●C.7
    ○D.9
    解析：
    Test t1,t2; // 创建了 t1,t2
    t1 = new Test(3,3); // t1创建对象并构造方法给 x,y 赋值
    t2 = t1; // t2 等于 t1 对象 互通
    t2.x = 5; // t2修改 x 的值为5，同时t1的x同步被修改
    t2 = new Test(4,4); // t2 重新创建一个对象
    System.out.print(t1.x + t2.x); // t1.x 在t2修改x的时候被同步修改成了5，所以就变成了 5 + 4
    21、给定Java代码如下所示，在//#处添加哪个选项，不可以构成方法重载（）
    public class Test{
    public void fun(int x,int y,int z){}
    //#
    }

    ○A.public int fun(int x,int y,float z){return 0;}
    ○B.public int fun(char x,int y,int z){return 0;}
    ●C.public void fun(int x,int z){}
    ○D.public void fun(int z,int y,int x){}
    解析：
    方法重载：同一个方法接收不同类型，不同参数个数的方法
    D. public void fun(int z,int y,int x){} // D选项已经与题目已存在的方法 重复
    22、在Java中，关于构造方法，下列说法错误的是（）
    ○A.构造方法的名称必须与类名相同
    ○B.构造方法可以携带参数
    ○C.构造方法不可以重载
    ●D.构造方法没有返回值
    解析：
    C. 构造方法不可以重载 // 方法重载：方法名相同，方法参数的类型或个数不同。在构造方法中可以实现不同的参数类型和不同的个数。
    23、有以下程序片段且Interesting不是内部类
    下列哪个选项不能插入到1.行（）
    1.
    2.public class Interesting{
    3. //#省略代码
    4.}
    ○A.import java.util.*;
    ○B.package mypackage;
    ●C.class OtherClass{}
    ○D.public class MyClass{}
    解析：
    D. public class MyClass{} // java中可以有内部类，但java中只能有一个 public 类
    24、以下代码的输出结果是?（）
    public class B{
    public static B t1 = new B();
    public static B t2 = new B();
    {
    System.out.println(“构造块”);
    }
    static{
    System.out.println(“静态块”);
    }
    public static void main(String[] args){
    B t = new B();
    }
    } 2 Points
    ○A.静态块 构造块 构造块 构造块
    ●B.构造块 静态块 构造块 构造块
    ○C.构造块 构造块 静态块 构造块
    ○D.构造块 构造块 构造块 静态块
    解析：
    构造块: 每次创建对象的时候都会执行一次
    静态块：静态代码块在 Class 被加载时运行，且只运行一次

    ============================ 错题总结 ==========================
    1、Java中的变量命名规范还未理解清楚
    2、Java中的不同注释还未理解用在什么地方
    3、Java中的不同数据类型有时 会发生转换 例如 char 跟 int
    4、给Java中不同数据类型定义并赋值时，赋值要跟着数据类型赋值，不然有时会发生类型错误
    5、Java中的 ++ 和 — 还要多理解 ，特别是 i— 和 i++
    6、Java中的不同数据类型相加会发生不同的改变
    7、Java中的 if 和 switch 理解少
    8、Java创建数组的几种方式 还未正确记牢
    9、Java对象与对象的赋值还需理解
    10、Java中的构造块与静态块执行时机与执行次数还需理解