Java基础练习题 (2)

1.重载和重写的区别是什么

答案：

​ 重载： 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序

不同，方法返回值和访问修饰符可以不同；发生在编译时。

​ 重写： 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父

类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类

方法访问修饰符为 private 则子类就不能重写该方法。

2、默写快速排序和冒泡排序

答案：

冒泡排序：

​
public class BubbleSort {
 
    public static void main(String[] args) {
        int[] arr = {2,7,4,3,5,8,6,1,9,0};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    
    public static void sort(int[] arr) {
        for(int j=0;j<arr.length;j++) {
            for(int i=0;i<arr.length-1;i++) {
                if(arr[i]>arr[i+1]) {
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }
    }
 
}

快速排序：

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = { 5, 7, 4, 2, 0, 3, -3, 1, -2, 9, 6, 10, 8, -1 };
        sort(arr, 0, arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
 
    public static void sort(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int base = arr[left];
 
        int i = left;
        int j = right;
 
        while (i != j) {
            while (arr[j] >= base && i < j) {
                j--;
            }
            while (arr[i] <= base && i < j) {
                i++;
            }
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        arr[left] = arr[i];
        arr[i] = base;
        sort(arr, left, i - 1);
        sort(arr, i + 1, right);
    }
}

3.简述你所知道的this关键字

答案：this.属性、this.方法名、this()

4.下列说法正确的有（ ）

A． 在类方法中可用this来调用本类的类方法

B． 在类方法中调用本类的类方法时可直接调用

C． 在类方法中只能调用本类中的类方法

D． 在类方法中绝对不能调用实例方法

答案：B

5.抽象类能用final修饰吗？为什么

答案：不能。当一个类被声明为final时，它表示这个类不能被继承；而当一个类被声明为abstract时，它至少包含一个抽象方法，这个方法必须由子类提供具体实现，因此，abstract类的主要目的是被其他类继承；由于final类不能被继承，而abstract类的主要目的是被继承并提供具体实现，所以这两个关键字在逻辑上是相互矛盾的，因此抽象类不能用final进行修饰

6.该树的前中后序遍历情况，以及代码

​

答案：

前序遍历：abdefgc

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        preorder(root, res);
        return res;
    }
​
    public void preorder(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        res.add(root.val);
        preorder(root.left, res);
        preorder(root.right, res);
    }
}

中序遍历：debgfac

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        inorder(root, res);
        return res;
    }
​
    public void inorder(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        inorder(root.left, res);
        res.add(root.val);
        inorder(root.right, res);
    }
}

后序遍历：edgfbca

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        postorder(root, res);
        return res;
    }
​
    public void postorder(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        postorder(root.left, res);
        postorder(root.right, res);
        res.add(root.val);
    }
}

7.请描述你所理解的多态！越多越好

答案：多态基于继承实现，子类可以重写父类中的方法，子类对象可以赋值给父类类型的变量，当子类继承了父类并重写了父类中的方法时，子类对象就可以被当作父类对象来使用，但调用的是子类重写后的方法

8.下列代码的输出是什么？并解释其原因

public class A {
    public String show(D obj) {
        return ("A and D");
    }
    public String show(A obj) {
        return ("A and A");
    } 
}

public class B extends A{
    public String show(B obj){
        return ("B and B");
    }
    
    public String show(A obj){
        return ("B and A");
    } 
}

public class C extends B{
}

public class D extends B{
}

public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));      
    }
}

a1创建的是A类对象，选择的数据类型也是A，因此可以调用A类当中的Show(D obj)和Show(A obj)方法

1、a1.Show(b)传参为B类型的b，B继承A，所以b可以向上转型成A类型，因此执行Show(A obj)方法，所以输出 A and A

2、a1.Show(c)传参为C类型的C，C继承B，B继承A，所以c可以向上转型成B类型再继续向上转型成A类型，因此执行Show(A obj)方法，所以输出 A and A

3、a1.Show(d)传参为D类型的d，因此执行Show(D obj)方法，所以输出 A and D

a2创建的是B类对象，选择的数据类型是A类型，因此a2可以调用A类当中的Show(D obj)和被B类重写过后的Show(A obj)方法

4、a2.Show(b)传参为B类型的b，B继承A，所以b可以向上转型成A类型，因此执行被B类重写后的Show(A obj)方法，所以输出 B and A

5、a2.Show(c)传参为C类型的C，C继承B，B继承A，所以c可以向上转型成B类型再继续向上转型成A类型，因此执行被B类重写后的Show(A obj)方法，所以输出 B and A

6、a2.Show(d)传参为D类型的d，因此执行A中的Show(D obj)方法，所以输出 A and D

b创建的是B类对象，选择的数据类型是A，因为B继承A，所以b可以调用A类当中的Show(D obj)方法和B类当中的show(B obj)、show(A obj)（该方法对A中该方法进行了重写）方法

7、b.show(b)传参为B类型的b，B继承A，所以b可以向上转型成A类型，因此执行B类中的Show(A obj)方法，所以输出 B and A

8、b.show(c)传参为C类型的C，C继承B，B继承A，所以c可以向上转型成B类型再继续向上转型成A类型，因此执行B类中的Show(A obj)方法，所以输出 B and A

9、b.show(d)传参为D类型的d，因此执行A中的Show(D obj)方法，所以输出 A and D

9.下列代码输出的结果是

public class Pig {
    static int[] arr = new int[3];
    static int[] brr = new int[3];
    public static void main(String[] args) {
        int a = 10;
        int b = 15;
        System.out.println("a="+a);  
        a = IntChange(a, b);
        System.out.println("a="+a); 
        
        Pig pig = new Pig();
        arr = pig.IntArrChange(arr,brr);
        System.out.println(Arrays.toString(arr));
        
    }
    public static int  IntChange(int a,int b) {
        a = b;
        return a;
    }
    public static int[]  IntArrChange(int[] arr,int[] brr) {
        arr = new int[3];  
           brr = new int[3]; 
        arr[0] = 1;
            brr[2] = 1;
        arr = brr;
        return arr;
    }
}

答案：

a=10

a=15

[0,0,1]

10.在java语言当中关于数据类型和包装类的说法下列正确的是：

A:基本数据类型是包装类的简写形式，可以用包装类替代基本数据类型
​
B:long和double都占了64位（64bit）的内存空间
​
C:默认的整数数据类型是int，默认的浮点数据类型时float
​
D:和包装类一样，基本数据类型声明的变量中也具有静态方法，用来完成进制转化

答案：B

11.分析下面这段Java代码，它的运行结果是( )

 public class Test {
    public static void main(String[] args) {
        int i = 12;
        System.out.println(i+=i-=i*=i);
    }
}

答案：-120

12.假设有一个父类Animal和它的子类Dog，下面哪个语句能正确体现多态？

A. Animal a = new Animal();
​
B. Dog d = new Dog();
​
C. Animal a = new Dog();
​
D. Dog d = new Animal();

答案：C