JAVA基础学习--面向对象试题

一、异常捕获

 

package com.pb.demo.demo1;public class Demo {    public static void main(String[] args) {                try {            func();            System.out.println("A");        } catch (Exception e) {            //e.printStackTrace();            System.out.println("C");        }        System.out.println("D");    }        /**     * 抛出异常     * @throws Exception     */    public static void func() throws Exception{        try {            throw new Exception();        } finally {            System.out.println("B");        }    }}

 

结果：B,C,D

 

二、对象的实例化过程

package com.pb.demo.demo2;public class Test {    public Test(){        System.out.println("Test");    }    }package com.pb.demo.demo2;/** * 继承父类test * @author Administrator * */public class Demo extends Test {        public Demo(){        //这里隐藏了super()        System.out.println("Demo");    }    public static void main(String[] args) {        new Demo();        new Test();    }}

结果：

Test
Demo
Test

三、接口

package com.pb.demo.demo2;public interface A {}package com.pb.demo.demo2;public class B implements A {      public String func(){      return "func";  }    public static void main(String[] args) {    A a=new B();    a.func();   //编译失败，因为A接口中并没有这个方法}}

四、方法重写

package com.pb.demo.demo3;public class Fu {    public boolean show(char a){        System.out.println(a);        return true;    }}package com.pb.demo.demo3;public class Demo extends Fu {    /**     * 重写父类的方法     * 调用时会调用子类重写后的方法     */    public boolean show(char a){        System.out.println(a);        return false;    }    public static void main(String[] args) {        int i=0;        Fu f=new Demo();        Demo d=new Demo();        for(f.show('A');f.show('B')&&(i<2);f.show('C')){            i++;            d.show('D');        }        //结果:A，B,    }}

结果;A,B

五、接口

package com.pb.demo.demo4;public interface A {}package com.pb.demo.demo4;public class B implements A {    public String test(){        return "yes";    }}package com.pb.demo.demo4;public class Demo {    static A get(){        return new B();    }    public static void main(String[] args) {        A a=Demo.get();        System.out.println(a.test()); //编译失败 接口中没有这个方法，这个方法是子类中特有的    }}

六、对象初始化

package com.pb.demo.demo5;public class Super {    int i=0;    public Super(String a){        System.out.println("A");        i=1;    }    public Super(){        System.out.println("B");        i+=2;    }}package com.pb.demo.demo5;public class Demo extends Super {    public Demo(String a){        System.out.println("C");        i=5;    }    public static void main(String[] args) {        int i=4;        Super d=new Demo("A");        System.out.println(d.i);    }    //B,C,5    }

结果：B,C,5

七、匿名内部类的使用

package com.pb.demo.demo6;public interface Inter {    public void show(int a,int b);    public void func();}package com.pb.demo.demo6;public class Demo {    public static void main(String[] args) {        // 补足代码，调用两个函数，用匿名内部类实现        Inter inter = new Inter() {            @Override            public void show(int a, int b) {            }            @Override            public void func() {            }        };        inter.show(3, 5);        inter.func();    }}

八、

package com.pb.demo.demo7;public class TD {    int y = 6;     class Inner {        static final int y = 3;        // 内部类中如果有static成员，这个内部类必须是static的,        void show() {            System.out.println(y); //只能调用局部中final修饰的        }    }}package com.pb.demo.demo7;public class TC {    public static void main(String[] args) {        TD.Inner ti=new TD().new Inner();        ti.show(); //3    }}

非静态内部类，不能定义静态成员，

内部类如果有静态成员，则这个内部类必须是静态内部类

九、方法重写和方法重载

public class Demo {    int show(int a,int b){        return 0;    }        }/**     * 下列哪里方法可以存在Demo的子类中     */    public int show(int a,int b){        return 0;    }  //可以方法重写       private int show(int a,int b){        return 0;    }  //权限不够   private int show(int a,long b){       return 0;   }   //可以，和父类不是同一个方法，方法重载   public short show(int a,int b){       return 0;   }//不可以，不是方法重载，不可以和给定的函数出现在同一类中，或者其子类      public static int show(int a,int b){       return 0;   }   //不可以，静态方法，只能覆盖静态

 

十、this,final

this：代表本类对象，哪个对象调用this所有的函数，this就代表哪个对象

final: 

1.修饰类，变量（成员变量，静态变量，局部变量），函数

2.修饰的类不可以被继承

3.修饰的函数不可以被重写

4.修饰的变量是一个常量，只能赋值一次

5.内部类只能访问局部中的final变量

十一、继承对象初始化

package com.pb.demo.demo8;public class Fu {    int num=4;    void show(){        System.out.println("show Fu");    }}package com.pb.demo.demo8;public class Zi extends Fu {    int num=5;    void show(){        System.out.println("show Zi");    }}package com.pb.demo.demo8;public class T { public static void main(String[] args) {    Fu f=new Zi();    Zi z=new Zi();    System.out.println(f.num);//4    System.out.println(z.num);//5    f.show(); //方法已经重写，执行子类的方法    z.show();}}

结果：

4
5
show Zi
show Zi

 

十二、接口的实现

package com.pb.demo.demo8;public interface A {    void show();}package com.pb.demo.demo8;public interface B {        void add(int a,int b);}package com.pb.demo.demo7;import com.pb.demo.demo8.A;import com.pb.demo.demo8.B;public class C implements A,B{        private int x;    private int y;    // private int sum;    @Override    public void add(int a, int b) {        this.x=a;        this.y=b;                //sum=a+b;    }    @Override    public void show() {        System.out.println(x+y);        //System.out.println(sum);            }    public static void main(String[] args) {        C c=new C();        c.add(4, 2);        c.show();//通过函数打印以上2个数的和    }}

十三、异常执行

package com.pb.demo.demo8;public class Demo {    public static void main(String[] args) {         try {            showExce();            System.out.println("A");        } catch (Exception e) {            System.out.println("B");        }finally{            System.out.println("C");        }         System.out.println("D");         //B,C,D    }    public static void showExce() throws Exception{        throw new Exception();    }}

结果：B,C,D

 

十四、继承，子类重写父类

package com.pb.demo.demo8;public class Super {    int i=0;    Super(){            };    public Super(String s){        i=1;    }    }package com.pb.demo.demo8;public class Demo1 extends Super {    public Demo1(String s){        i=2;    }        public static void main(String[] args) {        Demo1 d=new Demo1("yes");        System.out.println(d.i); //2    }}

结果：2

十五、方法重写

 

package com.pb.demo.demo9;public class Super {    public int get(){        return 4;    }}package com.pb.demo.demo9;public class Demo1 extends Super {        public long get(){ //方法重写不能改变返回值类型和参数        return 4;    }    public static void main(String[] args) {        Super s=new Demo1();        System.out.println(s.get());    }}

 

 

结果：编译失败：方法重写不能改变方法的返回值 和参数

十六、异常

 

package com.day10.demo2;public class Demo {    public static void main(String[] args) {        try {             func();        } catch (Exception e) {            System.out.println("C");                    }        System.out.println("D");            }    public static void func(){        try {            throw new Exception();            System.out.println("A");//抛出异常下方代码不会被执行        } catch (Exception e) {            System.out.println("B");                    }    }}

 

结果:throw下方的代码不能被执行到

删除后，执行结果：B,D

十七、匿名内部类

 

package com.day10.demo2;public class Demo1 {        public void func(){        //位置1：            }        public static void main(String[] args) {        Demo d=new Demo();        //位置2            }    /**     * A、在位置1写new Inner(); //OK     * B、在位置2写new Inner(); //主函数是静态的,如果要访问，需要被静态包修     * C、在位置2写new d.Inner();//格式错误 new new Demo1().Inner();     * D、在位置2写new Demo.Inner(); //错误因为inner不是静态的     */}

 

结果

十八、多重catch顺序

 

package com.day10.demo2;public class Exc0 extends Exception {}package com.day10.demo2;public class Demo2 {    public static void main(String[] args) {        try {            throw new Exc1();        } catch (Exception e) {            System.out.println("Exception");            /*             * Exception是最大的异常父类，             * 在最前面的后，下面的catch永远不会被执行到             */        }catch (Exc0 e) {            System.out.println("Exc0");        }    }}

 

结果:在最前面的后，下面的catch永远不会被执行到，父类的catch要放在最下面

十九、静态调用非静态，匿名内部类实现

 

package com.day10.demo2;public interface Test {        public void func();}

 

package com.day10.demo2;public class Demo3 {    public  void show(Test t){        t.func();    }    public static void main(String[] args) {        //补足代码：匿名内部类        new Demo3().show(new Test(){            @Override            public void func() {                            }                    });            }}

 

二十、异常带return

 

package com.day10.demo3;public class Test {    public static String output="";    public static void foo(int i){        try {            if(i==1)                throw new Exception();                    output+="1";        } catch (Exception e) {            output+="2";            return;        }finally{            output+="3";                    }        output+="4";    }        public static void main(String[] args) {                foo(0);        System.out.println(output);//1,3,4        foo(1);        System.out.println(output); //134,2,3    }}

 

结果

二十一、补全代码对象数组求最大值

 

package com.day10.demo3;public class Circle {    private static double pi=3.14;    private double radius;//半径    public Circle(double r){        this.radius=r;    }    public static double compare(Circle[] cir){        //程序代码，就是求数组中的最大值        int max=0;        for(int x=1;x<cir.length;x++){            if(cir[x].getRadius()>cir[max].radius){                max=x;            }                    }        return cir[max].getRadius();            }    public double getRadius() {        return radius;    }    public void setRadius(double radius) {        this.radius = radius;    }}package com.day10.demo3;public class TC {    public static void main(String[] args) {                Circle cir[] =new Circle[3];//创建了个类类型的数组        cir[0]=new Circle(2.0);        cir[1]=new Circle(3.0);        cir[2]=new Circle(5.0);        System.out.println("最大半径值是："+Circle.compare(cir));    }}

 

二十二、方法调用

 

package com.day10.demo3;public class Demo {    private static int j = 0;    private static boolean methodB(int k) {        j += k;        return true;    }    public static void methodA(int i) {        boolean b;        b = i < 10 | methodB(4);        b = i < 10 ||methodB(8);    }    public static void main(String[] args) {        methodA(0);        System.out.println(j);    }}

结果：4

二十三、对象中值的比较

 

 

package com.day10.demo4;public class Circle {    private double radius;    public Circle(double r){        this.radius=r;    }    public Circle compare(Circle cir){        //补足代码        if (this.radius>cir.getRadius()){            return this;        }else{            return cir;        }        //return (this.radius>cir.getRadius()?this:cir);    }    public double getRadius() {        return radius;    }    public void setRadius(double radius) {        this.radius = radius;    }    }package com.day10.demo4;public class TC {    public static void main(String[] args) {        Circle cir1=new Circle(1.0);        Circle cir2=new Circle(2.0);        Circle cir;        cir=cir1.compare(cir2);        if(cir1==cir){            System.out.println("圆1的半径比较大");        }else{            System.out.println("圆2的半径比较大");        }    }}