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

最新推荐文章于 2024-07-20 11:30:31 发布
最新推荐文章于 2024-07-20 11:30:31 发布
阅读量681 收藏 1
点赞数
分类专栏： JAVA基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ko0491/article/details/48447829
版权

一、异常捕获

 

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

    }

}
复制代码

 

 

森林森
关注
专栏目录
Java面向对象程序设计--试题.doc
09-30
面向对象程序设计（OOP）是Java的基础，通过封装、继承和多态等概念来构建复杂系统。 1. 构造函数是在创建对象时被调用的，用于初始化新创建的对象。因此，正确答案是D：对象被创建时。 2. 在Java中，子类继承父类...
Java面向对象编程题
Terita的博客
09-20 1万+
Java面向对象编程题
java面向的工作_【测试程序员面试题】面试问题：Java面向对… - 看准网
weixin_35615322的博客
02-26 1353
1、 请创建一个Animal动物类，要求有方法eat()方法，方法输出一条语句“吃东西”。 创建一个接口A，接口里有一个抽象方法fly()。创建一个Bird类继承Animal类并实现 接口A里的方法输出一条有语句“鸟儿飞翔”，重写eat()方法输出一条语句“鸟儿 吃虫”。在Test类中向上转型创建b对象，调用eat方法。然后向下转型调用eat()方 法、fly()方法。评分标准：正确写出Anima...
面向对象（Java）复习--选择题
m0_54453375的博客
06-18 793
类别访问修饰符非访问修饰符类修饰符public（公共类修饰符abstract（抽象类修饰符抽象方法必须要有抽象符，在修饰类时必须放在类名前声明抽象方法不可写出大括号、不能实例化final （最终类，不能被继承属性修饰符static（静态域修饰符 ）方法修饰符public 、 private、 protected 、 默认修饰符abstract（抽象方法控制符，只有方法的定义而没有方法体和操作实现）类方法中不能出现this或者super关键字；
Java面向对象选择题
PPDY93的博客
11-13 3532
一、选择题 在java中，以下程序的运行结果是（C） A. 输出：null B.正常运行，但不会输出任何内容 C. 编译出错，不能运行 D. 能运行，但运行时会出现异常 在类的继承关系中，需要遵循以下哪个继承原则？（B ） A 多重 B 单一 C 双重 D 不能继承 下面代码运行的正确结果是（C） A 编译错误，无法正常运行 B 编译正确，但运行时产生错误 C hello D world （A）空间用于存储使用new关键字所创建的对象 A 堆 B 栈 C 代码
Java面向对象基础练习题（含答案超详细）
热门推荐
weixin_49199821的博客
12-13 1万+
第1题 案例： 声明一个日期类MyDate，包含属性：年、月、日 声明一个Test02测试类，并在main方法中，创建3个日期对象，一个是你的出生日期，一个是我们开班 的日期，一个是今年过年的日期，并打印显示 系统预定义的日期类型。jdk1.8+提供了2套日期类型 java.util.Date public class Date implements java.io.Serializable,Cloneable, Comparable<Date>{ private...
JAVA面向对象程序设计(期末考试试题及答案).zip
06-05
这个压缩包文件"JAVA面向对象程序设计(期末考试试题及答案).zip"包含了学习和复习Java OOP的关键资源，包括一份详细的资源说明文档和期末考试试题及答案的PDF。 资源说明.docx可能涵盖了学习Java OOP的基础概念、...
java基础及面向对象试题.docx
11-26
【标题】: Java基础及面向对象试题 【描述】: 本试题主要涵盖Java编程的基础知识，包括变量命名规则、程序错误修正、逻辑判断、循环语句、数组操作、面向对象特性（如类、构造器、方法重载、重写）以及JVM内存结构...
JAVA面向对象程序设计(期末考试试题及答案)
06-16
本文总结了 JAVA面向对象程序设计的知识点，涵盖了 Java 语言的基本语法、面向对象编程的概念、异常处理、多线程编程、网络编程、数据库编程等方面的知识，为学习和掌握 Java 语言提供了有价值的参考。
JAVA面向对象程序设计(期末考试试题及答案).pdf
03-28
Java面向对象程序设计是编程领域中的核心概念，它基于面向对象的编程思想，将现实世界中的实体抽象为类，通过类来创建对象，实现代码的复用...通过学习和理解这些内容，开发者能够更好地理解和编写面向对象的Java程序。
Java面向对象程序设计综合练习1（选择题）
大家一起入坑
06-20 7089
以上答案都不正确R2-29R2-47R2-56
面向对象练习题
weixin_45012397的博客
04-09 1283
java.utiljava.langjava.io同一包下的类。
Java面向对象程序设计（江财版题库）
aqiao345的博客
06-24 1545
三、程序阅读题（从下列各题四个或五个备选答案中选出一个正确答案，并将其代号写在答题纸相应位置处。每小题1分，共15分。27.(int)('a' + Math.random() * ('z' - 'a' + 1)) 返回一个随机数范围__________.27. (char)('a' + Math.random() * ('z' - 'a' + 1)) 返回一个随机字符范围（ ）14. (char)('a' + Math.random() * ('z' - 'a' + 1)) 返回一个随机字符范围（ ）
Java面向对象篇选择题总结练习
YING—country的博客
09-26 5016
Java面向对象篇选择题练习
【Java练习题汇总】《第一行代码JAVA》面向对象进阶篇，汇总Java练习题——面向对象：特性详解、关键字this、super、instanceof、final、static、抽象类与接口... ~
Technology changes the world of life
07-17 1097
《第一行代码JAVA》面向对象进阶篇，汇总Java练习题——面向对象：特性详解、关键字this、super、instanceof、final、static、抽象类与接口... ~
Java基础编程500题——面向对象
最新发布
安晴晚风的博客
07-20 3268
Java基础编程500题——面向对象
每日作业 - JavaSE第7天
FreeSpider
10-19 2284
知识点 面向对象 题目1（训练） 定义手机类，手机有品牌(brand),价格(price)和颜色(color)三个属性，有打电话call()和sendMessage()两个功能。 请定义出手机类，类中要有空参、有参构造方法，set/get方法。 定义测试类，在主方法中使用空参构造创建对象，使用set方法赋值。 调用对象的两个功能，打印效果如下： 正在使用价格为3998元黑色的小米手机打电话.......
Java常见编程练习题-面向对象编程
bxy0806的博客
07-11 199
【代码】Java常见编程练习题-面向对象编程。
Java面向对象程序设计期末题库
m0_62553649的博客
06-25 2091
Java 选择题1.下列选项中,不属于Java语言特点的一项是( C )。A.分布式 B.安全性 C.编译执行 D.面向对象2.在Java语言中,( C )是最基本的元素?A.方法 B.包 C.对象 D.接口3. 编译一个定义了3个类和10个方法的Java源文件后,会产生( D )个字节码文件?扩展名是( )?A.13个字节码文件,扩展名为.classB.1个字节码文件,扩展名为.classC.3个字节码文件,扩展名为.javaD.3个字节码文件,扩展名为.cl
JAVA面向对象基础选择题及解析
"这是一份JAVA面向对象编程的考试题库，包含50道选择题和部分简答题，旨在测试和提升对JAVA面向...这个考试题库可以帮助学习者巩固JAVA面向对象编程的基础知识，通过解答这些题目，可以检验对面向对象概念的理解程度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值