Java基础——面向对象练习

按照Java规范书写程序代码，如果你认为程序有错误，请指出，并说明程序错误的原因。

1. 写出程序结果

public class Test1 {
    public static void func() throws Exception  //必须要声明
    {
        try
        {
            throw  new Exception();   //编译时异常没有处理,要么catch要么throws
            //throw相当于return
        }
        finally {
            System.out.println("B");
        }
    }

    public static void main(String[] args) {
        try
        {
            func();
            System.out.println("A");
        }
        catch (Exception e)
        {
            System.out.println("C");
        }
        System.out.println("D");
    }
}

2. 写出程序结果

public class Test2 {
    Test2()
    {
        System.out.println("Test");
    }
}

class Demo extends Test2
{
    Demo()
    {
        super();
        System.out.println("Demo");
    }

    public static void main(String[] args) {
        new Demo();
        new Test2();
    }
}

考察的子类的实例化过程。
子类必执行一个对应的父类的构造函数。

3. 写出程序结果

interface A{}
class B implements A{
    public String func(){
        return "func";
    }
}

class Demos
{
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.func());
    }
}

编译失败：创建父类引用指向子类对象，引用只能调用父类的方法，若子类复写了父类的方法，则执行子类复写的方法，否则执行父类定义的方法。

4. 写出程序结果

class Fu
{
    boolean show(char a)
    {
        System.out.println(a);
        return true;
    }
}

class Demoa extends Fu{
    public static void main(String[] args) {
        int i =0;
        Fu f = new Demoa(); //调用父类方法，执行子类方法0
        Demoa d = new Demoa();
        for(f.show('A'); f.show('B') && (i < 2); f.show('C'))
        {
            i++;
            d.show('D');
        }
    }
    boolean show(char a)
    {
        System.out.println(a);
        return false;
    }
}

5. 写出程序结果

class Super
{
    int i = 0;
    public Super(String a)
    {
        System.out.println("A");
        i = 1;
    }
    public Super()  //执行
    {
        System.out.println("B");
        i+=2;
    }
}

class Demo extends Super
{
    public Demo(String a)
    {
//        super();   //隐藏执行
        System.out.println("C");
        i = 5;
    }

    public static void main(String[] args) {
        int i = 4;
        Super d = new Demo("D");
        System.out.println(d.i);
    }
}

interface Inter
{
    void show(int a, int b);
    void func();
}

class Demo
{
    public static void main(String[] args) {
        //补充代码：调用两个函数，要求用匿名内部类
        Inter in = new Inter()  //多太，父类引用指向子类对象
        {
            @Override
            public void show(int a, int b) {
                
            }

            @Override
            public void func() {
                
            }
        };
        in.func();
        in.show(1,2);
    }
}

7. 写出程序结果

class TD{
    int y = 6;
    class Inner
    {
        static int y = 3;
        void show()
        {
            System.out.println(y);
        }
    }
}
class TC
{
    public static void main(String[] args) {
        TD.Inner ti = new TD().new Inner();
        ti.show();
    }
}

编译失败，非静态内部类中不可以定义静态成员（函数和数据）。
内部类中如果定义了静态成员，该内部类必须被静态修饰。

8. 选择题，写出错误答案错误的原因，用单行注释的方式。

class Demo
{
    int show(int a, int b)
    {
        return 0;
    }
}

下面哪些函数可以存在于Demo的子类中。
A. public int show(int a, int b){return 0;} //可以，覆盖
B. private int show(int a, int b){return 0;} //不可以，权限不够
C. private int show(int a, long b){return 0;} //可以，和父类不是一个函数。没有覆盖，相当于重载
D. public short show(int a, int b){return 0;} //不可以，因为函数不可以和给定函数出现同一类中，或者子父类中
E. static int show(int a, int b){return 0;} //不可以，静态只能覆盖静态

9. 写出this关键字的含义，final有哪些特点？

this：代表本类对象，那个对象调用this所在函数，this就代表那个对象。

final:
1. 修饰类，变量(成员变量，静态变量，局部变量），函数
2. 修饰的类不可以被继承
3. 修饰的函数不可以被覆盖
4. 修饰的变量是一个常量，只能覆盖一次。

10. 写出程序结果

class Fu
{
    int num = 4;
    void show()
    {
        System.out.println("show fu");
    }
}

class Zi extends Fu{
    int num = 5;
    void show(){
        System.out.println("show Zi");
    }
}

class T
{
    public static void main(String[] args) {
        Fu f = new Zi();
        Zi z = new Zi();
        System.out.println(f.num);
        System.out.println(z.num);
        f.show();
        z.show();
    }
}

成员变量：编译和运行看左边。
函数：编译看左边，运行看右边。

interface A
{
    void show();
}

interface B
{
    void add(int a, int b);
}

class C implements A,B
{
    private int a,b;
    //private int sum;
    @Override
    public void add(int a, int b) {
        this.a = a;
        this.b = b;
        // sum = a + b;
    }

    @Override
    public void show() {
        System.out.println(a+b);
        //System.out.println(sum);
    }
}

class D
{
    public static void main(String[] args) {
        C c = new C();
        c.add(2,3);
        c.show(); //通过该函数打印以上两个函数的和
    }
}

12. 写出程序结果

class Demo
{
    public static void main(String[] args) {
        try
        {
            showExec();
            System.out.println("A");
        }
        catch (Exception e)
        {
            System.out.println("B");
        }
        finally {
            System.out.println("C");
        }
        System.out.println("D");
    }
    public static void showExec() throws Exception
    {
        throw new Exception();
    }
}

12. 写出程序结果

class Super
{
    int i = 0;
    //Super(){}
    public Super(String a)
    {
        i = 1;
    }
}

class Demo extends Super
{
    public Demo(String s)
    {
        //super(); //隐藏信息
        i = 2;
    }

    public static void main(String[] args) {
        Demo d = new Demo("yes");
        System.out.println(d.i);
    }
}

编译失败：因为父类中缺少空参数的构造函数。
或者子类应该通过super语句指定要调用的父类中的构造函数。

14. 写出程序结果