X32专项练习部分01

隐式类型转换

public static void main(String[] args) {
        System.out.println(1 + "10" + 3 + "2");
    }
    /*
    输出结果："11032"
    原因分析：
    懒得解释了，直接上案例
    System.out.println(1+"10"+3+"2");//11032
    System.out.println(1+2+"10"+3+"2");//31032
    System.out.println(1+"10"+3+1+"2");//110312
    数字计算时，一旦遇到String类型
    后面的计算直接涉及字符串拼接
     */

多线程

    // 执行以下程序，最终输出可能是：
    public static void main(String args[]) {

        Thread[] ths = new Thread[3];
        for (int i = 0; i < 3; i++) {
            ths[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 5; j++) {
                        System.out.print(j);
                    }
                    System.out.print(" ");
                }
            });
        }
        for (Thread th : ths) {
            th.start();
        }
    }
	/*
    010 2123012 3434
    01201 340124 2334
    0012314 01223344**
    12345 12345 12345

    答案：C
    C选项中的另外两个空格在最后
    D选项由于5的出现明显错误
    A B选项错误类型相同
    虽然每次结果不同，但是第一个空格之前必然有 0 1 2 3 4 这5个数字
    这是因为第一个空格出现，意味着第一个线程执行完毕，必然会打印这四个数字
    又因为线程并发执行，所以后面两个线程个别数字可能会提前打印，这就导致了答案有很多
     */

抽象类与接口的区别

/*
    Java1.8版本之前的前提，Java特性中,abstract class和interface有什么区别（）
        抽象类可以有构造方法，接口中不能有构造方法
        抽象类中可以有普通成员变量，接口中没有普通成员变量
        抽象类中不可以包含静态方法，接口中可以包含静态方法
        一个类可以实现多个接口，但只能继承一个抽象类

        答案：ABD
        说明：
            C选项说反了
            其它的都对

        其它区别：
            继承方面：
                abstract下一代可以为抽象类
                interface下一代只能为实现者
            成员变量定义方面：
                jdk8之前，接口定义成员变量，只能用public 、static、final三个关键字修饰，此外都不行
                如果不用上述三个关键字，也是默认public static final
            成员你方法定义方面：
                定义成员方法只能用public 和abstract两个关键字修饰，此外都不行
                且不能有方法体，如果不用上述两个关键字，也是默认public abstract

        补充：
        在JDK1.7，接口中只包含抽象方法，使用public abstract修饰

        public interface Demo{
            public abstract void method();
        }

        在JDK1.8，接口中新加了默认方法和静态方法：
                默认方法：使用default修饰，在接口的实现类中，可以直接调用该方法，也可以重写该方法
                静态方法：使用static修饰，通过接口直接调用

        public interface Demo{
            //默认方法
            public default void method(){
                System.out.println("default method...");
            }

            //静态方法
            public static void print(){
                System.out.println("static method...");
            }
        }

        在JDK1.9，接口中新加了私有方法，使用private修饰，私有方法供接口内的默认方法调用
        复制代码

        public interface Demo{
            private void method() {
                System.out.println("Hello World!");
            }
        }
     */

方法重载

/*
    A,B,C,D 中哪些是 setvar的重载

    public class methodover
    {
        public void setVar(int a, int b, float c) {}
    }

     private void setVar(int a， float c， int b){}
     protected void setVar(int a， int b， float c){}
     public int setVar(int a， float c， int b){return a;}
     public int setVar(int a， float c){return a;}

     答案：ACD
     说明：
        重载是在同一个类中，有多个方法名相同，参数列表不同(参数个数不同，参数类型不同)
        与方法的返回值无关，与权限修饰符无关
        B中的参数列表和题目的方法完全一样了
     */

Java语言性特点

/*
    有关Java语言性特点说法错误的是
    Java致力于检查程序在编译和运行时的错误
    Java能运行虚拟机实现跨平台
    Java自己操纵内存减少了内存出错的可能性
    Java还实现了真数组，避免了覆盖数据类型的可能

    答案：D
    原因分析：
    数组元素在内存中是一个接着一个线性存放的，通过第一个元素就能访问随后的元素，
    避免了数据覆盖的可能性，实现了真数组为Java语言健壮性的特点之一，而不是语言性的特点
    和数据类型覆盖并没有关系
    C选项：java对垃圾回收是由java虚拟机不定时进行回收的，不需要程序员显式的调用相关方法
    c/c++程序回收内存要通过调用某些方法来执行
    拓展：
    数组越界会对内存中其他的数据产生覆盖，造成程序崩溃
    java中做了下标检测，所以不会出现数组越界，也就避免了数据覆盖
    C/C++中不检查数组越界，有数据覆盖风险
    python是伪数组
    伪数组只需要记住两点：
        长度不可变
        不能使用数组的方法
     */

Java位运算

public static void main(String[] args) {
        /*
        异位与运算符号
            对应位置不同，该位置的值赋值为1
            17：0001 0001
            05：0000 0101
            rs：0001 0100
            转10进制：20
            
        补充：    
        位运算
        (1)按位与 同时为1，则为1 否则为0  例：a = 2; b = 3; a & b => 10 & 11 => 10
        (2)按位或 有一个为1，则为1，否则为0 例：a = 2; b = 3; a | b => 10 | 11 => 11
        (3)按位异或 不同为1，相同为0 例：a = 2; b = 3; a ^ b => 10 ^ 11 => 01 
        (4)按位取反 二进制数在内存中是以补码的形式存在的，我们要得到补码然后取按位取反
         */
        System.out.println(17^5); // 20
    }

异常处理机制代码执行顺序

/*
    下列程序的输出结果是
    public class Test {
        public static void main(String[] args) {
            System.out.println(test()); // 2
        }
        private static int test() {
            int temp = 1;
            try {
                System.out.println(temp); // 1
                return ++temp;
            } catch (Exception e) {
                System.out.println(temp);
                return ++temp;
            } finally {
                ++temp;
                System.out.println(temp); // 3
            }
        }
    }

    答案：D
    说明：
        执行顺序为：
        输出try里面的初始temp：1；
        temp=2；
        *保存return里面temp的值：2；
        执行finally的语句temp：3，输出temp：3；
        返回try中的return语句，返回存在里面的temp的值：2；
        输出temp：2


    1,2,2
    1,2,3
    1,3,3
    1,3,2
     */

总目录