精华内容
下载资源
问答
  • 2021-03-11 14:17:19

    【其它】定义一个Father和Child类,并进行测试。 1)Father类为外部类,类中定义一个私有的String类型的属性name,name的值为“zhangjun”。 2)Child类为Father类的内部类,其中定义一个introFather()方法,方法中调用Father类的name属性。 3)定义一个测试类Test,在Test类的main()方法中,创建Child对象,并调用introFather ()方法。

    【填空题】被static关键字修饰的成员变量被称为______,它可以被该类所有的实例对象共享。

    【其它】拍摄一组(3-5张,不同环境,不同机位)校园自然光人像照片,运用学习的各种摄影知识。

    【简答题】简述&&与&的区别并举例说明。

    【填空题】所谓类的封装是指在定义一个类时,将类中的属性私有化,即使用______关键字来修饰。

    【多选题】关于super关键字以下说法哪些是正确的?

    【填空题】Java中的程序代码都必须在一个类中定义,类使用______关键字来定义。

    【填空题】在Java中,提供了一个______命令,用于将程序中的文档注释提取出来,生成HTML格式的帮助文档。

    【多选题】关于内部类,下面说法正确的是?(多选)

    【判断题】continue 语句只用于循环语句中,它的作用是跳出循环。

    【填空题】Select an appropriate verb form from the two given in the brackets. 1.( ) 2.( ) 3.( ) 4.( ) 5.( ) 6.( ) 7.( ) 8.( ) 9.( ) 10.( ) 11.( ) 12.( ; ; ) 13.( ) 14.( ) 15.( ) 16.( ) 17.( ) 18.( ) 19.( ) 20.( ) 21.( ) 22.( ) 23.( ) 24.( ) 25.( ) 26.( ) 27.( ) 28.( ) 29.( ) 30.( ) 31.( ) 32.( ) 33.( ) 34.( ) 35.( ) 36.( ) 37.( ) 38.( ) 39.( ) 40.( ) 14.( ) 42.( ) 43.( ) 44.( ) 45.( ) 46.( ) 47.( ) 48.( ) 49.( ) 50.( )

    【单选题】在Java中,要想让一个类继承另一个类,可以使用以下哪个关键字?

    【其它】根据授课内容,拍摄3种站姿和3种坐姿。

    【填空题】面向对象的三大特征是______、______和______。

    【填空题】当一个对象被当成垃圾从内存中释放时,它的______方法会被自动调用。

    【单选题】类的定义必须包含在以下哪种符号之间?

    【填空题】定义在类中的变量被称为______,定义在方法中的变量被称为______

    【填空题】面向对象程序设计的重点是______的设计,______是用来创建对象的模板。

    【单选题】编译运行下面的程序,结果是什么? public class A { public static void main(String[] args) { B b = new B(); b.test(); } void test() { System.out.print("A"); } } class B extends A { void test() { super.test(); System.out.print("B"); } }

    【其它】请拍摄4张人像照片,分别为全身人像,半身人像,七分人像和特写。

    【填空题】在一个类中,除了可以定义属性、方法,还可以定义类,这样的类被称为______。

    【填空题】布尔常量即布尔类型的两个值,分别是______和______。

    【判断题】在定义一个类的时候,如果类的成员被private所修饰,该成员不能在类的外部被直接访问。

    【判断题】Java中的每个类都至少有一个构造方法,一个类中如果没有定义构造方法,系统会自动为这个类创建一个默认的构造方法。

    【其它】根据之前胡秋季主题摄影方案策划进行拍摄,并进行作品的提交。 要求:组照(10张左右),每一张照片都要附上拍摄的位置信息,拍摄时的感想,并说明作品的优点和缺点。

    【判断题】ava语言不区分大小写。

    【单选题】下面哪一个是正确的类的声明?

    【多选题】下面哪些可以使用static关键字修饰?

    【填空题】在Java中,可以使用关键字______来创建类的实例对象。

    【单选题】请先阅读下面的代码 public class Test { public Test(){ System.out.println("构造方法一被调用了"); } public Test(int x){ this(); System.out.println("构造方法二被调用了"); } public Test(boolean b){ this(1); System.out.println("构造方法三被调用了"); } public static void main(String[] args) { Test test = new Test(true); } } 上面程序的运行结果为下列哪一项?

    【多选题】以下说法哪些是正确的?

    【简答题】请列举Java语言中的八种基本数据类型,并说明每种数据类型所占用的空间大小。

    【单选题】在以下什么情况下,构造方法会被调用?

    【其它】通过课堂学习,了解自己的摄影器材 确定自己本学期采用的摄影器材(比如说:XXX 手机,镜头光圈 XXX,焦距XXX,CMOS尺寸是XXX) 2.根据本课学习的关于好照片的标准,从你的手机中,找出三张你自己拍摄的你最喜欢的好照片。(要求至少一张是人像照片)

    【简答题】单例设计模式具备哪些特点?

    【单选题】在Java语言中,以下哪个关键字用于在方法上声明抛出异常?

    【单选题】在类的继承关系中,需要遵循以下哪个继承原则?

    【单选题】类中的一个成员方法被下面哪个修饰符修饰,该方法只能在本类被访问?

    【单选题】已知类的继承关系如下: class Employee; class Manager extends Employeer; class Director extends Employee; 则以下语句能通过编译的有哪些?

    【填空题】Choose an appropriate verb form, giving two answers where possible. 1.( ) 2.( ) 3.( ) 4.( ) 5.( ) 6.( ) 7.( ) 8.( ) 9.( ) 10.( ) 11.( ) 12.( ) 13.( ) 14.( ) 15.( ) 16.( ) 17.( ) 18.( ) 19.( ) 20.( )

    【判断题】声明构造方法时,不能使用private关键字修饰。

    【判断题】类中static修饰的变量或方法,可以使用类名或对象的引用变量访问。

    【其它】军训专题摄影 要求上交一组(5-10张)军训照片,表现学生军训的刻苦,坚韧的意志品质和精神面貌。 可以拍摄全景,特写,静物来表现军训的场景。

    【填空题】Choose an acceptable verb form from the two given in brackets according to the standard of formal writing. 1.( ) 2.( ) 3.( ) 4.( ) 5.( ) 6.( ) 7.( ) 8.( ) 9.( ) 10.( ) 11.( ) 12.( ) 13.( ) 14.( ) 15.( ) 16.( ) 17.( ) 18.( ) 19.( ) 20.( ) 21.( ) 22.( ) 23.( ) 24.( ) 25.( ) 26.( ) 27.( ) 28.( ) 29.( ) 30.( )

    【简答题】构造方法和普通的成员方法有什么区别?

    【多选题】下面对于构造方法的描述,正确有哪些?(多选)

    【判断题】方法内部类中不能访问外部类的成员变量。

    【多选题】下面对于单例设计模式的描述,正确的是?

    【多选题】使用this调用类的构造方法,下面的说法正确的是?(多选)

    【多选题】关于抽象类的说法哪些是正确的?

    更多相关内容
  • 所以继承和派生的关系就像小学时把字句和字句的造句一样。有了继承与派生后,就有了父类/基类与子类/派生,C++中将B称为父类/基类,将A称为子类/派生。 派生的声明: #include using namespace std;...
  • idea 查看类继承关系的快捷键

    千次阅读 2021-01-12 18:28:49
    类似eclipse ctrl+t的快捷键,idea是ctrl+H…找到对应的 查看类关系图…1.想要查看的上按 Ctrl + H -> Diagrams -> Show Diagrams -> Java Class Diagrams -> Show Implementations -> Ctrl +...

    类似eclipse ctrl+t的快捷键,idea中是ctrl+H…

    找到对应的类 查看类关系图…

    1.在想要查看的类上按 Ctrl + H -> Diagrams -> Show Diagrams -> Java Class Diagrams -> Show Implementations -> Ctrl + A -> 右击一下 -> Enter .…

    打开想要查看的接口或者类文件,使用快捷键CTRL+H调出Hierarchy窗口 比如,想要查看Exception的类继承关系,首先定位到这个文件,然后调出Hierarchy窗口. 该窗口上面的一排工具栏如下: 分别是: 查看完整的类(接口)阶层结构 查看父类或者父接口 查看子类 是否按照字母排序 当前操作搜索的范围[重点] 刷新 是否同步打开相应的类或者接口[即鼠标选中某个接口或类,编辑器自动打开] 扩展块或者隐藏块 固定窗口 导出所有的结构到文本文件中 如果用多了idea就会发现,很多的操作都…

    本章主要从整体层面了解Scala中的类层级关系. 一.Scala的类层级 在Java中Object类是所有类的最终父类,其他所有类都直接或间接的继承了Object类.在Scala中所有类的最终父类为Any类,所以Any类中的所有方法都可以在Scala中任意类中使用.但是这并不是说Scala中的Any类就类似于Java中的Object类,Scala中真正地位类似于Java中Object类的是AnyRef类. 在Scala中还提供了两个类Null和Nothing,这两个类在整个Scala类层级的最底…

    UnityEngine(命名空间) 其他命名空间 其他类 Object(类) 其他类(继承自Object) Component(类)(继承自Object) 其他类(继承自Component) Transform(类)(继承自Component) 其中,Transform继承自Component,而Component又继承自Object 常用脚本类继承关系图: 图片摘自,嗯对,就是水印那个地儿…

    前言: 本文代码基于python3 Content: 1.python中的序列类分类 2. python序列中abc基类继承关系 3. 由list的extend等方法来看序列类的一些特定方法 4. list这种序列类的一大特点:切片.和如何实现可切片对象.到如何自定义一个序列类. 5. biset维护排序序列 6. 什么时候使用list 7.列表推导式.生成器表达式.字典推导式 1.python中的序列类分类 a.什么是python的序列类? 之前提到的魔法函数这种时候就很重要啦.满足序列类相关…

    Java类初始化的顺序经常让人犯迷糊,现在本文尝试着从JVM的角度,对Java非继承和继承关系中类的初始化顺序进行试验,尝试给出JVM角度的解释. 非继承关系中的初始化顺序 对于非继承关系,主类InitialOrderWithoutExtend中包含了静态成员变量(类变量)SampleClass 类的一个实例,普通成员变量SampleClass 类的2个实例(在程序中的顺序不一样)以及一个静态代码块,其中静态代码块中如果静态成员变量sam不为空,则改变sam的引用.main()方法中创建了2个主…

    1.类之间的关系:(6种) 关系 表示 图示 解释 表明的结构和语义 泛化关系 带空心箭头的直线 A继承自B(B指代非抽象类) 继承结构 实现关系 带空心箭头的虚线 小汽车继承车(B指代抽象类) 继承结构 聚合关系 带空心菱形箭头的直线 表示A 聚合到 B 上,或者说 B 由 A 组成. 表示整体由部分构成的语义.(不是强依赖:整体不存在了,部分仍然存在) 组合关系 带实心菱形箭头直线 表示 A 组成 B,或者 B 由 A 组成: 表示整体由部分构成的语义:(强依赖:整体不存在了,则部分也不存在…

    做Java开发的,现在普遍都用上idea了.可以说,idea是当之无愧的Java开发神器.如果,你现在还没用idea,那肯定是你还没有感受过它的强大. 好了,话不多说,今天的主题主要是教大家怎么通过idea快速的查看一个类的类图关系,即一个类继承了哪些类,实现了哪些接口,以及接口有哪些子接口和实现类. 一.类关系 以一个阻塞队列LinkedBlockingQueue为例: 1)通过 Ctrl+Shift+N 找到这个类. 2)进到类里,在类名上面右键单击,选择 Diagrams -> Show…

    原创文章,转载请注明出处. 工欲善其事,必先利其器.阅读大型C++工程项目,如果有一些自动化的分析工具支持,学习的效率将大大提升.在前文中介绍了Source Insight在Linux下的安装方法,本文将介绍C++中继承关系的自动化生成方法. 经过调研,可用的自动化生成工具有微软的Visual Studio,IMB的Rational Rose(UML自动化工具),以及Doxygen.VS运行在Windows下,不大习惯使用,Rational Rose在12年前接触过,笨重无比,最后决定尝试Dox…

    1.restful规范 resfful规范的概念最重要: 是一套规范,规则,用于程序之间进行数据交换的约定. 他规定了一些协议,对我们感受最直接的就是,以前写增删改查的时候需要些四个视图寒素,restful规范写一个接口,根据http协议的请求方式分为不同的操作,比如post,get,put,patch,delete. 除此之外restful规范还规定了: 1.建议用https协议代替http协议 2.在url中要体现pai,添加api标识(体现出我写的是api) http://www.baid…

    Jackson是Spring Boot(SpringBoot)默认的JSON数据处理框架,但是其并不依赖于任何的Spring 库.有的小伙伴以为Jackson只能在Spring框架内使用,其实不是的,没有这种限制.它提供了很多的JSON数据处理方法.注解,也包括流式API.树模型.数据绑定,以及复杂数据类型转换等功能.它虽然简单易用,但绝对不是小玩具,更多的内容我会写成一个系列,5-10篇文章,请您继续关注我.

    场景:CCScene,继承自CCNode,几乎完全等于CCNode类 CCNode继承自CCObject,CCObject是真正意义上的父类,CCObject又继承自CCCopying类,CCCopying的只是定义接口,完全虚基类 CCObject主要定义了两方面的内容: 1.是有内存管理有关的东西,如引用计数,内存托管对象 2.与回调函数有关的东西,如定时器回调,菜单回调,等等 CCLayer继承自CCNode,CCSprite也继承自CCNode,因此可以认为CCNode是cocos中最重…

    1.CI_DB_mysql_driver 继承 CI_DB,  CI_DB这个类是不存在的,每次调用文件中~/CodeIgniter_2.1.3/system/database/DB.php函数&DB来初始化database的时候, 根据用户是否开启active_record,生成继承CI_DB_active_record或CI_DB_driver类的CI_DB类, 2.CI_DB_active_record类继承CI_DB_driver类 require_once(BASEPATH.'data…

    在实际开发中,会定义一些公共字段,而这些公共字段,一般都是在进行操作的时候由程序自动将默认值插入.而公共的字段一般会被封装到一个基础的实体类中,同时实体类中会实现相应的getter setter 方法(注:如果使用了Lombok 插件,就没有getter setter方法,相关注解请自行了解),同时,会用到相关注解.在下文中会一一讲到. 本文的技术选型为: springboot 2.2.2 + mybatis-plus 3, maven构建项目 相关依赖:

    作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! 在这里列举一些我使用Python时积累的小技巧.这些技巧是我在使用Python过程中经常使用的.之前很零碎的记在笔记本中,现在整理出来,和大家分享,也作为Python快速教程的一个补充. import模块 在Python经常使用import声明,以使用其他模块(也就是其它.py文件)中定义的对象. 1) 使用__name__ 当我们编写Python库模块的时候,我们往往运行一些测…

    分享两个资源,对于系统了解Qt框架的整体脉络很有帮助. Qt4类关系图+Qt5类关系图,PDF+JPG格式 [下载] Qt5类关系图(基于Qt5.1版),JPG格式[下载]…

    尝试着仔细阅读thinking in java 看到一篇很好的文章http://blog.csdn.net/u011080472/article/details/51330114…

    如果定义了 throw() 表示函数不抛出异常,这时候如果还是抛出,会导致运行时错误. #include #include #include using namespace std; void func() throw() { ; throw x; } int main() { std::cout << "Hello, World!" << std::endl; t…

    idea中,我当前设置的是eclipse的快捷键(从eclipse转过来的) 一般情况下,查看类的子类Ctrl+T 如何以树的形式查看完整继承关系,快捷键:F4 效果如下: 尤其从根节点查看的时候,完整的继承关系展现出来了 对于复杂的继承关系(代码复用)很有帮助 不过,项目中更多建议通过复合取代多继承(一般也称为扁平结构或立体结构)…

    转载自:http://blog.csdn.net/hyr83960944/article/details/38098091 查看类的继承关系的快捷键F4,在Android Studio常用快捷键这篇文章中,有写了.今天主要是讲一些关于这个快捷键出来的界面的一些配置,这块功能相对偏冷一些,可能很多人都会用不到.但是关于这些配置,android studio中很多都是类似的. 废话不多说,直接上图,如下图,我选中Activity,然后按F4,右边会出现一个和Activity有继承关系的图. 1.先简…

    查看类的继承关系的快捷键F4.在Android Studio经常使用快捷键这篇文章中.有写了.今天主要是讲一些关于这个快捷键出来的界面的一些配置.这块功能相对偏冷一些,可能非常多人都会用不到.可是关于这些配置,android studio中非常多都是类似的. 废话不多说,直接上图.例如以下图,我选中Activity,然后按F4.右边会出现一个和Activity有继承关系的图. 1.先简要分析下图中几个元素: 注:这边说第几个图标是从左到右的顺序来数的 第一个图标:显示全部的继承关系.包含父类,子…

    IntelliJ IDEA 中如何查看一个类的所有继承关系(当前类的所有继承关系图) .embody{ padding:10px 10px 10px; margin:0 -20px; border-bottom:solid 1px #ededed; } .embody_b{ margin:0 ; padding:10px 0; } .embody .embody_t,.embody .embody_c{ display: inline-block; margin-right:10px; } .e…

    Pycharm 查看一个类的继承关系图 在我们开发过程中: 无论是使用的开发框架自带的类, 还是我们自定义的类都特别多; 并且类之间单继承和多继承频繁使用, 这个继承,不仅仅是一级的继承关系,包括好几层的继承.父类的父类的父类. 直到最后->很难清楚一个类的实现关系, 迷失类的作用. 这里我们可以通过查看类的继承关系, 明白类的作用 查看DRF框架的APIView类的继承关系 下图就是我们查找的继承关系 查看DRF框架的GenericAPIView类所在.py模块的所有类继承关系 1.通过Ctr…

    在 IntelliJ IDEA 中这个查看一个类也就是当前类的所有继承关系,包括实现的所有的接口和继承的类, 这个继承,不仅仅是一级的继承关系,包括好几层的继承.父类的父类的父类.直到最后.可以很清楚明了的了解一个类的实现关系. diagram 英[ˈdaɪəgræm] 美[ˈdaɪəˌɡræm]n. 图表; 示意图; 图解; [数] 线图;vt. 图解; 用图表示; 下面看这个编辑器怎么以图解的形式,查看这种继承关系. (上面的是查看的Java源码的类的所有继承关系,最下面的这个是在查看spr…

    前言学习Unity开发引擎的初学者会接触大量的脚本类,而这些类之间的关系往往容易被忽略.本文对Unity引擎开发中的一些常用类及其关系进行了简单的归纳总结. 博文首发地址:http://tieba.baidu.com/p/3611960338 Unity常用脚本类继承关系图 对Unity开发稍有了解的朋友都知道,在Unity开发框架中有4个基本层次:工程(应用程序).场景.游戏对象和组件.在脚本中,整个应用程序和场景由Application类控制:而游戏对象和组件类均继承于Object类.在Ob…

    继承: 继承是指类与类之间的关系,是一种“什么”是“什么”的关系. 继承的功能之一就是用来解决代码重用问题 继承是一种创建新类的方式,在Python中,新建的类可以继承一个或多个父类,父类又可以称为基类或者超类,新建的类称为派生类或者子类 如下代码所示: class ParentClass1: pass class ParentClass2: pass class SubClass1(ParentClass1): # SubClass1 是 ParentClass1的子类,ParentClass…

    展开全文
  • Java之间的继承关系

    千次阅读 2020-08-21 16:23:07
    对于面向对象的程序设计语言来说,毫无疑问是其最重要的基础。抽象、封装、继承、多态这四大特性都离不开,只有存在,才能体现面向对象编程的... Java文件是以.java为后缀的代码文件,每个文件最.

    对于面向对象的程序设计语言来说,类毫无疑问是其最重要的基础。抽象、封装、继承、多态这四大特性都离不开类,只有存在类,才能体现面向对象编程的特点,今天我们就来了解一些类与继承的相关知识。首先,我们讲述一下与类的初始化相关的东西,然后再从几个方面阐述继承这一大特性。以下是本文的目录大纲:

      一.你了解类吗?

      二.你了解继承吗?

      三.常见的面试笔试题

      若有不正之处,请多多谅解并欢迎批评指正。

     

    一.你了解类吗?

      在Java中,类文件是以.java为后缀的代码文件,在每个类文件中最多只允许出现一个public类,当有public类的时候,类文件的名称必须和public类的名称相同,若不存在public,则类文件的名称可以为任意的名称(当然以数字开头的名称是不允许的)。

      在类内部,对于成员变量,如果在定义的时候没有进行显示的赋值初始化,则Java会保证类的每个成员变量都得到恰当的初始化:

      1)对于  char、short、byte、int、long、float、double等基本数据类型的变量来说会默认初始化为0(boolean变量默认会被初始化为false);

      2)对于引用类型的变量,会默认初始化为null。

      如果没有显示地定义构造器,则编译器会自动创建一个无参构造器,但是要记住一点,如果显示地定义了构造器,编译器就不会自动添加构造器。注意,所有的构造器默认为static的。

      下面我们着重讲解一下 初始化 顺序:

      当程序执行时,需要生成某个类的对象,Java执行引擎会先检查是否加载了这个类,如果没有加载,则先执行类的加载再生成对象,如果已经加载,则直接生成对象。

      在类的加载过程中,类的static成员变量会被初始化,另外,如果类中有static语句块,则会执行static语句块。static成员变量和static语句块的执行顺序同代码中的顺序一致。记住,在Java中,类是按需加载,只有当需要用到这个类的时候,才会加载这个类,并且只会加载一次。看下面这个例子就明白了:

    public class Test {
        public static void main(String[] args) throws ClassNotFoundException {
             
            Bread bread1 = new Bread();
            Bread bread2 = new Bread();
        }
    }
     
     
    class Bread {
        static{
            System.out.println("Bread is loaded");
        }
        public Bread() {
            System.out.println("bread");
        }
    }

      运行这段代码就会发现"Bread is loaded"只会被打印一次。

      在生成对象的过程中,会先初始化对象的成员变量,然后再执行构造器。也就是说类中的变量会在任何方法(包括构造器)调用之前得到初始化,即使变量散步于方法定义之间。

    public class Test {
        public static void main(String[] args)  {
            new Meal();
        }
    }
     
     
    class Meal {
         
        public Meal() {
            System.out.println("meal");
        }
         
        Bread bread = new Bread();
    }
     
    class Bread {
         
        public Bread() {
            System.out.println("bread");
        }
    }    Bread bread = new Bread();} class Bread {         public Bread() {        System.out.println("bread");    }}

      输出结果为:

    bread
    meal

     

    二.你了解继承吗?

      继承是所有OOP语言不可缺少的部分,在java中使用extends关键字来表示继承关系。当创建一个类时,总是在继承,如果没有明确指出要继承的类,就总是隐式地从根类Object进行继承。比如下面这段代码:

    class Person {
        public Person() {
             
        }
    }
     
    class Man extends Person {
        public Man() {
             
        }
    }

      类Man继承于Person类,这样一来的话,Person类称为父类(基类),Man类称为子类(导出类)。如果两个类存在继承关系,则子类会自动继承父类的方法和变量,在子类中可以调用父类的方法和变量。在java中,只允许单继承,也就是说 一个类最多只能显示地继承于一个父类。但是一个类却可以被多个类继承,也就是说一个类可以拥有多个子类。

      1.子类继承父类的成员变量

      当子类继承了某个类之后,便可以使用父类中的成员变量,但是并不是完全继承父类的所有成员变量。具体的原则如下:

      1)能够继承父类的public和protected成员变量;不能够继承父类的private成员变量;

      2)对于父类的包访问权限成员变量,如果子类和父类在同一个包下,则子类能够继承;否则,子类不能够继承;

      3)对于子类可以继承的父类成员变量,如果在子类中出现了同名称的成员变量,则会发生隐藏现象,即子类的成员变量会屏蔽掉父类的同名成员变量。如果要在子类中访问父类中同名成员变量,需要使用super关键字来进行引用。

      2.子类继承父类的方法

      同样地,子类也并不是完全继承父类的所有方法。

      1)能够继承父类的public和protected成员方法;不能够继承父类的private成员方法;

      2)对于父类的包访问权限成员方法,如果子类和父类在同一个包下,则子类能够继承;否则,子类不能够继承;

      3)对于子类可以继承的父类成员方法,如果在子类中出现了同名称的成员方法,则称为覆盖,即子类的成员方法会覆盖掉父类的同名成员方法。如果要在子类中访问父类中同名成员方法,需要使用super关键字来进行引用。

      注意:隐藏和覆盖是不同的。隐藏是针对成员变量和静态方法的,而覆盖是针对普通方法的。(后面会讲到)

      3.构造器

      子类是不能够继承父类的构造器,但是要注意的是,如果父类的构造器都是带有参数的,则必须在子类的构造器中显示地通过super关键字调用父类的构造器并配以适当的参数列表。如果父类有无参构造器,则在子类的构造器中用super关键字调用父类构造器不是必须的,如果没有使用super关键字,系统会自动调用父类的无参构造器。看下面这个例子就清楚了:

    class Shape {
         
        protected String name;
         
        public Shape(){
            name = "shape";
        }
         
        public Shape(String name) {
            this.name = name;
        }
    }
     
    class Circle extends Shape {
         
        private double radius;
         
        public Circle() {
            radius = 0;
        }
         
        public Circle(double radius) {
            this.radius = radius;
        }
         
        public Circle(double radius,String name) {
            this.radius = radius;
            this.name = name;
        }
    }

      这样的代码是没有问题的,如果把父类的无参构造器去掉,则下面的代码必然会出错:

      改成下面这样就行了:

      4.super

      super主要有两种用法:

      1)super.成员变量/super.成员方法;

      2)super(parameter1,parameter2....)

      第一种用法主要用来在子类中调用父类的同名成员变量或者方法;第二种主要用在子类的构造器中显示地调用父类的构造器,要注意的是,如果是用在子类构造器中,则必须是子类构造器的第一个语句。

     

    三.常见的面试笔试题

    1.下面这段代码的输出结果是什么?

    public class Test {
        public static void main(String[] args)  {
            new Circle();
        }
    }
     
    class Draw {
         
        public Draw(String type) {
            System.out.println(type+" draw constructor");
        }
    }
     
    class Shape {
        private Draw draw = new Draw("shape");
         
        public Shape(){
            System.out.println("shape constructor");
        }
    }
     
    class Circle extends Shape {
        private Draw draw = new Draw("circle");
        public Circle() {
            System.out.println("circle constructor");
        }
    }

     

    shape draw constructor
    shape constructor
    circle draw constructor
    circle constructor

      这道题目主要考察的是类继承时构造器的调用顺序和初始化顺序。要记住一点:父类的构造器调用以及初始化过程一定在子类的前面。由于Circle类的父类是Shape类,所以Shape类先进行初始化,然后再执行Shape类的构造器。接着才是对子类Circle进行初始化,最后执行Circle的构造器。

    2.下面这段代码的输出结果是什么?

    public class Test {
        public static void main(String[] args)  {
            Shape shape = new Circle();
            System.out.println(shape.name);
            shape.printType();
            shape.printName();
        }
    }
     
    class Shape {
        public String name = "shape";
         
        public Shape(){
            System.out.println("shape constructor");
        }
         
        public void printType() {
            System.out.println("this is shape");
        }
         
        public static void printName() {
            System.out.println("shape");
        }
    }
     
    class Circle extends Shape {
        public String name = "circle";
         
        public Circle() {
            System.out.println("circle constructor");
        }
         
        public void printType() {
            System.out.println("this is circle");
        }
         
        public static void printName() {
            System.out.println("circle");
        }
    }

     

    shape constructor
    circle constructor
    shape
    this is circle
    shape

      这道题主要考察了隐藏和覆盖的区别(当然也和多态相关,在后续博文中会继续讲到)。

      覆盖只针对非静态方法(终态方法不能被继承,所以就存在覆盖一说了),而隐藏是针对成员变量和静态方法的。这2者之间的区别是:覆盖受RTTI(Runtime type  identification)约束的,而隐藏却不受该约束。也就是说只有覆盖方法才会进行动态绑定,而隐藏是不会发生动态绑定的。在Java中,除了static方法和final方法,其他所有的方法都是动态绑定。因此,就会出现上面的输出结果。

     

    展开全文
  • 在继承关系中,已有的、设计好的类称为父类、基类或超类,自定义的新类称为子类或派生。派生可以继承父类的公有成员,但是不能继承其私有成员。继承的语法为 class 类名(继承类名)。 实例:使用的继承性...
  • java抽象 继承

    千次阅读 2021-03-08 06:02:32
    抽象类中可以有已经实现了的方法,也可以有abstract修饰的方法(抽象方法),因为存在抽象方法,所以该必须是抽象。但是接口要求只能包含抽象方法,抽象方法是指没有实现的方法。所以就不能像抽象那么无赖了,...

    关于

    java抽象类 继承的搜索结果

    回答

    抽象类和接口的区别:默认的方法实现 抽象类可以有默认的方法实现完全是抽象的。接口根本不存在方法的实现。抽象类中可以有已经实现了的方法,也可以有被abstract修饰的方法(抽象方法),因为存在抽象方法,所以该类必须是抽象类。但是接口要求只能包含抽象方法,抽象方法是指没有实现的方法。所以就不能像抽象类那么无赖了,接口就根本不能存在方法的实现。实现 抽象类使用extends关键字来继承抽象类。如果子类不是抽象类的话,它需要提供抽象类中所有声明的方法的实现。子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现。抽象类虽然不能实例化来使用,但是可以被继承,让子类来具体实现父类的所有抽象方法。有点老子没完成的梦想交给儿子来完成,但是如果子类将抽象方法没有全部实现,就必须把自己也修饰成抽象类,交于继承它的子类来完成实现。就相当于,儿子能力不够也没完成老爹的梦想,现在儿子等着再生儿子(被继承),然后让孙子去完成。以此类推,知道没有抽象函数。接口的实现,通过implements关键字。实现该接口的类,必须把接口中的所有方法给实现。不能再推给下一代。和抽象类相比,抽象类是将梦想传给家族,一代一代去完成。那么接口就是掌门人找大师兄来完成帮派的鸿星伟业,这时候就只有一次希望,要么有能力就实现,没能力就不要接。抽象类可以有构造器,而接口不能有构造器这个原因很简单,我们回到双方的定义上来,抽象类再怎么流氓无赖也好,终究是属于类,就天生享有类的所有特性(但是不能实例化),当然包括类的构造方法,也就是构造器。但是接口是所有抽象方法的集合,注意,是集合,不是类。当然没有构造方法一说,更别提什么构造器了。抽象方法可以有public、protected和default这些修饰符 接口方法默认修饰符是public。你不可以使用其它修饰符。抽象类的目的就是被继承,抽象方法就是为了被重写,所以肯定不能用private修饰符,肯定是可以用public的。但是protected和default也是可以的。接口就有且只有一个public修饰。(是不是感觉抽象类像小儿子各种耍无赖,接口就像私生子,说什么只能是什么)抽象类在java语言中所表示的是一种继承关系,一个子类只能存在一个父类,但是可以存在多个接口。java在类的继承上并没有多继承。抽象类属于类,所以可以被继承。但子类只能继承一个父类。java为了实现多继承,使用了接口。一个类可以实现多个接口。继承就好比生了孩子,只能有一个爹,但是这个孩子可以学语文,学数学,学英语等等很多东西,而语文、数学、英语就相当于接口。总的来说,因为java中抽象类只有单继承,接口就可以实现多继承。抽象方法比接口速度要快接口是稍微有点慢的,因为它需要时间去寻找在类中实现的方法。记住抽象方法是小儿子,从小吃的好所以跑的快,接口是私生子,从小日子苦,营养不良。如果你往抽象类中添加新的方法,你可以给它提供默认的实现。因此你不需要改变你现在的代码。 如果你往接口中添加方法,那么你必须改变实现该接口的类。抽象类可以有一些非抽象方法的存在,这些方法被称为默认实现。如果添加一个默认实现方法(不能是抽象方法),就不需要在子类中去实现,所以继承这个抽象类的子类无须改动。但是,接口中只能添加抽象方法,当你添加了抽象方法,实现该接口的类就必须实现这个新添加的方法。因为,定义中说的很清楚,接口的实现必须实现所有的方法。所有,当然包括新添加的方法。

    hiekay

    2019-12-02 01:39:31

    0 浏览量

    回答数 0

    问题

    java怎么继承抽象类

    java怎么继承抽象类...

    云计算小粉

    2019-12-01 19:57:04

    414 浏览量

    回答数 3

    回答

    1、Java为了简化设计和开发,抛弃了多重继承类的理念,因为多重继承类型带来很多潜在问题,比如重名方法和变量问题。2、Java提供了接口的多重继承支持3、接口只是 包含声明,属于部分约束。4、abstract class抽象类,可以包含具体实现,也可以包含没有实现代码的抽象方法,允许后代实现,这个比接口更丰富一些。某些情况下父类可以提前实现一些具体的代码,也可以不实现留着子类实现。更加灵活

    徐雷frank

    2019-12-02 01:49:22

    0 浏览量

    回答数 0

    回答

    toString().你确定你没开玩笑?感谢提醒不全部实现还能叫接口么。。。你自己去写得试试,编译确实可以通过,我在想是不是这样接口更灵活一些只有接口的抽象实现类不用全实现,普通接口的方法都需要实现的总结的好

    引用来自“PythonLee”的评论toString().你确定你没开玩笑?toString确实默认了,现在问题来了,Shape2里面也有抽象的toString,而他的子类应该也会默认实现toString,可是编译器为什么提示我错误而且继承接口的抽象实现类的子类还必须实现抽象父类中没有实现的方法。。。。

    LZ好深意:要知道Circle继承了Object,Object实现了toString().

    至于下面的抽象类Rhomboid是因为java是单继承,可没有直接父类实现toString().

    abstractclassShape2{   publicabstractStringtoString();}classRTmpextendsShape2{   @Override   publicStringtoString(){      returnnull;   }}classRhomboidextendsRTmp{   //这里不报错}我只能说楼主的根据这个例子做出猜测,实在是没经过严格验证的.你为什么不试试其他名称的方法体呢?服了

    引用来自“Cong_Cong”的评论

    LZ好深意:要知道Circle继承了Object,Object实现了toString().

    至于下面的抽象类Rhomboid是因为java是单继承,可没有直接父类实现toString().

    abstractclassShape2{   publicabstractStringtoString();}classRTmpextendsShape2{   @Override   publicStringtoString(){      returnnull;   }}classRhomboidextendsRTmp{   //这里不报错}这种问题...哭了很凑巧,LZ写的例子种,toString方法刚好是java.lang.Object中的,而这家伙是所有类的顶级父类,你换个名字就知道问题在哪了

    爱吃鱼的程序员

    2020-06-14 17:04:49

    0 浏览量

    回答数 0

    回答

    多重继承有很多概念上的麻烦问题,典型的比如菱形问题,要避免这种问题,最简单的办法就是不使用多重继承。在java中使用组合的方式来代替多重继承。抽象类是为了存放公用的函数和变量,接口只有函数定义而没有实现,抽象类则可以有变量,有函数实现。

    yu_hc200

    2019-12-02 01:49:23

    0 浏览量

    回答数 0

    回答

    面向对象的特征主要有以下几个方面:

    抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么。

    封装

    封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法,如果属性不想被外界访问,我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法,那么这个类也没有什么意义了。

    继承

    继承是使用已存在的类的定义作为基础建立新类的技术,新类的定义可以增加新的数据或新的功能,也可以用父类的功能,但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码。

    关于继承如下 3 点请记住:

    子类拥有父类非 private 的属性和方法。

    子类可以拥有自己属性和方法,即子类可以对父类进行扩展。

    子类可以用自己的方式实现父类的方法。(以后介绍)。

    多态

    所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量到底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。

    在Java中有两种形式可以实现多态:继承(多个子类对同一方法的重写)和接口(实现接口并覆盖接口中同一方法)。

    其中Java 面向对象编程三大特性:封装 继承 多态

    封装:隐藏对象的属性和实现细节,仅对外提供公共访问方式,将变化隔离,便于使用,提高复用性和安全性。

    继承:继承是使用已存在的类的定义作为基础建立新类的技术,新类的定义可以增加新的数据或新的功能,也可以用父类的功能,但不能选择性地继承父类。通过使用继承可以提高代码复用性。继承是多态的前提。

    关于继承如下 3 点请记住:

    子类拥有父类非 private 的属性和方法。

    子类可以拥有自己属性和方法,即子类可以对父类进行扩展。

    子类可以用自己的方式实现父类的方法。

    多态性:父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。

    在Java中有两种形式可以实现多态:继承(多个子类对同一方法的重写)和接口(实现接口并覆盖接口中同一方法)。

    方法重载(overload)实现的是编译时的多态性(也称为前绑定),而方法重写(override)实现的是运行时的多态性(也称为后绑定)。

    一个引用变量到底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。运行时的多态是面向对象最精髓的东西,要实现多态需要做两件事:

    方法重写(子类继承父类并重写父类中已有的或抽象的方法); 对象造型(用父类型引用子类型对象,这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为)。

    问问小秘

    2020-03-27 17:36:33

    0 浏览量

    回答数 0

    回答

    在Java中,OOP是一种与以下概念相关的编程样式: 继承:继承是一个类在其中获取另一类的属性的过程。 封装:Java中的封装是一种将数据和代码打包为单个单元的机制。 抽象:抽象是向用户隐藏实现细节并仅向用户提供功能的方法。 多态:多态是变量,函数或对象采取多种形式的能力。

    YDYK

    2020-04-23 19:37:18

    0 浏览量

    回答数 0

    回答

    接口是JAVA为了实现类似C++里面的多继承的一种妥协方案。比如,有接口A,然后B、C、D都实现了接口A。就类似于B、C、D都继承了抽象类A,都可以调用A中定义过的方法。比如需要对B、C、D的对象做类似的操作,就可以写出类似的代码。甚至可以把类似的代码抽象封装成函数,类等等。传递参数的时候,可以把类型写成A,那么B、C、D类的对象就都可以传递进来。各种。总之,接口不是为了规范产生的,它的好处也不是什么规范,而是尽量抽象,减少重复的代码。(说的装逼一点,叫更加符合面向对象的思想blabla……)(另外,不规范都是程序员的问题,接口并不能拯救世界。)实现类似的效果,只有两种方案:方案1:B、C、D都继承于A。方案2:B、C、D都实现A的接口。但是很明显,JAVA不支持多继承……于是只能用方案2,实现多个接口……所以你懂的,接口是很必要的。但是用了函数和类,可以为你减少重复的代码啊。你在考虑用继承或者接口的前提,一定是要“ B,C,D具有相同或者类似的行为,可以整合到一起 ”。接口可以让你的B、C、D类的对象都可以当做同一个类型(A接口)的参数到处传递,做相同的操作。(也就是说,比如B继承Y,又实现了Z,那么B既可以当做Y类型的参数,又可以当做Z类型的参数)

    蛮大人123

    2019-12-02 01:51:10

    0 浏览量

    回答数 0

    问题

    java中到底为什么要用到抽象类?

    比如有个类A,把它设置成abstract是为了不让它实例化,只能表示一个抽象的或者不具体的无法实例化的概念,但是就算不在这个A的前面加abstract照样可以实现很多类的继承,那我真的不太理解设置抽象类的意义到底在哪里,请各位不吝赐教!...

    蛮大人123

    2019-12-01 20:24:53

    1279 浏览量

    回答数 1

    回答

    Java中内部类主要分为成员内部类、局部内部类(嵌套在方法和作用域内)、匿名内部类(没构造方法)、静态内部类(static修饰的类,不能使用任何外围类的非static成员变量和方法, 不依赖外围类)

    使用内部类最吸引人的原因是:每个内部类都能独立地继承一个(接口的)实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响。

    因为Java不支持多继承,支持实现多个接口。但有时候会存在一些使用接口很难解决的问题,这个时候我们可以利用内部类提供的、可以继承多个具体的或者抽象的类的能力来解决这些程序设计问题。可以这样说,接口只是解决了部分问题,而内部类使得多重继承的解决方案变得更加完整。

    游客bnlxddh3fwntw

    2020-04-10 13:20:38

    0 浏览量

    回答数 0

    回答

    "枚举类可以实现一个或多个接口,使用enum定义的枚举类默认继承了java.lang.Enum类,而不是继承Object类。其中java.lang.Enum类实现了java.lang.Serializable和java.lang. Comparable两个接口。 使用enum定义、非抽象的枚举类默认会使用final修饰,因此枚举类不能派生子类。 枚举类的构造器只能使用private访问控制符,如果省略了构造器的访问控制符,则默认使用private修饰;如果强制指定访问控制符,则只能指定private修饰符。 枚举类的所有实例必须在枚举类的第一行显式列出,否则这个枚举类永远都不能产生实例。列出这些实例时,系统会自动添加public static final修饰,无须程序员显式添加。"

    星尘linger

    2020-04-07 13:24:42

    0 浏览量

    回答数 0

    回答

    enum和class、interface的地位一样

    使用enum定义的枚举类默认继承了java.lang.Enum,而不是继承Object类。枚举类可以实现一个或多个接口。

    枚举类的所有实例都必须放在第一行展示,不需使用new 关键字,不需显式调用构造器。自动添加public static final修饰。

    使用enum定义、非抽象的枚举类默认使用final修饰,不可以被继承。

    枚举类的构造器只能是私有的。

    游客lz7tjhznmiyda

    2019-12-02 01:03:52

    0 浏览量

    回答数 0

    回答

    面向对象有三个特征:封装、继承、多态。

    其中继承和实现都体现了传递性。而且明确定义如下:

    继承:如果多个类的某个部分的功能相同,那么可以抽象出一个类出来,把他们的相同部分都放到父类里,让他们都继承这个类。

    实现:如果多个类处理的目标是一样的,但是处理的方法方式不同,那么就定义一个接口,也就是一个标准,让他们的实现这个接口,各自实现自己具体的处理方法来处理那个目标

    所以,继承的根本原因是因为要复用,而实现的根本原因是需要定义一个标准。

    在Java中,继承使用extends关键字实现,而实现通过implements关键字。

    Java中支持一个类同时实现多个借口,但是不支持同时继承多个类。

    简单点说,就是同样是一台汽车,既可以是电动车,也可以是汽油车,也可以是油电混合的,只要实现不同的标准就行了,但是一台车只能属于一个品牌,一个厂商。

    class Car extends Benz implements GasolineCar, ElectroCar{

    }

    在接口中只能定义全局常量(static final)和无实现的方法(Java 8以后可以有defult方法);而在继承中可以定义属性方法,变量,常量等。

    montos

    2020-06-01 15:50:19

    0 浏览量

    回答数 0

    问题

    JAVA中继承那些事情

    访问权限

    Java 中有三个访问权限修饰符:private、protected 以及 public,如果不加访问修饰符,表示包级可见。

    可以对类或类中的成员(字段和方法࿰...

    montos

    2020-05-18 21:16:07

    4 浏览量

    回答数 1

    问题

    Java基础测试题2 | 基础不能都忘掉

    一、填空题

    1、Java中通过____关键字实现继承。

    2、一个类只能继承________个父类,但能实现____个接口。

    3、当子类中定义的方法与父类方法同名且参数类型及个数、返回值类型相同时,称子类方法...

    游客pklijor6gytpx

    2019-12-01 22:04:25

    575 浏览量

    回答数 0

    问题

    (JAVA)一个类没有直接实现接口,为什么可以这样为父接口实例化呢??报错

    @tcxu 你好,想跟你请教个问题:

    package jiu;

    interface A { // 定义一个接口     String INFO = "Hello World ."...

    爱吃鱼的程序员

    2020-06-06 09:57:24

    0 浏览量

    回答数 1

    问题

    【精品问答】100+ Java和JavaSE常用技术点

    为大家整理了 Java和JavaSE常用技术点,可以应对面试。供大家学习交流参考:

    运行时实现多态需要的三个必要条件?

    访问修饰符public、private、protected、以及不写...

    游客pklijor6gytpx

    2020-03-29 23:26:40

    1148 浏览量

    回答数 1

    回答

    首先我觉得像spring这样的庞大的开源框架的设计理念,并不会完全遵守,一些常用的准则,肯定有自己独到之处,java中不支持继承多个抽象类,却支持接口的继承和扩展,这样,对于一个接口有若干继承接口,在java中就是很正常的事情,就像spring中beanfactory有很多的继承接口,这些接口大多数面向不同的环境,不同的使用场景,就相当于把spring核心容器接口提供的功能,通过定义不同接口的方式来做了汇总归类,降低了使用接口的复杂度,我所知道的spring中有相当部分的属于接口方法,但是却不适合向普通用户公开,这样,通过一个子接口就隐藏了这部分接口代码,同时又符合面向接口的设计。

    长安归故里.

    2020-01-07 21:11:14

    0 浏览量

    回答数 0

    回答

    Java集合容器主要有以下几类:1,内置容器:数组2,list容器:Vetor,Stack,ArrayList,LinkedList,CopyOnWriteArrayList(1.5),AttributeList(1.5),RoleList(1.5),RoleUnresolvedList(1.5),ConcurrentLinkedQueue(1.5),ArrayBlockingQueue(1.5),LinkedBlockingQueue(1.5),PriorityQueue(1.5),PriorityBlockingQueue(1.5),SynchronousQueue(1.5)3,set容器:HashSet(1.2),LinkedHashSet(1.4),TreeSet(1.2),CopyOnWriteArraySet(1.5),EnumSet(1.5),JobStateReasons。4,map容器:Hashtable,HashMap(1.2),TreeMap(1.2),LinkedHashMap(1.4),WeakHashMap(1.2),IdentityHashMap(1.4),ConcurrentMap(1.5),concurrentHashMap(1.5)。注意:Vector,Stack,Hashtable是Java1.2前的容器。虽然在Java2之前,Java是没有完整的集合框架的。它只有一些简单的可以自扩展的容器类。但是在Java2后他们还是被融入到了集合框架的,不过只是历史遗留而已。它们和1.2前应该还是有些变化的,虽然本质没什么变化。Set接口继承于Collection,但不允许重复,使用自己内部的一个排列机制。List接口继承Collection,允许重复,以元素安插的次序来放置元素,不会重新排列。Map接口是一组成对的键-值对象,即所持有的是key-value pairs。Map中不能有重复的key。拥有自己的内部排列机制。一、Java1.2之前的容器类库其实在Java2之前,Java是没有完整的集合框架的。它只有一些简单的可以自扩展的容器类,比如Vector,Stack,Hashtable等。Java1容器类库设计的一个重大失误是竟然没有对容器进行排序的工具。比如你想让Vector容器中的对象按字典顺序进行排序,你就要自己实现。1.1、Vectorjava.util.Vector中包含的元素可以通过一个整型的索引值取得,它的大小可以在添加或移除元素时自动增加或缩小。Vector的操作很简单,通过addElement()加入一个对象,用elementAt()取出它,还可以查询当前所保存的对象的个数size();另外还有一个Enumeration类提供了连续操作Vector中元素的方法,这可以通过Vector中的elements()方法来获取一个Enumeration类的对象,可以用一个While循环来遍历其中的元素。用hasMoreElements()检查其中是否还有更多的元素。用nextElement()获得下一个元素。Enumeration的用意在于使你能完全不用理会你要遍历的容器的基础结构,只关注你的遍历方法,这也就使得遍历方法的重用成为可能。由于这种思想的强大功能,所以在Java2中被保留下来,不过具体实现,方法名和内部算法都改变了,这就是Java2中的Iterator以及ListIterator类。然而Enumeration的功能却十分有限,比如只能朝一个方向进行,只能读取而不能更改等。更多内容请参考《Vector》1.2、Stackjava.util.Stack最常用的操作便是压入和弹出,最后压入的元素最先被弹出。它遵循后进先出(LIFO)原则。在Java中Stack的的用法也很简单,有push()压入一个元素,用pop()弹出一个元素。更多内容请参考《Stack容器》1.3、HashtableHashtable与Java2中的Map类似,可以看成一种关联或映射数组,可以将两个毫无关系的对象相关联。它的基本目标是实现两个对象之间进行关联。更多内容请参考《Hashtable》二、Java2中的容器类库自Java1.2之后Java版本统称为Java2,Java2中的容器类库才可以说是一种真正意义上的集合框架的实现。基本完全重新设计,但是又对Java1中的一些容器类库在新的设计上进行了保留,这主要是为了向下兼容的目的,当用 Java2开发程序时,应尽量避免使用它们,Java2的集合框架已经完全可以满足你的需求。在Java1中容器类库是同步化的,而 Java2中的容器类库都是非同步化,这可能是对执行效率进行考虑的结果。Java2中的集合框架提供了一套设计优良的接口和类,使程序员操作成批的数据或对象元素极为方便。这些接口和类有很多对抽象数据类型操作的API,而这是我们常用的且在数据结构中熟知的。例如Maps,Sets,Lists,Arrays等。并且Java用面向对象的设计对这些数据结构和算法进行了封装,这就极大的减化了程序员编程时的负担。程序员也可以以这个集合框架为基础,定义更高级别的数据抽象,比如栈、队列和线程安全的集合等,从而满足自己的需要。Java2的集合框架,抽其核心,主要有三类:List(包括List,Queue,BlockingQueue)、Set和Map。List和Set继承了Collection,而Map则独成一体。初看上去可能会对Map独成一体感到不解,它为什么不也继承Collection呢?但是这种设计是合理的。一个Map提供了通过Key对Map中存储的Value进行访问,也就是说它操作的都是成对的对象元素,比如put()和get()方法,而这是一个Set或List 所不就具备的。当然在需要时,你可以由keySet()方法或values()方法从一个Map中得到键的Set集或值的Collection集。集合框架中还有两个很实用的公用类:Collections和Arrays。Collections提供了对一个Collection容器进行诸如排序、复制、查找和填充等一些非常有用的方法, Arrays则是对一个数组进行类似的操作。2.1、CollectionCollection接口提供了一组操作成批对象的方法。(它只是个接口)它提供了基本操作如添加、删除。它也支持查询操作如是否为空isEmpty()方法等。为了支持对Collection进行独立操作,Java的集合框架给出了一个Iterator,它使得你可以泛型操作一个Collection,而不需知道这个 Collection的具体实现类型是什么。它的功能与Java1中的Enumeration类似,只是更易掌握和使用,功能也更强大。在建立集合框架时,Sun的开发团队考虑到需要提供一些灵活的接口,用来操作成批的元素,又为了设计的简便,就把那些对集合进行可选操作的方法与基本方法放到了一起。因为一个接口的实现者必须提供对接口中定义的所有方法的实现,这就需要一种途径让调用者知道它正在调用 的可选方法当前不支持。最后开发团队选择使用一种信号,也即抛出一种不支持操作例外(UnsupportedOperationException),如果你在使用一个Collection中遇到一个上述的例外,那就意味着你的操作失败,比如你对一个只读Collection添加一个元素时,你就会得到一个不支持操作例外。在你实现一个集合接口时,你可以很容易的在你不想让用户使用的方法中抛出UnsupportOperationException来告诉使用者这个方法当前没有实现,UnsupportOperationException是RuntimeException的一个扩展。另外Java2的容器类库还有一种Fail fast的机制。比如你正在用一个Iterator遍历一个容器中的对象,这时另外一个线程或进程对那个容器进行了修改,那么再用next()方法时可能会有灾难性的后果,而这是你不愿看到的,这时就会引发一个ConcurrentModificationException例外。这就是 fail-fast。

    51干警网

    2019-12-02 01:42:48

    0 浏览量

    回答数 0

    回答

    你自己也说了,类X没有直接实现接口A和B,但是类X实现的接口D已经继承了接口A和B。

    A a = x; 这一行,并没有发生实例化。实例化的含义是创建对象,这一行并没有创建对象。这一行实际做的是,让引用a指向引用x所指向的对象。对象并没有增加。

    因为类X实现了接口D,而接口D已经继承了接口A和B,所以这一行不会报错。

    任意一个类 M  成功实现了某个接口 N1 或 N2,就可以将 接口 N1,或 接口N2  当成 类 M 的父类看待。进而,子类 M 的对象 m,自然也就是 N1 或 N2 类型的 实例 (或 引用 referene)。这叫向上转型 upcasting。比如,父类 Person 的子类 Student 的对象是 李明, 李明既是学生 Student 类型 (的引用),也是 人 Person 类型 (的引用)。

    在 楼主的案例 里,类 C 要同时实现 接口 A 和 B,但 它不但未能完成要求定义的抽象方法的方法体,而且自身又添加了一个抽象方法。因此,类 C 要冠以 关键词 abstract。

    在 楼主的案例 里,接口 D 同时继承 接口 A 和 B。

    最后,在 楼主的案例 里,类 X 不但成功继承了 类 C, 同时还 实现了接口 D,也就是同时实现了接口 A 和 B。

    这样一来,在 楼主的案例 里,类 X 就可以看作是 接口 A、B、类 C、以及 D 的子类 (subclass/derived_class),类 X 的对象/实体,自然也就可以当做是  接口 A、B、类 C、以及 D 的类型的引用:a、b、c、d ( 这种转变成为 向上转型 upcasting )。用这些引用,自然可以调用相关的方法。

    总之,就楼主的案例而言,虽然 类 class X 没有直接实现接口 interface A 和 interface B ,但是它成功继承了 实现 接口 interface A 和 interface B  的抽象类 abstract C。由此,类 class X 便是其父类 C,以及其父接口   interface A 和 interface B  的子类。于是,类 class X 的 实体/对象 x, 就可以向上转型为 其父类、父接口类型的引用, 即楼主所说的 "为父接口实例化"。

    参考:

    在java 中,什么叫向上转型

    爱吃鱼的程序员

    2020-06-06 09:57:41

    0 浏览量

    回答数 0

    问题

    【精品问答】Java基础测试题 2 答案 | 看你会多少

    一、填空题

    1、Java中通过extends关键字实现继承。

    2、一个类只能继承一个父类,但能实现多个接口。

    3、当子类中定义的方法与父类方法同名且参数类型及个数、返回值类型相同时,称子类方法覆写父类方法&...

    游客pklijor6gytpx

    2019-12-01 22:04:54

    334 浏览量

    回答数 0

    回答

    一、OOP三大基本特性 OOP

    面向对象程序设计(Object Oriented Programming)作为一种新方法,其本质是以建立模型体现出来的抽象思维过程和面向对象的方法。模型是用来反映现实世界中事物特征的。任何一个模型都不可能反映客观事物的一切具体特征,只能对事物特征和变化规律的一种抽象,且在它所涉及的范围内更普遍、更集中、更深刻地描述客体的特征。通过建立模型而达到的抽象是人们对客体认识的深化。 封装

    封装,也就是把客观事物封装成抽象的类,并且类可以把自己的属性和方法只让可信的类操作,对不可信的进行信息隐藏。 继承

    继承是指这样一种能力,它可以使用现有的类的所有功能,并在无需重新编写原来类的情况下对这些功能进行扩展。 多态

    多态指一个类实例的相同方法在不同情形有不同的表现形式。具体来说就是不同实现类对公共接口有不同的实现方式,但这些操作可以通过相同的方式(公共接口)予以调用。 二、OOD七大原则

    面向对象设计(OOD)有七大原则,它们互相补充 开-闭原则

    Open-Close Principle(OCP),即开-闭原则。开,指的是对扩展开放,即要支持方便地扩展;闭,指的是对修改关闭,即要严格限制对已有内容的修改。开-闭原则是最抽象也是最重要的OOD原则。简单工厂模式、工厂方法模式、抽象工厂模式中都提到了如何通过良好的设计遵循开-闭原则。 里氏替换原则

    Liskov Substitution Principle(LSP),即里氏替换原则。该原则规定“子类必须能够替换其父类,否则不应当设计为其子类”。换句话说,父类出现的地方,都应该能由其子类代替。所以,子类只能去扩展基类,而不是隐藏或者覆盖基类。 依赖倒置原则

    Dependence Inversion Principle(DIP),依赖倒置原则。它讲的是“设计和实现要依赖于抽象而非具体”。一方面抽象化更符合人的思维习惯;另一方面,根据里氏替换原则,可以很容易将原来的抽象替换为扩展后的具体,这样可以很好的支持开-闭原则。 接口隔离原则

    Interface Segration Principle(ISP),接口隔离原则,“将大的接口打散成多个小的独立的接口”。由于Java类支持实现多个接口,可以很容易的让类具有多种接口的特征,同时每个类可以选择性地只实现目标接口。 单一职责原则

    Single Responsibility Principle(SRP),单一职责原则。它讲的是,不要存在多于一个导致类变更的原因,是高内聚低耦合的一个体现。 迪米特法则/最少知道原则

    Law of Demeter or Least Knowledge Principle(LoD or LKP),迪米特法则或最少知道原则。它讲的是“一个对象就尽可能少的去了解其它对象”,从而实现松耦合。如果一个类的职责过多,由于多个职责耦合在了一起,任何一个职责的变更都可能引起其它职责的问题,严重影响了代码的可维护性和可重用性。 合成/聚合复用原则

    Composite/Aggregate Reuse Principle(CARP / CRP),合成/聚合复用原则。如果新对象的某些功能在别的已经创建好的对象里面已经实现,那么应当尽量使用别的对象提供的功能,使之成为新对象的一部分,而不要再重新创建。新对象可通过向这些对象的委派达到复用已有功能的效果。简而言之,要尽量使用合成/聚合,而非使用继承。

    景凌凯

    2020-03-19 23:49:30

    0 浏览量

    回答数 0

    回答

    Java提供了一套实现了Collection接口的标准集合类。其中一些是具体类,这些类可以直接拿来使用,而另外一些是抽象类,提供了接口的部分实现。

    标准集合类汇总于下表:

    序号类描述1AbstractCollection 实现了大部分的集合接口。2AbstractList 继承于AbstractCollection 并且实现了大部分List接口。3AbstractSequentialList 继承于 AbstractList ,提供了对数据元素的链式访问而不是随机访问。4LinkedList 该类实现了List接口,允许有null(空)元素。主要用于创建链表数据结构,该类没有同步方法,如果多个线程同时访问一个List,则必须自己实现访问同步,解决方法就是在创建List时候构造一个同步的List。例如:List list=Collections.synchronizedList(newLinkedList(...));LinkedList 查找效率低。5ArrayList 该类也是实现了List的接口,实现了可变大小的数组,随机访问和遍历元素时,提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%,插入删除效率低。6AbstractSet 继承于AbstractCollection 并且实现了大部分Set接口。7HashSet 该类实现了Set接口,不允许出现重复元素,不保证集合中元素的顺序,允许包含值为null的元素,但最多只能一个。8LinkedHashSet 具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。9TreeSet 该类实现了Set接口,可以实现排序等功能。10AbstractMap 实现了大部分的Map接口。11HashMap HashMap 是一个散列表,它存储的内容是键值对(key-value)映射。 该类实现了Map接口,根据键的HashCode值存储数据,具有很快的访问速度,最多允许一条记录的键为null,不支持线程同步。12TreeMap 继承了AbstractMap,并且使用一颗树。13WeakHashMap 继承AbstractMap类,使用弱密钥的哈希表。14LinkedHashMap 继承于HashMap,使用元素的自然顺序对元素进行排序.15IdentityHashMap 继承AbstractMap类,比较文档时使用引用相等。

    huc_逆天

    2021-01-08 14:25:56

    0 浏览量

    回答数 0

    回答

    Java 语言定义了一些异常类在 java.lang 标准包中。

    标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的,所以大部分从运行时异常类继承而来的异常都可以直接使用。

    Java 根据各个类库也定义了一些其他的异常,下面的表中列出了 Java 的非检查性异常。

    异常描述ArithmeticException当出现异常的运算条件时,抛出此异常。例如,一个整数"除以零"时,抛出此类的一个实例。ArrayIndexOutOfBoundsException用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小,则该索引为非法索引。ArrayStoreException试图将错误类型的对象存储到一个对象数组时抛出的异常。ClassCastException当试图将对象强制转换为不是实例的子类时,抛出该异常。IllegalArgumentException抛出的异常表明向方法传递了一个不合法或不正确的参数。IllegalMonitorStateException抛出的异常表明某一线程已经试图等待对象的监视器,或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。IllegalStateException在非法或不适当的时间调用方法时产生的信号。换句话说,即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。IllegalThreadStateException线程没有处于请求操作所要求的适当状态时抛出的异常。IndexOutOfBoundsException指示某排序索引(例如对数组、字符串或向量的排序)超出范围时抛出。NegativeArraySizeException如果应用程序试图创建大小为负的数组,则抛出该异常。NullPointerException当应用程序试图在需要对象的地方使用 null 时,抛出该异常NumberFormatException当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常。SecurityException由安全管理器抛出的异常,指示存在安全侵犯。StringIndexOutOfBoundsException此异常由 String 方法抛出,指示索引或者为负,或者超出字符串的大小。UnsupportedOperationException当不支持请求的操作时,抛出该异常。

    下面的表中列出了 Java 定义在 java.lang 包中的检查性异常类。

    异常描述ClassNotFoundException应用程序试图加载类时,找不到相应的类,抛出该异常。CloneNotSupportedException当调用 Object 类中的 clone 方法克隆对象,但该对象的类无法实现 Cloneable 接口时,抛出该异常。IllegalAccessException拒绝访问一个类的时候,抛出该异常。InstantiationException当试图使用 Class 类中的 newInstance 方法创建一个类的实例,而指定的类对象因为是一个接口或是一个抽象类而无法实例化时,抛出该异常。InterruptedException一个线程被另一个线程中断,抛出该异常。NoSuchFieldException请求的变量不存在NoSuchMethodException请求的方法不存在

    huc_逆天

    2021-01-08 14:08:25

    0 浏览量

    回答数 0

    问题

    Java基础

    面向对象有那三大特征

    类由什么组成

    "什么运算符的作用是根据对象的类型分配内存空间。当对象拥有内存空间时,会自动调用类中的构造方法 为对象实例化。"

    使用____修饰的类成员称为私有成员。私有成员只...

    游客pklijor6gytpx

    2019-12-01 22:02:53

    69 浏览量

    回答数 1

    问题

    Java技术1000问(3)【精品问答】

    为了方便Java开发者快速找到相关技术问题和答案,开发者社区策划了Java技术1000问内容,包含最基础的Java语言概述、数据类型和运算符、面向对象等维度内容。

    我们会以每天至少50条的速度,增...

    问问小秘

    2020-06-02 14:27:10

    11463 浏览量

    回答数 3

    问题

    当具体的JPA实体类与其通用超类位于不同的包中时,问题加载应用程序

    最近,我正在重组和重构代码,其中一项任务是将类归类到逻辑组/程序包中。由于我在泛型中使用了很多继承/子类,因此我通常将父类留在原处,并将其子类移到单独的子包中。

    下面是目录ÿ...

    几许相思几点泪

    2019-12-22 18:29:45

    21 浏览量

    回答数 1

    回答

    异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的。

    比如说,你的代码少了一个分号,那么运行出来结果是提示是错误 java.lang.Error;如果你用System.out.println(11/0),那么你是因为你用0做了除数,会抛出 java.lang.ArithmeticException 的异常。

    异常发生的原因有很多,通常包含以下几大类:

    用户输入了非法数据。 要打开的文件不存在。 网络通信时连接中断,或者JVM内存溢出。 这些异常有的是因为用户错误引起,有的是程序错误引起的,还有其它一些是因为物理错误引起的。- 要理解Java异常处理是如何工作的,你需要掌握以下三种类型的异常:

    检查性异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略。 运行时异常: 运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常可以在编译时被忽略。 错误: 错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时,一个错误就发生了,它们在编译也检查不到的。 Exception 类的层次 所有的异常类是从 java.lang.Exception 类继承的子类。

    Exception 类是 Throwable 类的子类。除了Exception类外,Throwable还有一个子类Error 。

    Java 程序通常不捕获错误。错误一般发生在严重故障时,它们在Java程序处理的范畴之外。

    Error 用来指示运行时环境发生的错误。

    例如,JVM 内存溢出。一般地,程序不会从错误中恢复。

    异常类有两个主要的子类:IOException 类和 RuntimeException 类。

    在 Java 内置类中(接下来会说明),有大部分常用检查性和非检查性异常。

    Java 内置异常类 Java 语言定义了一些异常类在 java.lang 标准包中。

    标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的,所以大部分从运行时异常类继承而来的异常都可以直接使用。

    Java 根据各个类库也定义了一些其他的异常,下面的表中列出了 Java 的非检查性异常。

    异常 描述 ArithmeticException 当出现异常的运算条件时,抛出此异常。例如,一个整数"除以零"时,抛出此类的一个实例。 ArrayIndexOutOfBoundsException 用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小,则该索引为非法索引。 ArrayStoreException 试图将错误类型的对象存储到一个对象数组时抛出的异常。 ClassCastException 当试图将对象强制转换为不是实例的子类时,抛出该异常。 IllegalArgumentException 抛出的异常表明向方法传递了一个不合法或不正确的参数。 IllegalMonitorStateException 抛出的异常表明某一线程已经试图等待对象的监视器,或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。 IllegalStateException 在非法或不适当的时间调用方法时产生的信号。换句话说,即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。 IllegalThreadStateException 线程没有处于请求操作所要求的适当状态时抛出的异常。 IndexOutOfBoundsException 指示某排序索引(例如对数组、字符串或向量的排序)超出范围时抛出。 NegativeArraySizeException 如果应用程序试图创建大小为负的数组,则抛出该异常。 NullPointerException 当应用程序试图在需要对象的地方使用 null 时,抛出该异常 NumberFormatException 当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常。 SecurityException 由安全管理器抛出的异常,指示存在安全侵犯。 StringIndexOutOfBoundsException 此异常由 String 方法抛出,指示索引或者为负,或者超出字符串的大小。 UnsupportedOperationException 当不支持请求的操作时,抛出该异常。 下面的表中列出了 Java 定义在 java.lang 包中的检查性异常类。

    异常 描述 ClassNotFoundException 应用程序试图加载类时,找不到相应的类,抛出该异常。 CloneNotSupportedException 当调用 Object 类中的 clone 方法克隆对象,但该对象的类无法实现 Cloneable 接口时,抛出该异常。 IllegalAccessException 拒绝访问一个类的时候,抛出该异常。 InstantiationException 当试图使用 Class 类中的 newInstance 方法创建一个类的实例,而指定的类对象因为是一个接口或是一个抽象类而无法实例化时,抛出该异常。 InterruptedException 一个线程被另一个线程中断,抛出该异常。 NoSuchFieldException 请求的变量不存在 NoSuchMethodException 请求的方法不存在 异常方法 下面的列表是 Throwable 类的主要方法:

    序号 方法及说明 1 public String getMessage() 返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。 2 public Throwable getCause() 返回一个Throwable 对象代表异常原因。 3 public String toString() 使用getMessage()的结果返回类的串级名字。 4 public void printStackTrace() 打印toString()结果和栈层次到System.err,即错误输出流。 5 public StackTraceElement [] getStackTrace() 返回一个包含堆栈层次的数组。下标为0的元素代表栈顶,最后一个元素代表方法调用堆栈的栈底。 6 public Throwable fillInStackTrace() 用当前的调用栈层次填充Throwable 对象栈层次,添加到栈层次任何先前信息中。 捕获异常 使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。

    try/catch代码块中的代码称为保护代码,使用 try/catch 的语法如下:

    try { // 程序代码 }catch(ExceptionName e1) { //Catch 块 } Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时,try 后面的 catch 块就会被检查。

    如果发生的异常包含在 catch 块中,异常会被传递到该 catch 块,这和传递一个参数到方法是一样。

    实例 下面的例子中声明有两个元素的一个数组,当代码试图访问数组的第三个元素的时候就会抛出一个异常。

    ExcepTest.java 文件代码: // 文件名 : ExcepTest.java import java.io.*; public class ExcepTest{

    public static void main(String args[]){ try{ int a[] = new int[2]; System.out.println("Access element three :" + a[3]); }catch(ArrayIndexOutOfBoundsException e){ System.out.println("Exception thrown :" + e); } System.out.println("Out of the block"); } } 以上代码编译运行输出结果如下:

    Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3 Out of the block 多重捕获块 一个 try 代码块后面跟随多个 catch 代码块的情况就叫多重捕获。

    多重捕获块的语法如下所示:

    try{ // 程序代码 }catch(异常类型1 异常的变量名1){ // 程序代码 }catch(异常类型2 异常的变量名2){ // 程序代码 }catch(异常类型3 异常的变量名3){ // 程序代码 } 上面的代码段包含了 3 个 catch块。

    可以在 try 语句后面添加任意数量的 catch 块。

    如果保护代码中发生异常,异常被抛给第一个 catch 块。

    如果抛出异常的数据类型与 ExceptionType1 匹配,它在这里就会被捕获。

    如果不匹配,它会被传递给第二个 catch 块。

    如此,直到异常被捕获或者通过所有的 catch 块。

    实例 该实例展示了怎么使用多重 try/catch。

    try { file = new FileInputStream(fileName); x = (byte) file.read(); } catch(FileNotFoundException f) { // Not valid! f.printStackTrace(); return -1; } catch(IOException i) { i.printStackTrace(); return -1; } throws/throw 关键字: 如果一个方法没有捕获到一个检查性异常,那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。

    也可以使用 throw 关键字抛出一个异常,无论它是新实例化的还是刚捕获到的。

    下面方法的声明抛出一个 RemoteException 异常:

    import java.io.*; public class className { public void deposit(double amount) throws RemoteException { // Method implementation throw new RemoteException(); } //Remainder of class definition } 一个方法可以声明抛出多个异常,多个异常之间用逗号隔开。

    例如,下面的方法声明抛出 RemoteException 和 InsufficientFundsException:

    import java.io.*; public class className { public void withdraw(double amount) throws RemoteException, InsufficientFundsException { // Method implementation } //Remainder of class definition } finally关键字 finally 关键字用来创建在 try 代码块后面执行的代码块。

    无论是否发生异常,finally 代码块中的代码总会被执行。

    在 finally 代码块中,可以运行清理类型等收尾善后性质的语句。

    finally 代码块出现在 catch 代码块最后,语法如下:

    try{ // 程序代码 }catch(异常类型1 异常的变量名1){ // 程序代码 }catch(异常类型2 异常的变量名2){ // 程序代码 }finally{ // 程序代码 } 实例 ExcepTest.java 文件代码: public class ExcepTest{ public static void main(String args[]){ int a[] = new int[2]; try{ System.out.println("Access element three :" + a[3]); }catch(ArrayIndexOutOfBoundsException e){ System.out.println("Exception thrown :" + e); } finally{ a[0] = 6; System.out.println("First element value: " +a[0]); System.out.println("The finally statement is executed"); } } } 以上实例编译运行结果如下:

    Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3 First element value: 6 The finally statement is executed 注意下面事项:

    catch 不能独立于 try 存在。 在 try/catch 后面添加 finally 块并非强制性要求的。 try 代码后不能既没 catch 块也没 finally 块。 try, catch, finally 块之间不能添加任何代码。 声明自定义异常 在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。 所有异常都必须是 Throwable 的子类。 如果希望写一个检查性异常类,则需要继承 Exception 类。 如果你想写一个运行时异常类,那么需要继承 RuntimeException 类。 可以像下面这样定义自己的异常类:

    class MyException extends Exception{ } 只继承Exception 类来创建的异常类是检查性异常类。

    下面的 InsufficientFundsException 类是用户定义的异常类,它继承自 Exception。

    一个异常类和其它任何类一样,包含有变量和方法。

    实例 以下实例是一个银行账户的模拟,通过银行卡的号码完成识别,可以进行存钱和取钱的操作。

    InsufficientFundsException.java 文件代码: // 文件名InsufficientFundsException.java import java.io.*;

    //自定义异常类,继承Exception类 public class InsufficientFundsException extends Exception { //此处的amount用来储存当出现异常(取出钱多于余额时)所缺乏的钱 private double amount; public InsufficientFundsException(double amount) { this.amount = amount; } public double getAmount() { return amount; } } 为了展示如何使用我们自定义的异常类,

    在下面的 CheckingAccount 类中包含一个 withdraw() 方法抛出一个 InsufficientFundsException 异常。

    CheckingAccount.java 文件代码: // 文件名称 CheckingAccount.java import java.io.*;

    //此类模拟银行账户 public class CheckingAccount { //balance为余额,number为卡号 private double balance; private int number; public CheckingAccount(int number) { this.number = number; } //方法:存钱 public void deposit(double amount) { balance += amount; } //方法:取钱 public void withdraw(double amount) throws InsufficientFundsException { if(amount <= balance) { balance -= amount; } else { double needs = amount - balance; throw new InsufficientFundsException(needs); } } //方法:返回余额 public double getBalance() { return balance; } //方法:返回卡号 public int getNumber() { return number; } } 下面的 BankDemo 程序示范了如何调用 CheckingAccount 类的 deposit() 和 withdraw() 方法。

    BankDemo.java 文件代码: //文件名称 BankDemo.java public class BankDemo { public static void main(String [] args) { CheckingAccount c = new CheckingAccount(101); System.out.println("Depositing $500..."); c.deposit(500.00); try { System.out.println("\nWithdrawing $100..."); c.withdraw(100.00); System.out.println("\nWithdrawing $600..."); c.withdraw(600.00); }catch(InsufficientFundsException e) { System.out.println("Sorry, but you are short $" + e.getAmount()); e.printStackTrace(); } } } 编译上面三个文件,并运行程序 BankDemo,得到结果如下所示:

    Depositing $500...

    Withdrawing $100...

    Withdrawing $600... Sorry, but you are short $200.0 InsufficientFundsException at CheckingAccount.withdraw(CheckingAccount.java:25) at BankDemo.main(BankDemo.java:13) 通用异常 在Java中定义了两种类型的异常和错误。

    JVM(Java虚拟机) 异常:由 JVM 抛出的异常或错误。例如:NullPointerException 类,ArrayIndexOutOfBoundsException 类,ClassCastException 类。 程序级异常:由程序或者API程序抛出的异常。例如 IllegalArgumentException 类,IllegalStateException 类。

    游客2q7uranxketok

    2021-02-07 20:08:10

    0 浏览量

    回答数 0

    问题

    【精品问答】Java实战200例(附源码)

    Java实战200例(附源码)

    1.编写一个Java程序,用if-else语句判断某年份是否为闰年

    2. 编写一个Java程序在屏幕上输出1!+2!+...

    珍宝珠

    2020-02-14 11:55:46

    16104 浏览量

    回答数 10

    问题

    java二叉树模板抽象化

    我有两个二叉树类,分别管理着不同的数据

    class bt1{

    //自身业务逻辑

    String s;

    public String getS(){

    return "godness " + s;

    }

    //二叉树逻辑

    bt1 left;

    bt1 r...

    蛮大人123

    2019-12-01 19:39:48

    1166 浏览量

    回答数 1

    展开全文
  • Python——继承

    千次阅读 2021-12-08 10:26:44
    Python中继承语法格式如下: class 子类名(父类名): 的属性 的方法 例 7-11 继承示例,子类继承父类方法: #ex0711.py 继承示例,子类继承父类方法 class Animal: num = 0 def __init__(self): ...
  • Python中类的多继承

    千次阅读 2019-05-21 18:02:49
    文章目录Python中类的多继承继承Python多继承实现多继承的缺点Mixin*思路1**思路2**思路3**思路4*Mixin Python中类的多继承 Python2.2之前是没有共同的祖先的,之后,引入object,它是所有的共同祖先...
  • 继承与派生

    千次阅读 2022-03-27 20:43:57
    及对象的访问权限: 类中的成员函数可以直接访问类中的数据成员(包括私有成员、公有成员、保护成员); 类中的成员函数可以相互访问;...在继承关系中继承的类称为基类(或父类),把通过继承关...
  • Java继承详解

    2021-01-20 03:35:36
     通过extends关键字让之间产生继承关系。  class SubDemo extends Demo{} //SubDemo是子类,Demo是父类  继承有什么好处?  提高代码的复用性。  让之间产生了关系,是多态的前提。  继承...
  • 彻底搞懂python继承

    2021-01-21 16:48:32
    在继承关系中,已有的、设计好的类称为父类或基类,新设计的类称为子类或派生。派生可以继承父类的公有成员,但是不能继承其私有成员。如果需要派生类中调用基类的方法,可以使用内置函数super()或者通过...
  • C# 继承

    2021-01-03 04:21:27
    这个已有的类被称为的基类,这个新的类被称为派生类。 继承的思想实现了 属于(IS-A) 关系。例如,哺乳动物 属于(IS-A) 动物,狗 属于(IS-A) 哺乳动物,因此狗 属于(IS-A) 动物。 基类和派生类 一个类可以...
  • java继承详解

    万次阅读 多人点赞 2020-12-19 08:43:00
    继承的描述现实生活继承一般指的是子女继承父辈的财产。程序继承描述的是事物之间的所属关系,通过继承可以使多种事物之间形成一种关系体系。例如猫和狗都属于动物,程序便可以描述为猫...
  • python继承

    2021-01-29 21:52:01
    一、概述二、继承2.1 继承的定义2.2 构造函数的继承2.3 子类对父类...通过继承创建的新类称为“子类”或“派生”,被继承类称为“基类”、“父类”或“超类”,继承的过程,就是从一般到特殊的过程。某...
  • 派生和基类的关系类继承

    千次阅读 2016-07-01 19:33:10
    开发新工程,尤其是当工程十分庞大时,重用经过测试的代码比重新编写代码要好的多,使用已有的代码可以节省时间,由于已有的代码已测试和使用过,因此有助于避免程序引入错误。另外,必须考虑的细节越少,便...
  • 1、接口可以继承接口,抽象不可以继承接口,但可以实现接口。 2、抽象可以继承实体。抽象可以实现(implements)接口,抽象是否可继承实体,取决于实体必须是否有明确的构造函数。 3、抽象可以继承...
  • 继承的类称为父类,继承了父类的所有数据和操作的类称为子类。 PHP 中用 extends 表明子类与父类的继承关系面向对象的程序设计,采用继承的方式来组织设计系统,可以提高程序的抽象程度,更接近人...
  • 一、继承关系      继承指的是一个称为子类、子接口)继承另外的一个称为父类、父接口)的功能,并可以增加它自己的新功能的能力。Java中继承关系通过关键字extends明确标识,设计...
  • servlet继承什么

    千次阅读 2021-03-14 15:52:07
    Servlet(Server Applet)是Java Servlet的简称,称为小服务程序或服务连接器,用Java编写的服务器端程序,具有独立于平台和协议的特性,主要功能在于交互式地浏览和生成数据,生成动态Web内容。狭义的Servlet是指Java...
  • C++继承关系

    千次阅读 2016-11-08 12:50:15
    C++继承关系 一、继承概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员保持原有特性的基础上进行扩展,增加功能。这样产生新的,称派生。继承呈现了面向对象...
  • Python 类继承与多重继承

    千次阅读 2020-05-21 10:35:03
    python中新定义一个类称为子类,被继承类称为父类;子类继承父类后就拥有了父类的所有特性。 #语法格式 class 子类名(父类名): pass 如下:定义了Person,一个Student,但是Student完全可以使用Person...
  • java中类继承详解。

    万次阅读 多人点赞 2018-07-11 21:42:48
     实现继承类被称为子类. 被继承类被称为父类. 父类和子类的关系, 是一种一般和特殊的关系. 例如水果和苹果的关系, 苹果继承了水果, 苹果是水果的子类, 水果是苹果的父类.Java里子类继承父类的语法格式如下:...
  • C++ 继承关系

    千次阅读 2019-04-26 23:16:56
    1.继承的概念及定义 1.1继承的概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员保持原有特性的基础上进行扩展,增加功能,这样产生新的,...1.2.2继承关系和访问限定...
  • C++继承

    千次阅读 2022-03-16 13:53:39
    c++中被继承类称为父类或基类,继承类称为子类或派生。"子类"和"父类"通常放一起称呼,"基类"和"派生"通常放一起称呼。派生除了拥有基类的成员,还可以定义自己的新成员,以增强的功能。 使用继承...
  • Java继承

    千次阅读 2021-02-13 02:17:13
    新的这个类被称为子类或者派生类,已知的类被称为父类或者基类、超类。2.为什么使用继承呢?将一个类作为父类这样可以使其代码进行重用,子类就可以不再需要写父类已有的属性或者行为了3.那Java如何实现继...
  • 第7.6节 Python中类继承机制详述

    千次阅读 多人点赞 2019-06-12 18:41:25
    本章第一节,介绍了面向对象程序设计的三个特征:封装、继承和多态,前面章节重点介绍了封装和多态,由于Python语言是多态语言,对象的类型不再由继承等方式决定,而由实际运行时所表现出的具体行为来决定,因此不...
  • C++ (继承的基础知识)

    万次阅读 多人点赞 2018-07-29 12:53:54
    文章概述 之间的关系; 继承的基础知识; 派生的语法定义; 继承的重要说明;...派生的访问控制;...派生访问控制的结论;...之间的关系 ...3. 继承关系: 具有传递性,不具有对称性。 继承的基础知识 a...
  • Qt的自定义需要继承QObject吗?

    千次阅读 2020-04-25 23:17:27
    近日写一些表示层的数据对像时,遇到了一个不明原因的小问题(见上一篇)引发思考:Qt自己定义的需不需要继承QObject基类?百度、论坛找了一圈没有答案。无奈只能翻看帮助文档,原来QObject的介绍写的非常...
  • 面向对象程序设计-继承

    千次阅读 2021-11-12 09:19:07
    继承之间的关系,使用继承可以减少代码的冗余,可以通过下图简单的了解继承继承是一种新建的方式,新建的类称为子类,被继承类称为父类。继承之间的关系,使用继承可以减少代码的冗余,...
  •  通过继承创建的新类称为“子类”或“派生”,被继承类称为“基类”、“父类”或“超类”,继承的过程,就是从一般到特殊的过程。某些 OOP 语言,一个子类可以继承多个基类。但是一般情况下,一个子类只能...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 245,910
精华内容 98,364
关键字:

在继承关系中被继承的类称为