抽象类与接口的问题
抽象类和接口的相同点跟区别
相同点:(1) 都可以被继承(2) 都不能被实例化(3) 都可以包含方法声明(4) 派生类必须实现未实现的方法区别:(1) 抽象基类可以定义字段、属性、方法实现。
接口只能定义属性、索引器、事件、和方法声明,不能包含字段。
(2) 抽象类是一个不完整的类,需要进一步细化,而接口是一个行为规范。
微软的自定义接口总是后带able字段,证明其是表述一类“我能做。
”(3) 接口可以被多重实现,抽象类只能被单一继承(4) 抽象类更多的是定义在一系列紧密相关的类间,而接口大多数是关系疏松但都实现某一功能的类中(5) 抽象类是从一系列相关对象中抽象出来的概念,因此反映的是事物的内部共性;接口是为了满足外部调用而定义的一个功能约定,因此反映的是事物的外部特性(6) 接口基本上不具备继承的任何具体特点,它仅仅承诺了能够调用的方法(7) 接口可以用于支持回调,而继承并不具备这个特点(8) 抽象类实现的具体方法默认为虚的,但实现接口的类中的接口方法却默认为非虚的,当然您也可以声明为虚的(9) 如果抽象类实现接口,则可以把接口中方法映射到抽象类中作为抽象方法而不必实现,而在抽象类的子类中实现接口中方法使用规则:1、抽象类主要用于关系密切的对象,而接口最适合为不相关的类提供通用功能2、如果要设计大的功能单元,则使用抽象类;如果要设计小而简练的功能块,则使用接口。
3、如果预计要创建组件的多个版本,则创建抽象类。
接口一旦创建就不能更改。
如果需要接口的新版本,必须创建一个全新的接口。
4、如果创建的功能将在大范围的全异对象间使用,则使用接口;如果要在组件的所有实现间提供通用的已实现功能,则使用抽象类。
5、分析对象,提炼内部共性形成抽象类,用以表示对象本质,即“是什么”。
为外部提供调用或功能需要扩充时优先使用接口6、好的接口定义应该是具有专一功能性的,而不是多功能的,否则造成接口污染。
如果一个类只是实现了这个接口的中一个功能,而不得不去实现接口中的其他方法,就叫接口污染7、尽量避免使用继承来实现组建功能,而是使用黑箱复用,即对象组合。
接口和抽象类的区别和作用(功能、用途、好处)
接⼝和抽象类的区别和作⽤(功能、⽤途、好处)接⼝:抽象类和接⼝亲兄弟,但是有嫡出庶出的区别总结了4点接⼝存在的意义:1、重要性:在Java语⾔中, abstract class 和interface 是⽀持抽象类定义的两种机制。
正是由于这两种机制的存在,才赋予了Java强⼤的⾯向对象能⼒。
2、简单、规范性:如果⼀个项⽬⽐较庞⼤,那么就需要⼀个能理清所有业务的架构师来定义⼀些主要的接⼝,这些接⼝不仅告诉开发⼈员你需要实现那些业务,⽽且也将命名规范限制住了(防⽌⼀些开发⼈员随便命名导致别的程序员⽆法看明⽩ 3、维护、拓展性:⽐如你要做⼀个画板程序,其中⾥⾯有⼀个⾯板类,主要负责绘画功能,然后你就这样定义了这个类。
可是在不久将来,你突然发现这个类满⾜不了你了,然后你⼜要重新设计这个类,更糟糕是你可能要放弃这个类,那么其他地⽅可能有引⽤他,这样修改起来很⿇烦。
如果你⼀开始定义⼀个接⼝,把绘制功能放在接⼝⾥,然后定义类时实现这个接⼝,然后你只要⽤这个接⼝去引⽤实现它的类就⾏了,以后要换的话只不过是引⽤另⼀个类⽽已,这样就达到维护、拓展的⽅便性。
4、安全、严密性:接⼝是实现软件松耦合的重要⼿段,它描叙了系统对外的所有服务,⽽不涉及任何具体的实现细节。
这样就⽐较安全、严密⼀些(⼀般软件服务商考虑的⽐较多)。
那么什么是接⼝呢?接⼝是⼀种能⼒1:接⼝的命名规则与类型不同。
如果修饰符是public。
则该接⼝在整个项⽬中可见,如果省略修饰符则该接⼝只能在该包可见2:接⼝中可以定义常量,不能定义变量,接⼝中的属性都会⾃动⽤public static final修饰,即接⼝中的属性都是全局静态常量,接⼝中的常量必须在定义时指定初始值3:接⼝中所有的⽅法抽象⽅法。
接⼝中的⽅法都会⾃动⽤public abstract修饰。
即接⼝中只有全局抽象⽅法,4:和抽象类⼀样,接⼝不能被实例化,接⼝中不能有狗构造⽅法5:接⼝之间可以通过extends 实现继承关系,⼀个接⼝可以继承多个接⼝。
接口的定义及使用
1、课程名称:接口的定义及使用2、知识点2.1、上次课程的主要知识点1、抽象类的设计是在普通类之上的抽象类;2、抽象类关键的问题就是约定了子类必须要覆写的抽象方法;3、抽象类的使用原则:·抽象类必须有子类,子类利用extends关键字来继承抽象类,一个子类只能够继承一个父类;·抽象类的子类(如果不是抽象类),那么必须要覆写抽象类中的全部抽象方法;·抽象类可以利用对象的向上转型机制,通过子类对象进行实例化操作。
2.2、本次预计讲解的知识点1、接口的基本定义以及使用形式;2、与接口有关的设计模式的初步认识;3、接口与抽象类的区别。
3、具体内容(★★★★★★★★★★★★★★)接口与抽象类相比,接口的使用几率是最高的,所有的设计几乎都是围绕着接口进行的,但是要想把接口彻底闹明白,需要很长一段时间。
3.1、接口的基本概念接口是一种特殊的类,但是在接口里面的组成与类不同,比类的组成部分简单,主要由抽象方法和全局常量所组成。
而接口使用interface关键字来定义。
范例:定义一个接口当一个接口定义完成之后,需要遵循如下的步骤进行接口的使用:·接口一定要定义子类,子类利用implements关键字来实现接口,一个子类可以同时实现多个接口;|- 秒杀抽象类的单继承局限,一个抽象类只能够被一个子类所继承;·接口的子类(如果不是抽象类)那么必须覆写接口中的全部抽象方法;·接口的对象利用子类对象的向上转型进行实例化操作。
范例:使用接口但是这个时候会有这样一种比较神奇的操作。
注意:关于接口的组成描述接口里面在定义的时候就已经明确的给出了开发要求:抽象方法和全局常量,所以以下两种接口的定义从本质上讲是完全一样的。
如果在定义接口方法的时候没有使用public ,那么本质上也不是default 权限,而默认就是public 。
很多时候为了防止一些开发者概念不清晰,所以以后建议大家在定义接口的时候永远都写上public ,但是一般都不会去写abstract 。
Java抽象类与接口-笔记
抽象类与接口-笔记关键字:接口抽象类,接口与类是一个层次的概念,是java中极其重要的概念抽象类是从多个类中抽象出来的公共模板,提供子类均具有的功能。
接口是从多个类中抽象出来的规范,体现的是规范和实现分离的原则,同时也有效的解决Java单重继承的缺陷。
*******普通方法与抽象方法的不同*******普通方法需要有访问修饰符,返回类型,方法名,还要有一个方法体,抽象方法也有访问修饰符,返回类型,方法名,但是它还多了一个修饰符——abstract,同时没有方法体,也就是说抽象方法没有实现。
普通方法与抽象方法的区别:1,普通方法必须要有实现体,抽象方法不能有实现体,抽象方法要用abstract修饰符来修饰。
********普通类与抽象类的区别*********普通类:要有访问修饰符,class关键字和类名。
抽象类:在普通类的基础之上,还多了一个abstract修饰符。
在使用的时候抽象类与普通类也不一样:普通类:可以通过new关键字实例化。
抽象类:不能使用new关键字来实例化。
**********抽象类********************抽象类:是一个不能实例化的类,它可以具有抽象方法或者普通方法。
定义抽象类的语法与定义普通类类似,只是多了一个关键字abstract。
注意:抽象类中可以定义抽象方法,也可以拥有普通方法,而普通类当中只能定义普通方法。
********对比抽象类与接口***************抽象类用abstract修饰符来定义,而且抽象类中可以有抽象方法,也可以有普通方法。
**接口是使用interface关键字来定义,关键字后面是接口名。
注意::定义接口的时候不再使用class关键字。
同时,接口只能拥有抽象方法。
***从定义就可以看出抽象类与接口的区别:1,抽象类使用abstract声明,接口使用interface声明。
2,抽象类除了抽象方法,还可以有普通方法,而接口中只能有抽象方法。
类与接口的关系及区别
类与接⼝的关系及区别1、类和类的关系:继承 extends / 单继承-- 继承的意义:为了提⾼代码的复⽤性,减少了代码的编写提⾼开发效率。
-- ⽅法重写的意义:在不修改⽗类源码的前提下,在⼦类中重写业务,从此使⽤的就是重写后的功能。
-- 要求⼦类的⽅法声明和⽗类⼀样,只要改⽅法体。
-- 有了继承有了重写就产⽣了多态,多态的意义:为了统⼀程序的调⽤标准,标准就是⽗类。
-- 多态也就是向上转型/向上造型。
(⽗类引⽤指向⼦类对象编译看左边,运⾏看右边)-- 向下造型的意义:很少⽤,相当于想要使⽤⼦类的特殊功能,还不如直接创建⼦类对象简单。
-- class A extends B-- 其中,A和B都是类,A是⼦类,B是⽗类,A就拥有了B的所有功能(除了私有的和构造⽅法)-- 其他知识点:this 和super ,构造⽅法,各种代码块...2、类和接⼝关系:实现implements / 单实现 / 多实现-- class A implements B,C-- 其中,A是实现类,B和C是接⼝-- 要求A 可以把 B 和C 接⼝⾥的所有抽象⽅法都重写掉,否则 A 就是抽象类-- 接⼝不能创建对象-- 接⼝⾥没有构造⽅法,接⼝⾥都是常量,接⼝⾥都是抽象⽅法3、接⼝和接⼝关系:继承extends / 单继承 / 多继承-- 接⼝的多继承的关系,打破了java单继承的局限性-- interface A extends B,C-- 其中,A B C 都是接⼝,A是⼦接⼝,同时拥有B和C接⼝⾥的所有功能-- class AImpl implements A-- 要求AImpl需要重写A接⼝⾥的所有⽅法(是包含B和C接⼝的所有⽅法),否则就是抽象类4、接⼝和抽象类的区别-- 相同点:都是抽象层,都不能实例化-- 不同点:-- 1、抽象类⽤abstract关键字描述,接⼝⽤interface-- 2、⼦类和抽象类之间是extends关系,实现类和接⼝之间是implements关系-- 3、抽象类中可以有构造⽅法,接⼝⾥不能出现构造⽅法-- 4、抽象类⾥可以有变量,接⼝⾥没有变量全都是静态的常量-- 5、接⼝⾥定义常量的语法:public static final String NAME="jack",会为变量⾃动拼接public static final -- 6、抽象类⾥可以有普通⽅法也可以有抽象⽅法,接⼝都是抽象⽅法-- 7、抽象类和⼦类之间是继承关系,⽽且java中,只⽀持单继承-- 8、接⼝突破了java单继承的局限性,因为接⼝可以多继承也可以多实现,甚⾄可以继承的同时多实现-- 9、接⼝的复杂⽤法-- 多继承: interface A extends B,C 其中A是⼦接⼝,同时拥有⾃⼰的和BC的功能-- 多实现: class AImpl implements M,N,O,P 其中AImpl是实现类,需要同时重写MNOP的所有抽象⽅法,否则就是⼀个抽 -- 继承的同时多实现: class AImpl extends Object implements M,N ⼀定是先继承后实现。
抽象类和接口的区别
抽象类和接口的区别对于面向对象编程来说,抽象是它的一大特征之一。
在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类。
这两者有太多相似的地方,又有太多不同的地方。
下面是为大家准备的抽象类和接口的区别,希望大家喜欢!抽象类和接口的相关知识一.抽象类在了解抽象类之前,先来了解一下抽象方法。
抽象方法是一种特殊的方法:它只有声明,而没有具体的实现。
抽象方法的声明格式为:1abstract void fun();抽象方法必须用abstract关键字进行修饰。
如果一个类含有抽象方法,则称这个类为抽象类,抽象类必须在类前用abstract关键字修饰。
因为抽象类中含有无具体实现的方法,所以不能用抽象类创建对象。
下面要注意一个问题:在《JAVA编程思想》一书中,将抽象类定义为“包含抽象方法的类”,但是后面发现如果一个类不包含抽象方法,只是用abstract修饰的话也是抽象类。
也就是说抽象类不一定必须含有抽象方法。
个人觉得这个属于钻牛角尖的问题吧,因为如果一个抽象类不包含任何抽象方法,为何还要设计为抽象类?所以暂且记住这个概念吧,不必去深究为什么。
123[public] abstract class ClassName {abstract void fun();}从这里可以看出,抽象类就是为了继承而存在的,如果你定义了一个抽象类,却不去继承它,那么等于白白创建了这个抽象类,因为你不能用它来做任何事情。
对于一个父类,如果它的某个方法在父类中实现出来没有任何意义,必须根据子类的实际需求来进行不同的实现,那么就可以将这个方法声明为abstract方法,此时这个类也就成为abstract类了。
包含抽象方法的类称为抽象类,但并不意味着抽象类中只能有抽象方法,它和普通类一样,同样可以拥有成员变量和普通的成员方法。
注意,抽象类和普通类的主要有三点区别:1)抽象方法必须为public或者protected(因为如果为private,则不能被子类继承,子类便无法实现该方法),缺省情况下默认为public。
多态的三种手段
多态的三种⼿段⽤virtual修饰的⽅法叫做虚⽅法虚⽅法可以在⼦类中通过override关键字来重写常见的虚⽅法:ToString() Equalsc#基础多态的三种⼿段多态的概念概念:让⼀个对象能够表现出多种的状态(类型)实现多态的3种⼿段:1、虚⽅法 2、抽象类 3、接⼝关于虚⽅法需要注意的⼏点:1.⽗类中如果有⽅法需要让⼦类重写,则可以将该⽅法标记为virtual2.虚⽅法在⽗类中必须有实现,哪怕是空实现。
3.虚⽅法⼦类可以重写(override),也可以不重写关于抽象⽅法注意的⼏点:1.需要⽤abstract关键字标记2.抽象⽅法不能有任何⽅法实现。
3.抽象成员必须包含在抽象类中。
4.由于抽象成员没有任何实现,所以⼦类必须将抽象成员重写。
5.抽象类不能实例化,抽象类的作⽤:抽象类的作⽤就是为了让⼦类继承。
6.抽象类中可以包括抽象成员,可以包括有具体代码的成员。
7. 还有抽象⽅法不能⽤static修饰1.接⼝中只能包含⽅法(属性、事件、索引器也都是⽅法)2.接⼝中的成员都不能有任何实现。
光说不做3.接⼝不能被实例化。
4.接⼝中的成员不能有任何访问修饰符。
(默认为public)5.实现接⼝的⼦类必须将接⼝中的所有成员全都实现。
6.⼦类实现接⼝的⽅法时,不需要任何关键字,直接实现即可。
7.接⼝存在的意义就是为了多态。
//1.虚⽅法⽤virtual修饰的⽅法叫做虚⽅法虚⽅法可以在⼦类中通过override关键字来重写常见的虚⽅法:ToString() Equals//1)、虚⽅法//步骤://1、将⽗类的⽅法标记为虚⽅法,使⽤关键字 virtual,这个函数可以被⼦类重新写⼀个遍。
public class Employee{public virtual void DaKa(){Console.WriteLine("九点打卡");}}public class Manager : Employee{public override void DaKa(){Console.WriteLine("经理11点打卡");}}public class Programmer : Employee{public override void DaKa(){Console.WriteLine("程序猿不打卡");}}//抽象类1//2)、抽象类//当⽗类中的⽅法不知道如何去实现的时候,可以考虑将⽗类写成抽象类,将⽅法写成抽象⽅法。
中国银行笔程序员面试题
中国银行笔试题1.J2EE是什么?2.介绍Java中的Collection framework(包括如何写自己的数据结构)?如COLLECTION中遗留类(HASHTABLE、VECTOR)和现有类的区别?(同步)3.Java中异常处理机制,事件机制?4.EJB与JAVA BEAN的区别?EJB与JAVA BEAN是SUN的不同组件规范,EJB是在容器中运行的,分步式的,而JAVA BEAN主要是一种可利用的组件,主要在客户端UI表现上。
5.JAVA中的多形与继承?XML:namespace prefix = o ns = "urn:schemas-microsoft-com:Officeffice" />可出编程,选择题。
6.抽象类与接口?接口的好处是将实现与表现分离。
抽象类与接口都用于抽象,但是抽象类(JAVA中)可以有自己的部分实现,而接口则完全是一个标识(同时有多重继承的功能)。
7.Java 的通信编程,编程题(或问答),用JAVA SOCKET编程,读服务器几个字符,再写入本地显示?8.JAVA servletapi中forward() 与redirect()的区别?forward()方法可以使用原来的对象,而且速度较快。
9.JAVA解析XML的方式?SAX、dom10.用JAVA实现数据库查询,这是一道编程题。
基本操作,不用讲了。
11.用JAVA实现一种排序,比较,JAVA类实现序列化的方法(二种)?如在COLLECTION框架中,实现比较要实现什么样的接口。
12.JSP中动态INCLUDE与静态INCLUDE的区别?老一套,动态可以带参数,静态相当于一段静态HTML文件。
13.应用服务器与web SERVER的区别?14.设计模式与UML方面。
如工厂模式,解决多数据库支持问题。
15。
编程:编写一个截取字符串的函数,输入为一个字符串和字节数,输出为按字节截取的字符串。
JAVA继承,接口,抽象类等练习
一、选择题1、为了区分重载多态中同名的不同方法,要求(A )。
A) 采用不同的参数列表B) 返回值类型不同C) 调用时用类名或对象名做前缀D) 参数名不同2、定义主类的类头时可以使用的访问控制符是( C)。
A) private B) protected C) public D) private protected3、下列整型的常量属性i 的定义中,正确的是( A)。
A) static final int i=100; B) final int i;C) static int i; D) final float i=1.2f;4、设x,y 均为已定义的类名,下列声明对象x1的语句中正确的是( C)。
A) public x x1= new y( ); B) x x1=x( );C) x x1=new x( ); D) int x x1;5、下列方法定义中,正确的是( D)。
A) int x( int a,b ) B) double x( int a,int b){ return (a-b); } { int w; w=a-b; }C) double x( a,b ) D) int x( int a,int b){ return b; } { return a-b; }6、为了使包sos在当前程序中可见,可以使用的语句是( A)。
A)import sos.*; B)package sos.*;C)sos import; D)sos package;7、设i、j、k 为类x 中定义的int 型变量名,下列类x 的构造函数中正确的是( )。
A) x( int m){ ... } B) void x( int m){ ... }C) x( int m, int n){ ... } D) x( int h,int m,int n){ ... }8、下列类头定义中,正确的是( )。
CA) class x B) public x extends y{ .... } { .... }C) public class x extends y D) class x extends y implements y1{ .... } { .... }9、下面是有关子类继承父类构造函数的描述,其中正确的是(C )。
java面试问题及回答
java面试问题及回答java面试问题及回答一1.Java中的方法覆盖(Overriding)和方法重载(Overloading)是什么意思?Java中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数不同的情况。
与此相对,方法覆盖是说子类重新定义了父类的方法。
方法覆盖必须有相同的方法名,参数列表和返回类型。
覆盖者可能不会限制它所覆盖的方法的访问。
2.Java中,什么是构造函数?什么是构造函数重载?什么是复制构造函数?当新对象被创建的时候,构造函数会被调用。
每一个类都有构造函数。
在程序员没有给类提供构造函数的情况下,Java编译器会为这个类创建一个默认的构造函数。
Java中构造函数重载和方法重载很相似。
可以为一个类创建多个构造函数。
每一个构造函数必须有它自己唯一的参数列表。
Java不支持像C++中那样的复制构造函数,这个不同点是因为如果你不自己写构造函数的情况下,Java不会创建默认的复制构造函数。
3.Java支持多继承么?不支持,Java不支持多继承。
每个类都只能继承一个类,但是可以实现多个接口。
4.接口和抽象类的区别是什么?Java提供和支持创建抽象类和接口。
它们的实现有共同点,不同点在于:接口中所有的方法隐含的都是抽象的。
而抽象类则可以同时包含抽象和非抽象的方法。
类可以实现很多个接口,但是只能继承一个抽象类类如果要实现一个接口,它必须要实现接口声明的所有方法。
但是,类可以不实现抽象类声明的所有方法,当然,在这种情况下,类也必须得声明成是抽象的。
抽象类可以在不提供接口方法实现的情况下实现接口。
Java接口中声明的变量默认都是final的。
抽象类可以包含非final的变量。
Java接口中的成员函数默认是public的。
抽象类的成员函数可以是private,protected或者是public。
接口是绝对抽象的,不可以被实例化。
抽象类也不可以被实例化,但是,如果它包含main方法的话是可以被调用的。
php 接口类与抽象类的实际作用
class BaseShop implements Shop
{
public function buy($gid)
{
echo('你购买了ID为 :'.$gid.'的商品');
}
public function sell($gid)
{
echo('你卖了ID为 :'.$gid.'的商品');
2.php 抽象类 : abstract
其实抽象类和接口类有一部分很像,记得在哪里看见这样一句话,抽象类就把类像的部分抽出来,这句看上去很搞笑,其实它说出了抽象类的真理,抽象类的作用是,当你发现你的很多类里面用很多方法你不断的在重复写,那你就可以考虑使用抽象类了,你可能会说“我不是可以重写一个类每个公共类我个实例化一个这个公共类,调用相同的方法就可以了”,这里是可以,实际上抽象类做的工作也就是这个,不过他省去了你实例化的这个步骤,让你就像直接调用本类方法一样方便,而且你还可以重载这个方法。如:
interface Shop
{
public function buy($gid);
public function sell($gid);
public function view($gid);
}
我声明一个shop接口类,定义了三个方法:买(buy),卖(sell),看(view),那么继承此类的所有子类都必须实现这3个方法少一个都不行,如果子类没有实现这些话,就无法运行。实际上接口类说白了,就是一个类的模板,一个类的规定,如果你属于这类,你就必须遵循我的规定,少一个都不行,但是具体你怎么去做,我不管,那是你的事,如:
Java语言程序设计(郑莉)课后习题答案
1.什么是对象、类,它们之间的联系?答:1)对象是包含现实世界物体特征的抽象实体,它反映系统为之保存信息和与它交互的能力。
对象是一些属性及服务的封装体,在程序设计领域,可以用“对象=数据+作用于这些数据上的操作”来表示。
现实生活中对象是指客观世界的实体;在程序中对象是指一组变量和相关方法的集合。
2)类是既有相同操作功能和相同的数据格式的对象的集合与抽象!3)两者的关系:对象是类的具体实例.。
2.什么是面向对象的程序设计方法?它有那些基本特征?答:面向对象程序设计从所处理的数据入手,以数据为中心而不是以服务为中心来描述系统。
它把编程问题视为一个数据集合,数据相对于功能而言,具有更强的稳定性。
它的特征:抽象,封装,继承,多态。
4.请解释类属性、实例属性及其区别。
答:实例属性,由一个个的实例用来存储所有实例都需要的属性信息,不同实例的属性值可能会不同。
5.请解释类方法、实例属性及其区别。
答:实例方法表示特定对象的行为,在声明时前面不加static修饰符,在使用时需要发送给一个类实例。
类方法也称为静态方法,在方法声明时前面需加static修饰符,类方法表示具体实例中类对象的共有行为。
区别:实例方法可以直接访问实例变量,调用实例方法,实例方法可以直接访问类变量,调用类方法;类方法可以直接调用类变量和类方法,类方法不能直接调用实例变量和实例方法;6.类的访问控制符有哪几种?具体含义及其区别。
答:类的访问控制符只有public(公共类)及无修饰符(默认类)两种。
区别:当使用public修饰符时表示所有其他的类都可以使用此类;当没有修饰符时,则只有与此类处于同一包中的其他类可以使用类。
7类成员的访问控制符有哪几种?他们对类成员分别有哪些访问限制的作用?答:类成员的访问控制符有public,private,protecte及无修饰符.public(公有的):用public修饰的成分表示公有的,也就是它可以被其他任何对象访问(前提是对累成员所在的类访问有访问权限).Private(保护的):类中限定为private的成员只能被这个类本身访问,在类外不可见。
抽象类与接口
7
Java高级编程
实例
图形类Shape,类中有一个抽象方法:用于返回图形的周 长;有一个属性:颜色;有两个子类:三角形和圆,实现 抽象方法。在测试类中,输出三角形和圆的周长和颜色。 见:形状抽象类文件夹
教员
中心 详细信息 detail方法 (输出详细信息)
中心
教员 详细信息
打印
21
Java高级编程
为什么需要Java接口 9-5
以下这个解决方案中存在着什么问题?
public class AccpSchool1 { private Printer printer = new Printer(); //输出中心的详细信息 public String detail() { return "这里是ACCP中心"; } //使用打印机打印教员信息 public void print(AccpTeacher1 t){ public class Printer { printer.printjz(t.detail()); public void printjz(String content) { } System.out.println("开始打印:"); //使用打印机打印中心信息 System.out.println(content); public void print(AccpSchool1 s){ } printer.printjz(s.detail()); } } } public class AccpTeacher1 { //输出教员的详细信息 public String detail() { return "本人是ACCP教员"; } } 每增加一种新类型,都需要增加相应的print(类型名称 var)方法 ——程序的可扩展性及可维护性极差 ——这不符合系统的要求
类与接口的区别和详解
类与接⼝的区别和详解
接⼝和抽象类的区别和联系
共同点:
1)抽象类和接⼝都不能被直接实例化;
差异点:
1)⼀个类只能继承⼀个抽象类,但是⼀个类可以同时实现多个接⼝;
2)接⼝⾥⾯只能对⽅法进⾏声明,抽象类既可以对⽅法进⾏声明也可以对⽅法进⾏实现;
3)抽象类⾥⾯的抽象⽅法必须全部被⼦类实现,如果⼦类不能全部实现,那么⼦类必须也是抽象类。
接⼝⾥⾯的⽅法也必须全部被⼦类实现,如果⼦类不能实现那么⼦类必须是抽象类;
4)抽象类描述了“A is a B” 的关系;接⼝描述了“A is like a B” 的关系;
5)设计理念:
接⼝的设计⽬的是为了实现多态,是对类的⾏为进⾏约束,可以强制要求不同的类具有相同的⾏为。
它只约束了⾏为的有⽆,但不对如何实现⾏为进⾏限制。
抽象类的设计⽬的是代码复⽤,可以把所有⼦类拥有的共同特性放到⼀个抽象类中,⼦类继承此抽象类。
当不同的类具有某些相同的⾏为(记为⾏为集合A),且其中⼀部分⾏为的实现⽅式⼀致时(A的⾮真⼦集,记为B),可以让这些类都派⽣于⼀个抽象类。
在这个抽象类中实现了B,避免让所有的⼦类来实现B,这就达到了代码复⽤的⽬的。
⽽A减B的部分,留给各个⼦类⾃⼰实现。
正是因为A-B在这⾥没有实现,所以抽象类不允许实例化出来(否则当调⽤到A-B时,⽆法执⾏)。
南航java面试题
南航java面试题一、简介Java,一种面向对象的编程语言,在计算机科学领域得到广泛应用。
作为南航面试的一部分,以下是一些常见的Java面试题。
本文将逐一介绍这些问题,并提供详细的解答。
二、面试题目及解答1. 说说Java的特点以及与其他编程语言的区别。
Java的特点:- 简单性:Java语法相对简单易懂,容易上手。
- 面向对象:Java是一种纯粹的面向对象编程语言,支持封装、继承、多态等面向对象的特性。
- 跨平台性:Java程序可以在不同的操作系统上运行,这要归功于Java虚拟机(JVM)。
- 健壮性:Java通过垃圾回收机制、异常处理等机制保证程序的稳定性。
- 安全性:Java提供了丰富的安全措施,如访问控制、类型检查等。
- 高性能:Java通过JIT(即时编译器)和面向对象设计,提供了良好的性能。
与其他编程语言的区别:- C/C++:Java相对于C/C++更易学、更安全;Java具有跨平台性,而C/C++需要为不同平台编写不同的代码;Java具有自动垃圾回收机制,而C/C++需要手动管理内存。
- Python:Java比Python更适合大型项目,因为Java有更好的性能和多线程支持;Java需要提前编译,而Python是解释型语言。
- JavaScript:Java是一种后端语言,而JavaScript主要用于前端开发;Java是一种强类型语言,而JavaScript是一种动态类型语言。
2. 请解释Java中的异常处理机制。
Java的异常处理机制通过try-catch-finally语句块来实现。
当程序出现异常时,会抛出一个异常对象,如果这个异常对象没有被捕获,程序将终止执行。
try-catch语句块用于捕获并处理异常。
try块中包含可能会抛出异常的代码,当异常发生时,程序会跳转到与其匹配的catch块进行处理。
catch块中可以指定捕获特定类型的异常,也可以使用通用的Exception 类型来捕获所有异常。
提升代码扩展性的JAVA使用技巧
提升代码扩展性的JAVA使用技巧随着软件开发的不断发展,代码的扩展性成为了一个非常重要的问题。
扩展性好的代码可以方便地进行功能的扩展和修改,而扩展性差的代码则会导致修改困难、代码冗余等问题。
在JAVA开发中,有许多技巧可以帮助我们提升代码的扩展性,本文将介绍一些常用的JAVA使用技巧,希望能对读者有所帮助。
1. 使用接口和抽象类接口和抽象类是JAVA中非常重要的概念,它们能够帮助我们实现代码的解耦和扩展。
通过定义接口和抽象类,我们可以将代码的实现细节与接口分离,从而使得代码更加灵活和可扩展。
在设计类的时候,我们可以首先考虑定义接口或抽象类,然后再进行具体的实现。
2. 使用设计模式设计模式是一种被广泛应用于软件开发中的经验总结,它提供了一套解决特定问题的方案。
在JAVA开发中,有许多常用的设计模式可以帮助我们提升代码的扩展性,例如工厂模式、观察者模式、策略模式等。
通过合理地运用设计模式,我们可以将代码的耦合度降低,从而提高代码的扩展性。
3. 使用泛型泛型是JAVA中的一个重要特性,它可以使得代码更加通用和灵活。
通过使用泛型,我们可以在编译期间对代码进行类型检查,避免了在运行时出现类型转换错误的问题。
同时,泛型还可以提高代码的可读性和可维护性,使得代码更加易于扩展和修改。
4. 使用注解注解是JAVA中的一个重要特性,它可以用来为代码添加元数据信息。
通过使用注解,我们可以在编译期间对代码进行静态检查,从而提高代码的健壮性和可扩展性。
例如,我们可以使用注解来标记某个方法需要进行事务管理,然后通过AOP的方式来实现事务管理的功能。
5. 使用反射反射是JAVA中的一个强大特性,它可以在运行时动态地获取和操作类的信息。
通过使用反射,我们可以在不知道类的具体实现的情况下,通过类的名称来创建对象、调用方法等。
反射可以使得代码更加灵活和可扩展,但是由于反射的性能较低,所以在使用反射时需要慎重考虑。
6. 使用单元测试单元测试是软件开发中非常重要的一环,它可以帮助我们验证代码的正确性和可扩展性。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
从语法定义层面看abstract class和interface
在语法层面,Java语言对于abstract class和interface给出了不同的定义方式,下面以定义一个名为Demo的抽象类为例来说明这种不同。
使用abstract class的方式定义Demo抽象类的方式如下:
上面主要从语法定义和编程的角度论述了abstract class和interface的区别,这些层面的区别是比较低层次的、非本质的。本小节将从另一个层面:abstract class和interface所反映出的设计理念,来分析一下二者的区别。作者认为,从这个层面进行分析才能理解二者概念的本质所在。
abstract class Demo {
abstract void method1();
abstract void method2();
…
}
使用interface的方式定义Demo抽象类的方式如下:
interface Demo {
void method1();
}
其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。
如果现在要求Door还要具有报警的功能。我们该如何设计针对该例子的类结构呢(在本例中,主要是为了展示abstract class和interface反映在设计理念上的区别,其他方面无关的问题都做了简化或者忽略)?下面将罗列出可能的解决方案,并从设计理念层面对这些不同的方案进行分析。
从编程的角度来看,abstract class和interface都可以用来实现"design by contract"的思想。但是在具体的使用上面还是有一些区别的。
首先,abstract class在Java语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface。也许,这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。
考虑这样一个例子,假设在我们的问题领域中有一个关于Door的抽象概念,该Door具有执行两个动作open和close,此时我们可以通过abstract class或者interface来定义一个表示该抽象概念的类型,定义方式分别如下所示:
使用abstract class方式定义Door:
理解抽象类
abstract class和interface在Java语言中都是用来进行抽象类(本文中的抽象类并非从abstract class翻译而来,它表示的是一个抽象体,而abstract class为Java语言中用于定义抽象类的一种方法,请读者注意区分)定义的,那么什么是抽象类,使用抽象类能为我们带来什么好处呢?
abstract class Door {
abstract void open();
abstract void close();
}
使用interface方式定义Door:
interface Door {
void open();
void close();
解决方案一:
简单的在Door的定义中增加一个alarm方法,如下:
abstract class Door {
abstract void open();
abstract void close();
abstract void alarm();
}
抽象类与接口的问题:
abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制,正是由于这两种机制的存在,才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性,甚至可以相互替换,因此很多开发者在进行抽象类定义时对于abstract class和interface的选择显得比较随意。其实,两者之间还是有很大的区别的,对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析,试图给开发者提供一个在二者之间进行选择的依据。
其次,在abstract class的定义中,我们可以赋予方法的默认行为。但是在interface的定义中,方法却不能拥有默认行为,为了绕过这个限制,必须使用委托,但是这会 增加一些复杂性,有时会造成很大的麻烦。
在抽象类中不能定义默认行为还存在另一个比较严重的问题,那就是可能会造成维护上的麻烦。因为如果后来想修改类的界面(一般通过abstract class或者interface来表示)以适应新的情况(比如,添加新的方法或者给已用的方法中添加新的参数)时,就会非常的麻烦,可能要花费很多的时间(对于派生类很多的情况,尤为如此)。但是如果界面是通过abstract class来实现的,那么可能就只需要修改定义在abstract class中的默认行为就可以了。
前面已经提到过,abstarct class在Java语言中体现了一种继承关系,要想使得继承关系合理,父类和派生类之间必须存在"is a"关系,即父类和派生类在概念本质上应该是相同的(参考文献〔3〕中有关于"is a"关系的大篇幅深入的论述,有兴趣的读者可以参考)。对于interface 来说则不然,并不要求interface的实现者和interface定义在概念本质上是一致的,仅仅是实现了interface定义的契约而已。为了使论述便于理解,下面将通过一个简单的实例进行说明。
void method2();
…
}
在abstract class方式中,Demo可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface方式的实现中,Demo只能够有静态的不能被修改的数据成员(也就是必须是static final的,不过在interface中一般不定义数据成员),所有的成员方法都是abstract的。从某种意义上说,interface是一种特殊形式的abstract class。
在面向对象领域,抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述,但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类,而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体,因此它可以是不允许修改的;同时,通过从这个抽象体派生,也可扩展此模块的行为功能。熟悉OCP的读者一定知道,为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle),抽象类是其中的关键所在。
abstract class Door {
abstract void open();
abstract void close();
}
interface Alarm {
void alarm();
}
class AlarmDoor extends Door implements Alarm {
}
这种方法违反了面向对象设计中的一个核心原则ISP(Interface Segregation Priciple),在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变(比如:修改alarm方法的参数)而改变,反之依然。
如果我们对于问题领域的理解是:AlarmDoor在概念本质上是Door,同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢?前面已经说过,abstract class在Java语言中表示一种继承关系,而继承关系在本质上是"is a"关系。所以对于Door这个概念,我们应该使用abstarct class方式来定义。另外,AlarmDoor又具有报警功能,说明它又能够完成报警概念中定义的行为,所以报警概念可以通过interface方式定义。如下所示:
或者
interface Door {
void open();
void close();
void alarm();
}
那么具有报警功能的AlarmDoor的定义方式如下:
class AlarmDoor extends Door {
void open() { … }
同样,如果不能在抽象类中定义默认行为,就会导致同样的方法实现出现在该抽象类的每一个派生类中,违反了"one rule,one place"原则,造成代码重复,同样不利于以后的维护。因此,在abstract class和interface间进行选择时要非常的小心。
从设计理念层面看abstract class和interface
void open() { … }
void close() { … }
void alarm() { … }
}
这种实现方式基本上能够明确的反映出我们对于问题领域的理解,正确的揭示我们的设计意图。其实abstract class表示的是"is a"关系,interface表示的是"like a"关系,大家在选择时可以作为一个依据,当然这是建立在对问题领域的理解上的,比如:如果我们认为AlarmDoor在概念本质上是报警器,同时又具有Door的功能,那么上述的定义方式就要反过来了
在面向对象的概念中,我们知道所有的对象都是通过类来描绘的,但是反过来却不是这样。并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。比如:如果我们进行一个图形编辑软件的开发,就会发现问题领域存在着圆、三角形这样一些具体概念,它们是不同的,但是它们又都属于形状这样一个概念,形状这个概念在问题领域是不存在的,它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念,所以用以表征抽象案二: