Java抽象类接口、内部类题库_编写程序描述兔子和青蛙。分析兔子和青蛙的共性-程序员宅基地

一、选择题

1.	Person类和Test类的代码如下所示，则代码中的错误语句是（ C ）。（选择一项）
	public class Person { public String name; public Person(String name) { this.name = name; } } public class Test { public static void main(String[] args) { final Person person = new Person("欧欧"); person.name = "美美"; person = new Person("亚亚"); } }

	A.	final Person person = new Person("欧欧");
	B.	person.name = "美美";
	C.	person = new Person("亚亚");
	D.	没有错误

2.	如下Java代码运行的结果是（ B ）。（选择一项）
	public class Test { final int age; public Test(){ age=10; } public static void main(String[ ] args) { System.out.println(new Test().age); } }

	A	输出：0
	B.	输出：10
	C.	输出：null
	D.	运行时出现异常

3.	以下代码中错误的语句是（ D ）。（选择一项）
	public class Something{ public static void main(String[] args){ final Other o=new Other(); new Something().addOne(o);//1 } public void addOne( Other o){ o.i++;//2 o = new Other();//3 } } class Other{ public int i; }

	A	1
	B.	2
	C.	3
	D.	没有错误

4.	下列选项中，关于Java的抽象类和抽象方法说法正确的是（ AC ）。（选择二项）

	A	抽象类中可以含有0个或多个抽象方法
	B.	抽象类中不可以有构造方法
	C.	一个类中若有抽象方法，则这个类必为抽象类
	D.	子类必须重写父类所有的抽象方法

5.	在Java中关于abstract关键字，以下说法正确的是（ AB ）。（选择两项）

	A	abstract类中可以没有抽象方法
	B.	abstract类的子类也可以是抽象类
	C.	abstract方法可以有方法体
	D.	abstract类可以创建对象

6.	以下选项可替换题目中//add code here而不产生编译错误的是（ AD ）。（选择二项）
	public abstract class MyClass{ public int constInt=5; //add code here public void method( ){ } }

	A	public abstract void method(int a);
	B.	constInt =constInt+5;
	C.	public int method( );
	D.	public abstract void anotherMethod( );

7.	在Java接口中，下列选项中属于有效的方法声明是（ AC ）。（选择二项）

	A	public void aMethod( );
	B.	final void aMethod( );
	C.	void aMethod(){ }
	D.	private void aMethod( );

8.	以下选项中关于匿名内部类的说法正确的是（ BC ）。（选择二项）

	A.	匿名内部类可以实现多个接口，或者继承一个父类
	B.	匿名内部类不能是抽象类，必须实现它的抽象父类或者接口里包含的所有抽象方法
	C.	匿名内部类没有类名，所以匿名内部类不能定义构造方法
	D.	匿名内部类可以直接访问外部类的所有局部变量

二、判断题（共20个题目，总计10分）

声明为final的类不能是超类。（ T ）
使用final修饰的变量将变成常量，其中不能再被改变；使用final修饰的方法将无法被子类重载；使用final修饰的类将无法再被其他类继承。（ T ）
抽象方法不能含有方法体，并且必须定义在抽象类中。（ F ）
抽象类是指在class前加使用abstract关键字修饰，且可以存在抽象方法和普通方法的类。（ T ）
接口中只有常量，没有变量；只有抽象方法，并且全部都是public方法。（ T ）
抽象类和接口都不能实例化，都没有构造方法。（ F ）
接口并不要求实现类和接口在概念本质上一致的，仅仅是实现了接口定义的约定或者能力而已。接口定义了“做什么”，而实现类负责完成“怎么做”，体现了功能（规范）和实现分离的原则。（ T ）
内部类作为外部类成员，权限修饰符和其他成员一样，可声明为private、默认、protected或public。( T )
匿名内部类适合创建那种只需要使用一次的类，它可以实现一个或多个接口，或者继承一个父类。（ F ）
对于物理连接，比如数据库连接、输入流输出流、Socket连接等，垃圾回收机制无能为力，必须手动关闭才可以。( T )
垃圾回收机制回收任何对象之前，总会先调用它gc( )方法，该方法是Object类提供的方法。不要主动调用某个对象的该方法，应该交给垃圾回收机制调用。（ F ）

三、简答题

final和abstract关键字的作用。
接口和抽象类的联系和区别。
内部类的类型及其特点。

四、编码题

1.编写程序描述兔子和青蛙

需求说明：使用面向对象的思想，设计自定义类描述兔子和青蛙。

实现思路及关键代码

1) 分析兔子和青蛙的共性

2) 根据共性，定义抽象的动物类

属性：名字、颜色、类别（哺乳类、非哺乳类）

方法：吃饭，发出叫声

3) 根据青蛙会游泳抽象游泳的接口

方法：游泳

4) 定义兔子继承动物类，青蛙继承动物同时实现游泳接口

程序运行结果如图所示。

  
  
   
     /**
      *
      * 动物类
      *
      * @author Administrator
      *
      */
     public abstract class Animal
     {
      
         private String name;//名字
         private String color;//颜色
         private String type;//类别（哺乳类、非哺乳类）
         public Animal()
         {
      
             super();
         }
         public Animal(String name, String color, String type)
         {
      
             super();
             this.name = name;
             this.color = color;
             this.type = type;
         }
         public String getName()
         {
      
             return name;
         }
         public void setName(String name)
         {
      
             this.name = name;
         }
         public String getColor()
         {
      
             return color;
         }
         public void setColor(String color)
         {
      
             this.color = color;
         }
         public String getType()
         {
      
             return type;
         }
         public void setType(String type)
         {
      
             this.type = type;
         }
         /**
          *
          * 发出叫声
          *
          */
         public abstract void shout();
         /**
          *
          * 吃饭
          *
          */
         public abstract void eat();
     }
     /**
      *
      * 游泳接口
      *
      * @author Administrator
      *
      */
     public interface Swimmable
     {
      
         /**
          *
          * 游泳
          *
          */
         public void swim();
     }
     public class Frog extends Animal implements Swimmable
     {
      
         public Frog()
         {
      
             super();
         }
         public Frog(String name, String color, String type)
         {
      
             super(name, color, type);
         }
         @Override
         public void shout()
         {
      
             System.out.println("那只" + super.getColor()
                     + "的，名字叫" + super.getName() + "的青蛙正在呱呱的叫");
         }
         @Override
         public void eat()
         {
      
             System.out.println("青蛙是" + super.getType() + ",爱吃昆虫");
         }
         @Override
         public void swim()
         {
      
             System.out.println("虽然不是鱼，但是青蛙也是游泳高手");
         }
     }
     public class Rabbit extends Animal
     {
      
         public Rabbit()
         {
      
             super();
         }
         public Rabbit(String name, String color, String type)
         {
      
             super(name, color, type);
         }
         @Override
         public void shout()
         {
      
             System.out.println("那只" + super.getColor()
                     + "的，名字叫" + super.getName() + "的兔子正在叽叽的叫");
         }
         @Override
         public void eat()
         {
      
             System.out.println("兔子是" + super.getType() + ",爱吃胡萝卜");
         }
     }
     public class Test
     {
      
         public static void main(String[] args)
         {
      
             Animal rabbit = new Rabbit("美人", "黑色", "哺乳类");
             rabbit.shout();
             rabbit.eat();
             System.out.println("====================");
             Animal frog = new Frog("大兵", "绿色", "非哺乳类");
             frog.shout();
             frog.eat();
             Swimmable swimer = (Swimmable) frog;
             swimer.swim();
         }
     }

2.编写程序描述影视歌三栖艺人

需求说明：请使用面向对象的思想，设计自定义类，描述影视歌三梄艺人。

实现思路及关键代码

1) 分析影视歌三栖艺人的特性

a) 可以演电影

b) 可以演电视剧

c) 可以唱歌

2) 定义多个接口描述特性

a) 演电影的接口-----方法：演电影

b) 演电视剧的接口-----方法：演电视剧

c) 唱歌的接口-----方法：唱歌

3) 定义艺人类实现多个接口

程序运行结果如图2所示。

  
  
   
     /**
      *
      * 可演电影接口
      *
      * @author Administrator
      *
      */
     public interface Filmable
     {
      
         /**
          *
          * 演电影
          *
          */
         public void actFilm();
     }
     /**
      *
      * 会唱歌接口
      *
      * @author Administrator
      *
      */
     public interface Singable
     {
      
         /**
          *
          * 唱歌
          *
          */
         public void sing();
     }
     /**
      *
      * 会演电视剧接口
      *
      * @author Administrator
      *
      */
     public interface TVable
     {
      
         /**
          *
          * 演电视剧
          *
          */
         public void showTV();
     }
     public class Star implements Filmable, TVable, Singable
     {
      
         private String name;//姓名
         public Star()
         {
      
             super();
         }
         public Star(String name)
         {
      
             super();
             this.name = name;
         }
         public String getName()
         {
      
             return name;
         }
         public void setName(String name)
         {
      
             this.name = name;
         }
         @Override
         public void sing()
         {
      
             System.out.println("我会唱歌");
         }
         @Override
         public void showTV()
         {
      
             System.out.println("我能演电视剧");
         }
         @Override
         public void actFilm()
         {
      
             System.out.println("我能演电影");
         }
         public void introduce()
         {
      
             System.out.println("大家好，我是" + name);
         }
     }
     public class Test
     {
      
         public static void main(String[] args)
         {
      
             Star star = new Star("马素素");
             star.introduce();
             star.actFilm();
             star.showTV();
             star.sing();
         }
     }

3.写一个方法对任意引用数据类型数组进行排序。具体要求如下:

1) 方法声明为public void sortArr(Object arr[]){ }

2) 方法中首先输出排序前数组内容，然后进行排序，最后输出排序后数组内容。

3) 可以是冒泡排序或其他算法实现，不直接调用Java提供的方法实现排序。

思路：任意类实现Comparable接口来实现该引用数据类型的元素排序，在sort()方法中将Object强转成Comparable实现两个对象的比较。

  
  
   
     public void sort(Object[] arr)
     {
      
         //输出排序前数组
         for (int i = 0; i < arr.length; i++)
         {
      
             System.out.println(arr[i]);
         }
         //大循环，一共n个元素，达到最终有序，至多n-1趟比较
         Object temp;
         for (int i = 0; i < arr.length - 1; i++)
         {
      
             //定义一个符号量
             boolean flag = true;//没有交换，有序
             //小循环
             for (int j = 0; j < arr.length - 1 - i; j++)
             {
      
                 //如果前一个大于后一个
                 Comparables c1 = (Comparables) arr[j];
                 Comparables c2 = (Comparables) arr[j + 1];
                 if (c1.compareTo(c2) > 0)
                 {
      
                     //交换
                     temp = arr[j];
                     arr[j] = arr[j + 1];
                     arr[j + 1] = temp;
                     //修改符号量
                     flag = false;//交换过，无序
                 }
             }
             //判断经过此趟循环后是否已经有序
             if (flag)
             {
      
                 break;//退出外层循环，省略后续趟循环
             }
         }
         //输出排序后数组
         for (int i = 0; i < arr.length; i++)
         {
      
             System.out.println(arr[i]);
         }
     }

五、可选题

1.实现不同符合PCI规范的适配器

需求说明：PCI是一种规范，所有实现了该规范的适配器，必如显卡、声卡、网卡都可以安装到PCI插槽上并工作。模拟实现该功能。

实现思路及关键代码

1) 定义PCI接口，具有传送数据send()方法

2) 定义显卡VideaCard类，实现该接口

3) 定义声卡AudioCard类，实现PCI接口

4) 定义网卡NetCard类，实现PCI接口

5) 定义测试类，让显卡、声卡、网卡发送数据

  
  
   
     class a
     {
      
         /**
          *
          * PCI接口
          *
          * @author Administrator
          *
          *
          *
          */
         public interface PCI
         {
      
             /**
              *
              * 传输数据
              *
              */
             public void send();
         }
         public class VideoCard implements PCI
         {
      
             @Override
             public void send()
             {
      
                 System.out.println("使用PCI接口传输视频数据");
             }
         }
         public class SoundCard implements PCI
         {
      
             @Override
             public void send()
             {
      
                 System.out.println("使用PCI接口传输声音数据");
             }
         }
         public class NetCard implements PCI
         {
      
             @Override
             public void send()
             {
      
                 System.out.println("使用PCI接口传输网络数据");
             }
         }
         public class Test
         {
      
             public static void main(String[] args)
             {
      
                 PCI p1 = new VideoCard();
                 p1.send();
                 PCI p2 = new SoundCard();
                 p2.send();
                 PCI p3 = new NetCard();
                 p3.send();
             }
         }
     }

2.实现不同引用类型对象的大小比较

需求说明：学生类，新闻类，商品类虽然是完全不同的类，但是都具有比较的能力，比如可以比较两个学生的大小，但需要指定比较的依据是学号、姓名还是成绩等。

实现思路及关键代码：

将比较的能力定义为接口，让学生、新闻、商品类都实现该接口。

1) 定义接口Comparable，其中包含唯一的方法int compareTo(Object obj)；返回值>0，表示大于，返回值=0，表示等于，返回值<0，表示小于。

2) 定义学生类，包括学号、姓名、年龄和分数，实现Comparable接口，按照分数倒序排列；

3) 定义新闻类，包括编号（int类型）、标题、内容和点击数，实现Comparable接口，按照编号正序排列；

4) 定义测试类，分别创建两个学生对象、新闻对象，进行比较并输出结果。

  
  
   
     /**
      *
      * 比较接口
      *
      * @author Administrator
      *
      *
      *
      */
     public interface Comparable
     {
      
         /**
          *
          * 比较
          *
          * @param obj 另外一个对象
          *
          * @return 比较的结果 >0 大于 =0 等于 <0 小于
          *
          */
         public int compareTo(Object obj);
     }
     public class News implements Comparable
     {
      
         private int nid;//编号
         private String title; //标题
         private String contents;//内容
         private String type;//新闻类别
         public News()
         {
      
             super();
         }
         public News(int nid, String title, String contents, String type)
         {
      
             super();
             this.nid = nid;
             this.title = title;
             this.contents = contents;
             this.type = type;
         }
         /**
          *
          * 按照新闻编号正序排列
          *
          */
         public int compareTo(Object obj)
         {
      
             News other = (News) obj;
             return this.nid - other.nid;
         }
         @Override
         public String toString()
         {
      
             return "News [nid=" + nid + ", title=" + title + ", contents="
                     + contents + ", type=" + type + "]";
         }
     }
     public class Student implements Comparable
     {
      
         private int id;
         private String name;
         private int age;
         private double score;
         public Student()
         {
      
             super();
         }
         public Student(int id, String name, int age, double score)
         {
      
             super();
             this.id = id;
             this.name = name;
             this.age = age;
             this.score = score;
         }
         /**
          *
          * 按照学生成绩降序排序
          *
          */
         public int compareTo(Object obj)
         {
      
             Student other = (Student) obj;
             if (this.score > other.score)
             {
      
                 return -1;
             } else if (this.score < other.score)
             {
      
                 return 1;
             } else
             {
      
                 return 0;
             }
         }
         @Override
         public String toString()
         {
      
             return "Student [id=" + id + ", name=" + name + ", age=" + age
                     + ", score=" + score + "]";
         }
     }
     public class Test
     {
      
         public static void main(String[] args)
         {
      
             //
             Student stu1 = new Student(11, "小红", 18, 97d);
             Student stu2 = new Student(12, "小东", 20, 98d);
             if (stu1.compareTo(stu2) > 0)
             {
      
                 System.out.println(stu2);
                 System.out.println(stu1);
             } else
             {
      
                 System.out.println(stu1);
                 System.out.println(stu2);
             }
             //
             News news1 = new News(33, "恒大亚冠", "恒大亚冠小组被淘汰", "体育");
             News news2 = new News(44, "上海尚学堂", "请原谅我的姗姗来迟", "IT");
             if (news1.compareTo(news2) > 0)
             {
      
                 System.out.println(news2);
                 System.out.println(news1);
             } else
             {
      
                 System.out.println(news1);
                 System.out.println(news2);
             }
         }
     }

本文链接：https://blog.csdn.net/mzd8341/article/details/76164960

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

稀疏编码的数学基础与理论分析-程序员宅基地

文章浏览阅读290次，点赞8次，收藏10次。1.背景介绍稀疏编码是一种用于处理稀疏数据的编码技术，其主要应用于信息传输、存储和处理等领域。稀疏数据是指数据中大部分元素为零或近似于零的数据，例如文本、图像、音频、视频等。稀疏编码的核心思想是将稀疏数据表示为非零元素和它们对应的位置信息，从而减少存储空间和计算复杂度。稀疏编码的研究起源于1990年代，随着大数据时代的到来，稀疏编码技术的应用范围和影响力不断扩大。目前，稀疏编码已经成为计算...

EasyGBS国标流媒体服务器GB28181国标方案安装使用文档-程序员宅基地

文章浏览阅读217次。EasyGBS - GB28181 国标方案安装使用文档下载安装包下载，正式使用需商业授权, 功能一致在线演示在线API架构图EasySIPCMSSIP 中心信令服务, 单节点, 自带一个 Redis Server, 随 EasySIPCMS 自启动, 不需要手动运行EasySIPSMSSIP 流媒体服务, 根..._easygbs-windows-2.6.0-23042316使用文档

【Web】记录巅峰极客2023 BabyURL题目复现——Jackson原生链_原生jackson 反序列化链子-程序员宅基地

文章浏览阅读1.2k次，点赞27次，收藏7次。2023巅峰极客 BabyURL之前AliyunCTF Bypassit I这题考查了这样一条链子：其实就是Jackson的原生反序列化利用今天复现的这题也是大同小异，一起来整一下。_原生jackson 反序列化链子

一文搞懂SpringCloud，详解干货，做好笔记_spring cloud-程序员宅基地

文章浏览阅读734次，点赞9次，收藏7次。微服务架构简单的说就是将单体应用进一步拆分，拆分成更小的服务，每个服务都是一个可以独立运行的项目。这么多小服务，如何管理他们？(服务治理注册中心[服务注册发现剔除])这么多小服务，他们之间如何通讯？这么多小服务，客户端怎么访问他们？(网关)这么多小服务，一旦出现问题了，应该如何自处理？(容错)这么多小服务，一旦出现问题了，应该如何排错?(链路追踪)对于上面的问题，是任何一个微服务设计者都不能绕过去的，因此大部分的微服务产品都针对每一个问题提供了相应的组件来解决它们。_spring cloud

Js实现图片点击切换与轮播-程序员宅基地

文章浏览阅读5.9k次，点赞6次，收藏20次。Js实现图片点击切换与轮播图片点击切换<!DOCTYPE html><html> <head> <meta charset="UTF-8"> <title></title> <script type="text/ja..._点击图片进行轮播图切换

tensorflow-gpu版本安装教程（过程详细）_tensorflow gpu版本安装-程序员宅基地

文章浏览阅读10w+次，点赞245次，收藏1.5k次。在开始安装前，如果你的电脑装过tensorflow，请先把他们卸载干净，包括依赖的包（tensorflow-estimator、tensorboard、tensorflow、keras-applications、keras-preprocessing），不然后续安装了tensorflow-gpu可能会出现找不到cuda的问题。cuda、cudnn。..._tensorflow gpu版本安装

随便推点

物联网时代权限滥用漏洞的攻击及防御-程序员宅基地

文章浏览阅读243次。0x00 简介权限滥用漏洞一般归类于逻辑问题，是指服务端功能开放过多或权限限制不严格，导致攻击者可以通过直接或间接调用的方式达到攻击效果。随着物联网时代的到来，这种漏洞已经屡见不鲜，各种漏洞组合利用也是千奇百怪、五花八门，这里总结漏洞是为了更好地应对和预防，如有不妥之处还请业内人士多多指教。0x01 背景2014年4月，在比特币飞涨的时代某网站曾经..._使用物联网漏洞的使用者

Visual Odometry and Depth Calculation--Epipolar Geometry--Direct Method--PnP_normalized plane coordinates-程序员宅基地

文章浏览阅读786次。A. Epipolar geometry and triangulationThe epipolar geometry mainly adopts the feature point method, such as SIFT, SURF and ORB, etc. to obtain the feature points corresponding to two frames of images. As shown in Figure 1, let the first image be and th_normalized plane coordinates

开放信息抽取(OIE)系统（三）-- 第二代开放信息抽取系统(人工规则, rule-based, 先抽取关系)_语义角色增强的关系抽取-程序员宅基地

文章浏览阅读708次，点赞2次，收藏3次。开放信息抽取(OIE)系统（三）-- 第二代开放信息抽取系统(人工规则, rule-based, 先关系再实体)一.第二代开放信息抽取系统背景第一代开放信息抽取系统(Open Information Extraction， OIE， learning-based, 自学习, 先抽取实体)通常抽取大量冗余信息，为了消除这些冗余信息，诞生了第二代开放信息抽取系统。二.第二代开放信息抽取系统历史第二代开放信息抽取系统着眼于解决第一代系统的三大问题: 大量非信息性提取（即省略关键信息的提取）、_语义角色增强的关系抽取