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

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

智能推荐

计算两个经纬度点之间的距离_getdistance求经纬度之间的距离-程序员宅基地

文章浏览阅读1.2k次。计算经纬度点之间距离的算法 getDistance(lat1, lng1, lat2, lng2) { const radLat1 = lat1 * Math.PI / 180.0; const radLat2 = lat2 * Math.PI / 180.0; const a = radLat1 - radLat2; con..._getdistance求经纬度之间的距离

Unity + Grpc + protobuf + C# 使用流程详解_unity grpc-程序员宅基地

文章浏览阅读3.7k次，点赞11次，收藏30次。最近公司的一个unity项目要把通信方式从Photon替换成grpc，正好系统学一下grpc,以下是我的学习心得。本篇博客系统详细地介绍了unity使用grpc通信的全部要点，希望可以帮助到大家。奥利给！详解目录一、本篇博客知识点简介二、资源及工具的下载地址1、protocolBuffer各个版本2、GRPC3、grpc_unity_package.2.27.0-dev4、.NET Core SDK 2.1及以上三、C#使用Grpc方法流程1、新建项目2、定义服务3、使用GRPC.Tools自动生成.c_unity grpc

Keil出现无法生成.hex文件，经检查，发现是MULTIPLE PUBLIC DEFINITIONS。_keil生成不了hex文件的原因multilple-程序员宅基地

文章浏览阅读1.3w次，点赞4次，收藏6次。Keil出现无法生成.hex文件，经检查，发现是MULTIPLE PUBLIC DEFINITIONS。实际并不应该出现这种问题。回顾新建项目时在选择单片机型号STC12C5A60S2后，在CPU栏没有选择默认，而是选择了　Use　Extended Linker(LX51) instead of BL51 和 Use Extended Assembler(AX51) instead of ..._keil生成不了hex文件的原因multilple

hibernate 的dialect(方言)配置_hibernate.dialect配置-程序员宅基地

文章浏览阅读4.2k次。转自：https://blog.csdn.net/baidu_40487407/article/details/93042568RDBMS方言RDBMSDialectDB2org.hibernate.dialect.DB2DialectDB2 AS/400org.hibernate.dialect.DB2400DialectDB2 OS390org.hibern..._hibernate.dialect配置

Linux---wifi驱动移植及调试（SSV6x5x）_linux wifi驱动-程序员宅基地

文章浏览阅读4.4k次，点赞2次，收藏21次。南方硅谷ssv6x5x驱动移植_linux wifi驱动

Win10系统怎么使用U盘重装（图文并茂）_windows10下载u盘安装-程序员宅基地

文章浏览阅读6k次，点赞6次，收藏56次。本教程一共分为了10个步骤，每一个步骤都有图片，相对来说非常详细了，欢迎大家讨论与学习！_windows10下载u盘安装