java 中抽象类的继承_java抽象类 继承

关于

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