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

一、异常捕获

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的半径比较大");
        }

    }

}

时间： 2024-10-09 01:58:23

基础学习--面向对象试题的相关文章

python基础学习-面向对象高级

一.反射 1.什么是反射? 指的是在程序运行过程中可以"动态 (不见棺材不掉泪)"获取对象的信息 2.为什么要用反射? 在不清楚对方程序提供的obj值对其进行分析处理时,不知道从什么地方获取,也不清楚这个值得属性的情况下就需要用到反射进行动态获取进行分析 3.如何实现反射? #举例: class People: def __init__(self,name,age): self.name=name self.age=age def say(self): print('<%s:%

Java基础学习（三）——面向对象思想

学习Java,就离不开学习面向对象的编程思想.Java语言是纯粹的面向对象的程序设计语言,这主要表现为Java完全支持面向对象的三种基本特征: 封装(encapsulation) 继承(inheritance) 多态(polymorphism) Java语言完全以对象为中心,Java程序的最小程序单位是类,整个Java程序由一个一个的类组成. 万物皆对象 “面向对象”(英语:Object Oriented,简称OO)是一种以事物为中心的编程思想. 面向对象程序设计(英语:Object-orien

Java基础-学习笔记（五）——面向过程和面向对象的区别

学习面向对象的语言,要弄清楚面向对象,首先要从理解面向过程开始. 回想起之前在学习C语言时,每次拿到一个题目,首先想到的是,先分析出解决问题所需要的步骤,每一个功能点,用一个函数来表示,使用的时候一个一个进行调用就好了,程序的重心在函数上(谓语):面向对象,就是要把问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描述每个事物在整个解决问题过程中的行为,强调的是对象本身(主语) 还有就是数据是单独存储还是与操作存储在一起.对面向过程而言,数据是独立的.而在面向对象中,对象本身就

JavaScript 基础学习1-day14

JavaScript 基础学习1 知识预览JavaScript概述二 JavaScript的基础三 JavaScript的对象BOM对象DOM对象实例练习js扩展 JavaScript概述 JavaScript的历史 1992年Nombas开发出C-minus-minus(C--)的嵌入式脚本语言(最初绑定在CEnvi软件中).后将其改名ScriptEase.(客户端执行的语言) Netscape(网景)接收Nombas的理念,(Brendan Eich)在其Netscape Navigator

五本书籍助你从零基础学习java编程到精通之路

前天的文章给大家介绍了Java初学者应该学习哪些基础,亦是美网络小编从Java的三个大方向:J2SE.J2EE.J2ME对大家做了前景分析,这两天也收到了大家的很多反馈,很多小伙伴看了后对自己的Java编程方向有了比较明确的目标,也有小伙伴们说,要是能提供一些Java初学者应看的书籍就更好了,其实推荐Java书籍已经被规划在小编写的Java编程系列文章之中,常言道:书中自有黄金屋,书中自有颜如玉,下面亦是美网络小编给大家推荐的Java书籍中虽然没有黄金屋和颜如玉,但却能让Java编程的初学者快速

java基础学习笔记day01

java基础学习笔记day01 1.软件开发: 软件:按照特定顺序组织的计算机数据和指令的集合开发:软件的制作过程软件开发:借助开发工具和计算机语言制作软件 2.java概述: java之父:詹姆斯·高斯林 JDK:java开发环境 jre:java运行环境 JVM:java虚拟机 java跨平台是因为,JVM能在不同的平台运行,JVM是跨平台的 JavaSE:标准版 JavaME:手机端,物联网 JavaEE:企业版,互联网项目 3.java语言特点: 简单性解释性面向对象高性能分

黑马程序员_毕向东_Java基础视频教程_Java基础学习知识点总结

黑马程序员_毕向东_Java基础视频教程 Java基础学习知识点总结 2016年01月06日 day01 一.基础知识:软件开发 1.什么是软件?软件:一系列按照特定顺序组织的计算机数据和指令的集合. 2.常见的软件:系统软件:如:DOS,Windows,Linux等.应用软件:如:扫雷,迅雷,QQ等. 3.什么是开发?制作软件. 二.基础知识:人机交互方式 4.软件的出现实现了人与计算机之间的更好的交互. 5.交互方式:图形化界面:这种方式简单直观,使用者易于接受,容易上手操作.命令行方式:

Day6 - Python基础6 面向对象编程

Python之路,Day6 - 面向对象学习本节内容: 面向对象编程介绍为什么要用面向对象进行开发? 面向对象的特性:封装.继承.多态类.方法. 引子你现在是一家游戏公司的开发人员,现在需要你开发一款叫做<人狗大战>的游戏,你就思考呀,人狗作战,那至少需要2个角色,一个是人, 一个是狗,且人和狗都有不同的技能,比如人拿棍打狗, 狗可以咬人,怎么描述这种不同的角色和他们的功能呢? 你搜罗了自己掌握的所有技能,写出了下面的代码来描述这两个角色 1 2 3 4 5 6 7 8 9 10 11

零基础学习hadoop到上手工作线路指导（中级篇）

此篇是在零基础学习hadoop到上手工作线路指导(初级篇)的基础,一个继续总结. 五一假期:在写点内容,也算是总结.上面我们会了基本的编程,我们需要对hadoop有一个更深的理解: hadoop分为hadoop1.X.hadoop2.X,并且还有hadoop生态系统.这里只能慢慢介绍了.一口也吃不成胖子. hadoop 1.x分为 mapreduce与hdfs其中mapreduce是很多人都需要迈过去的槛,它比较难以理解,我们有时候即使写出了mapreduce程序,但是还是摸不着头脑. 我们不知