抽象类与接口的区别

合集下载

抽象方法和接口的区别

抽象方法和接口的区别

抽象方法和接口的区别
抽象方法和接口是面向对象编程中的两个重要概念,它们之间存在以下区别:
1. 定义方式:抽象方法是在抽象类中定义的方法,使用关键字abstract修饰,没有方法体;接口是由方法签名组成的集合,使用关键字interface进行定义。

2. 继承关系:抽象方法通过继承的方式实现子类对该方法的重写,一个类只能继承一个抽象类;接口通过实现的方式实现对接口中方法的定义,一个类可以实现多个接口。

3. 状态:抽象方法可以有非抽象方法和属性,并可以包含构造函数,一个抽象类可以有自己的状态;接口只能包含抽象方法和常量,没有自己的状态。

4. 实例化:抽象方法不能直接被实例化,需要通过子类继承和重写来实现;接口不能被实例化,但可以通过实现类实例化,使用接口引用来调用实现类的方法。

5. 使用场景:抽象方法适用于需要有默认实现和状态的情况,可以用作基类从而提供一些共享的实现;接口适用于需要强制与不同类之间进行某种逻辑上的约束的情况。

总结来说,抽象方法提供了一种非强制性的基类实现,而接口则是一种强制性的实现规范。

抽象方法更强调类的继承和共享实现,接口更强调类的多态和实现规范。

金航数码面试

金航数码面试
jsp:forward:在本容器内跳转 。 跳转后,地址栏地址不变 。效率高。跳转后立即结束本页的内容。
sendRedirect:在容器之间的跳转,跳转后地址栏地址为跳转后的地址,效率较低。
通常采用jsp:forward方式跳转。
25、类变量的初始化
答:在Java中类变量在局部中一定要初始化,因为局部变量会覆盖全局变量,否则会报错:变量未初始化。全局变量则可以不初始化,而到具体的内部方法或其他的类成员中初始化。
9) 数据校验的对比:Struts 1支持在ActionForm重写validate方法中手动校验,或者通过整合Commons alidator框架来完成数据校验。Struts 2支持通过重写validate方法进行校验,也支持整合XWork校验框架进行校验。
10) Action执行控制的对比:Struts 1支持每一个模块对应一个请求处理(即生命周期的概念),但是模块中的所有Action必须共享相同的生命周期。Struts 2支持通过拦截器堆栈(Interceptor Stacks)为每一个Action创建不同的生命周期。开发者可以根据需要创建相应堆栈,从而和不同的Action一起使用。
3) Servlet依赖方面的对比:Struts 1 Action依赖于Servlet API,因为Struts 1 Action的execute方法中有HttpServletRequest和HttpServletResponse方法。Struts 2 Action不再依赖于Servlet API,从而允许Action脱离Web容器运行,从而降低了测试Action的难度。 当然,如果Action需要直接访问HttpServletRequest和HttpServletResponse参数,Struts 2 Action仍然可以访问它们。但是,大部分时候,Action都无需直接访问HttpServetRequest和HttpServletResponse,从而给开发者更多灵活的选择。

接口和抽象类的区别和作用(功能、用途、好处)

接口和抽象类的区别和作用(功能、用途、好处)

接⼝和抽象类的区别和作⽤(功能、⽤途、好处)接⼝:抽象类和接⼝亲兄弟,但是有嫡出庶出的区别总结了4点接⼝存在的意义:1、重要性:在Java语⾔中, abstract class 和interface 是⽀持抽象类定义的两种机制。

正是由于这两种机制的存在,才赋予了Java强⼤的⾯向对象能⼒。

2、简单、规范性:如果⼀个项⽬⽐较庞⼤,那么就需要⼀个能理清所有业务的架构师来定义⼀些主要的接⼝,这些接⼝不仅告诉开发⼈员你需要实现那些业务,⽽且也将命名规范限制住了(防⽌⼀些开发⼈员随便命名导致别的程序员⽆法看明⽩ 3、维护、拓展性:⽐如你要做⼀个画板程序,其中⾥⾯有⼀个⾯板类,主要负责绘画功能,然后你就这样定义了这个类。

可是在不久将来,你突然发现这个类满⾜不了你了,然后你⼜要重新设计这个类,更糟糕是你可能要放弃这个类,那么其他地⽅可能有引⽤他,这样修改起来很⿇烦。

如果你⼀开始定义⼀个接⼝,把绘制功能放在接⼝⾥,然后定义类时实现这个接⼝,然后你只要⽤这个接⼝去引⽤实现它的类就⾏了,以后要换的话只不过是引⽤另⼀个类⽽已,这样就达到维护、拓展的⽅便性。

4、安全、严密性:接⼝是实现软件松耦合的重要⼿段,它描叙了系统对外的所有服务,⽽不涉及任何具体的实现细节。

这样就⽐较安全、严密⼀些(⼀般软件服务商考虑的⽐较多)。

那么什么是接⼝呢?接⼝是⼀种能⼒1:接⼝的命名规则与类型不同。

如果修饰符是public。

则该接⼝在整个项⽬中可见,如果省略修饰符则该接⼝只能在该包可见2:接⼝中可以定义常量,不能定义变量,接⼝中的属性都会⾃动⽤public static final修饰,即接⼝中的属性都是全局静态常量,接⼝中的常量必须在定义时指定初始值3:接⼝中所有的⽅法抽象⽅法。

接⼝中的⽅法都会⾃动⽤public abstract修饰。

即接⼝中只有全局抽象⽅法,4:和抽象类⼀样,接⼝不能被实例化,接⼝中不能有狗构造⽅法5:接⼝之间可以通过extends 实现继承关系,⼀个接⼝可以继承多个接⼝。

接口和抽象类的区别和联系

接口和抽象类的区别和联系

接⼝和抽象类的区别和联系1、抽象类抽象类不能创建实例,它只能作为⽗类被继承。

抽象类是从多个具体类中抽象出来的⽗类,它具有更⾼层次的抽象。

从多个具有相同特征的类中抽象出⼀个抽象类,以这个抽象类作为其⼦类的模板,从⽽避免了⼦类的随意性。

(1) 抽象⽅法只作声明,⽽不包含实现,可以看成是没有实现体的虚⽅法(2) 抽象类不能被实例化(3) 抽象类可以但不是必须有抽象属性和抽象⽅法,但是⼀旦有了抽象⽅法,就⼀定要把这个类声明为抽象类(4) 具体派⽣类必须覆盖基类的抽象⽅法(5) 抽象派⽣类可以覆盖基类的抽象⽅法,也可以不覆盖。

如果不覆盖,则其具体派⽣类必须覆盖它们2、接⼝(1) 接⼝不能被实例化(2) 接⼝只能包含⽅法声明(3) 接⼝的成员包括⽅法、属性、索引器、事件(4) 接⼝中不能包含常量、字段(域)、构造函数、析构函数、静态成员3、接⼝和抽象类的区别(1)抽象类可以有构造⽅法,接⼝中不能有构造⽅法。

(2)抽象类中可以有普通成员变量,接⼝中没有普通成员变量(3)抽象类中可以包含静态⽅法,接⼝中不能包含静态⽅法(4)⼀个类可以实现多个接⼝,但只能继承⼀个抽象类。

(5)接⼝可以被多重实现,抽象类只能被单⼀继承(6)如果抽象类实现接⼝,则可以把接⼝中⽅法映射到抽象类中作为抽象⽅法⽽不必实现,⽽在抽象类的⼦类中实现接⼝中⽅法4、接⼝和抽象类的共同点(1) 都可以被继承(2) 都不能被实例化(3) 都可以包含⽅法声明(4) 派⽣类必须实现未实现的⽅法5、为什么要写接⼝或抽象类1. 减少代码的书写(代码重载)2. 提⾼了代码的可维护性和扩展性。

3. 在团队合作中,代码的规范性6、抽象类和接⼝都差不多,什么时候选择使⽤接⼝1. 在当前类族中不是必须的(例如Tager需要⽽Rabbit不需要)的⽅法时2. 不同类族的多个类需要实现同样的⽅法时(接⼝)。

C++中抽象类和接口的区别

C++中抽象类和接口的区别

C++中抽象类和接⼝的区别抽象类(abstract class)和接⼝(interface)的概念是⾯向对象设计中常⽤的概念, 也是⽐较容易混淆的概念. 在这⾥, 我提出⼀种区分它们的思路:1. 如果⼀个类B在语法上继承(extend)了类A, 那么在语义上类B是⼀个类A.2. 如果⼀个类B在语法上实现了(implement)接⼝I, 那么类B遵从接⼝I制定的协议.------------------------------------------------------------------------------------------------使⽤abstract class的根本原因在于, ⼈们希望通过这样的⽅式, 表现不同层次的抽象.⽽interface的本质是⼀套协议. 在程序设计的发展中, ⼈们⼜发现接⼝可以⽤来表⽰对⾏为的抽象, 不过, 这只是interface的⼀种⽤法不是其本质. ------------------------------------------------------------------------------------------------理论结合实际才是最好的学习⽅式, 不过在这⾥, 我只想举⼀些我见到过关于接⼝使⽤的反⾯教材:1. 在接⼝中包含数据成员. 这⼏乎肯定是错的, 因为协议是规范是标准, 不应该跟具体实现有任何牵连, 也不应该给具体实现造成任何负担.2. C++中 delete 掉⼀个接⼝. 例如:class IInterface(){Public:Virtual ~IInterface(){};…}Class ClassImpl : public IInterface{…}Int main(){IInterface* pInterface = new ClassImpl();…delete pInterface;}从语法的⾓度和语⾔⾃⾝的⾓度来看, 这是可⾏的, ⽽且只要将接⼝的析构函数设置为virtual, 就能避免内存泄漏.但我要说, 这不是语法和语⾔的问题, ⽽是从根本上就错了.因为接⼝是⼀套协议, ⼀套规范, 并不是实现.Delete ⼀个接⼝的代码, 到底想要表达什么样的语义? 如果⼀段代码从语义上都说不通, 就不应该出现在程序中.------------------------------------------------------------------------------------------------------------------------要在C++中表现接⼝的概念, ⼀种做法是这样:class IInterface{public:virtual void DoSomething() = 0;// 不应当有析构函数, 因为从语义上说, 接⼝是不能delete的.}如果要delete, 只能delete⼀个类的实例:Class A{Public:Virtual ~A();Public:Virtual void DoSomething() = 0;}Class B : public A{…}Int main(){A* pA = new B();…Delete pA;}我们可以这样做, 因为pA对应的是⼀个实例, 我们可以在A这⼀层将其销毁.先举个例⼦,⽅便⼤家理解,然后从例⼦中抽象概括出结理论。

java abstract方法继承

java abstract方法继承

Java Abstract方法继承一、什么是Abstract方法Abstract方法是Java中一种特殊的方法,它只有声明而没有具体的实现。

在定义一个Abstract方法时,需要使用abstract关键字修饰方法,并且该方法所在的类必须是抽象类或者接口。

Abstract方法的定义如下:public abstract void methodName();二、抽象类与接口抽象类(Abstract Class)是一个不能被实例化的类,它可以包含Abstract方法和具体的方法实现。

抽象类通过使用abstract关键字进行修饰。

接口(Interface)是一种纯抽象的类,它只包含Abstract方法和常量。

接口定义方法时,默认使用public abstract修饰。

抽象类和接口的区别如下: - 抽象类可以有构造方法,而接口不能有构造方法。

- 类只能继承一个抽象类,但可以实现多个接口。

- 抽象类可以有成员变量,而接口只能有常量。

- 接口中的方法默认是public的,而抽象类中的方法可以有不同的访问修饰符。

三、Abstract方法的继承方式Abstract方法在继承关系中有以下几种继承方式:子类覆盖方法、子类重载方法、子类继续声明抽象方法。

1. 子类覆盖方法当一个子类继承自一个抽象类或者实现一个接口时,它必须实现抽象类或接口中的所有Abstract方法。

子类通过覆盖Abstract方法来提供具体的实现。

例如,有一个抽象类Animal,其中定义了一个Abstract方法eat(),如下所示:public abstract void eat();}如果一个子类Dog继承自Animal,则必须实现eat()方法:public class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃骨头");}}2. 子类重载方法除了覆盖Abstract方法,子类还可以重载Abstract方法。

面向对象程序设计中的接口和抽象类的对比研究

面向对象程序设计中的接口和抽象类的对比研究

面向对象程序设计中的接口和抽象类的对比研究在面向对象程序设计当中,接口(Interface)和抽象类(Abstract Class)是常用的两种机制,它们旨在提高程序的复用性、可扩展性和可维护性。

接口和抽象类虽然都可以实现多态性,但是它们的实现方式和应用场景却存在一些区别。

本文将针对接口和抽象类进行对比研究,分别从概念、实现、使用、优缺点等方面进行探讨。

一、概念接口是一组抽象方法的集合,其中的方法都是公共的,不提供具体的实现。

接口的主要目的是定义整个系统的服务,让接口与接口之间的实现独立开来。

接口的定义方式为 interface,接口的成员默认为 public static final,可以省略这些修饰符。

抽象类也是一种不完整的类,不提供具体的实现,只是定义出一些抽象方法。

其主要目的在于为子类提供一个通用的类型,并可以通过继承的方式来实现具体的方法。

抽象类的定义方式为 abstract class,其中可以同时定义具体的方法和抽象的方法,在子类中必须实现抽象方法才能进行实例化。

二、实现接口和抽象类的实现方式存在较大的差别。

接口的实现方式为类实现接口,一个类可以实现多个接口,接口之间是独立任意的,通过关键字 implements 来实现。

接口的方法必须在实现类中进行实现,实现类中需要完全实现接口中的所有方法,否则这个类仍是一个抽象类。

抽象类的实现方式为子类继承抽象类,并对抽象方法进行具体实现。

抽象类可以有自己的属性和具体实现的方法,同时可以定义抽象方法。

抽象类的子类需要在继承抽象类的同时必须实现抽象方法,否则仍是一个抽象类。

三、使用接口和抽象类在使用上也有不同的特点。

接口主要用于解耦合,实现系统的松散耦合。

通过定义接口和实现类之间的关系,可以方便地进行接口的解耦合。

接口的定义时一种规范,通过这些规范来确保不同类之间的互操作性以及符合代码复合原则。

抽象类主要用于继承,提供了一个通用的类型,并让子类去具体实现这个通用类型所需要的方法。

面向对象程序设计中的抽象类与接口研究

面向对象程序设计中的抽象类与接口研究

面向对象程序设计中的抽象类与接口研究随着软件开发技术的不断发展,面向对象程序设计成为了当今十分流行和广泛使用的一种编程思想。

而在面向对象程序设计中,抽象类与接口则是两个非常重要的概念。

本文将对抽象类与接口进行深入研究。

一、什么是抽象类?抽象类是一种不能被实例化的类,它的主要作用是为其子类提供具有实现细节的基类。

抽象类一般用于描述某一类事物的抽象概念,而非具体的某一个事物。

在Java中,我们可以使用abstract关键字来定义一个抽象类。

抽象类中可以包含抽象方法和非抽象方法,抽象方法则是一种没有具体实现的方法,而非抽象方法则是有具体实现的方法。

abstract class Animal {String name;public void setName(String name) { = name;}public abstract void eat();}上述代码定义了一个名为Animal的抽象类和一个抽象方法eat()。

由于抽象方法没有具体实现,因此不需要在抽象类中对它进行实现。

二、什么是接口?接口是一种到处可见的类型,它定义了一组方法的规范,但并不提供对这些方法的具体实现。

接口只是指定了一组标准,由实现该接口的类来提供具体实现。

在Java中,我们可以使用interface关键字来定义一个接口。

接口中只能包含常量和抽象方法,常量必须使用public static final修饰符进行修饰,抽象方法则必须使用public abstract修饰符进行修饰。

interface Animal {public static final int NUM_LEGS = 4;public abstract void makeSound();}上述代码定义了一个名为Animal的接口和一个抽象方法makeSound()。

由于接口中的抽象方法没有具体实现,因此我们必须在实现该接口的类中对它进行实现。

三、抽象类与接口的区别虽然抽象类与接口都是用于描述某一类事物的抽象概念,但二者之间还是存在一些区别的,具体表现如下:1. 实现方式不同抽象类是一种类,是通过继承来实现的,而接口是一种接口,是通过实现来实现的。

接口和抽象类的区别是什么?Java接口中声明的变量默认都是final的。(为什么)

接口和抽象类的区别是什么?Java接口中声明的变量默认都是final的。(为什么)

接⼝和抽象类的区别是什么?Java接⼝中声明的变量默认都是final的。

(为什么)接⼝和抽象类的区别是什么?参考答案Java提供和⽀持创建抽象类和接⼝。

它们的实现有共同点,不同点在于:接⼝中所有的⽅法隐含的都是抽象的。

⽽抽象类则可以同时包含抽象和⾮抽象的⽅法。

类可以实现很多个接⼝,但是只能继承⼀个抽象类类可以不实现抽象类和接⼝声明的所有⽅法,当然,在这种情况下,类也必须得声明成是抽象的。

抽象类可以在不提供接⼝⽅法实现的情况下实现接⼝。

?Java接⼝中声明的变量默认都是final的。

(为什么)抽象类可以包含⾮final的变量。

Java接⼝中的成员函数默认是public的。

抽象类的成员函数可以是private,protected或者是public。

接⼝是绝对抽象的,不可以被实例化。

抽象类也不可以被实例化,但是,如果它包含main⽅法的话是可以被调⽤的。

也可以参考JDK8中抽象类和接⼝的区别问题1.Java接⼝中声明的变量默认都是final的。

(为什么)interface中的变量是当作常量来设计的,它不但是final,⽽且还是public static的,也即interface中的变量⼀定是public static final的,换⾔之,这个变量实际上已经是个“常量”。

解答:java接⼝中成员变量必须是final类型的原因如下:1. 接⼝中的数据对所有实现类只有⼀份,所以是static2.要使实现类为了向上转型成功,所以必须是final的.这个举例⼦很好理解.⽐如接⼝A,A有变量value.实现类A1,A2,可以向上转型.假如代码中有⼀句:A a=null;a=....(2)实际实现类System.out.println(a.value);利⽤向上转型,可以得到接⼝a的值,在第2步中,我不关你是实现类A1,还是new A2(),通过转型,我们可以得到正确的值.要是类中可以更改,我们得不到⼀个统⼀的值,接⼝也没有了意义.假设接⼝的成员变量x不是final的,且默认有值。

抽象类和接口的区别

抽象类和接口的区别

抽象类和接口的区别对于面向对象编程来说,抽象是它的一大特征之一。

在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类。

这两者有太多相似的地方,又有太多不同的地方。

下面是为大家准备的抽象类和接口的区别,希望大家喜欢!抽象类和接口的相关知识一.抽象类在了解抽象类之前,先来了解一下抽象方法。

抽象方法是一种特殊的方法:它只有声明,而没有具体的实现。

抽象方法的声明格式为:1abstract void fun();抽象方法必须用abstract关键字进行修饰。

如果一个类含有抽象方法,则称这个类为抽象类,抽象类必须在类前用abstract关键字修饰。

因为抽象类中含有无具体实现的方法,所以不能用抽象类创建对象。

下面要注意一个问题:在《JAVA编程思想》一书中,将抽象类定义为“包含抽象方法的类”,但是后面发现如果一个类不包含抽象方法,只是用abstract修饰的话也是抽象类。

也就是说抽象类不一定必须含有抽象方法。

个人觉得这个属于钻牛角尖的问题吧,因为如果一个抽象类不包含任何抽象方法,为何还要设计为抽象类?所以暂且记住这个概念吧,不必去深究为什么。

123[public] abstract class ClassName {abstract void fun();}从这里可以看出,抽象类就是为了继承而存在的,如果你定义了一个抽象类,却不去继承它,那么等于白白创建了这个抽象类,因为你不能用它来做任何事情。

对于一个父类,如果它的某个方法在父类中实现出来没有任何意义,必须根据子类的实际需求来进行不同的实现,那么就可以将这个方法声明为abstract方法,此时这个类也就成为abstract类了。

包含抽象方法的类称为抽象类,但并不意味着抽象类中只能有抽象方法,它和普通类一样,同样可以拥有成员变量和普通的成员方法。

注意,抽象类和普通类的主要有三点区别:1)抽象方法必须为public或者protected(因为如果为private,则不能被子类继承,子类便无法实现该方法),缺省情况下默认为public。

抽象类与接口的区别

抽象类与接口的区别

抽象类与接口的区别1.语法层面上的区别1.抽象类可以提供成员方法的实现细节,而接口中只能存在public abstract 方法;2.抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是public static final 类型的;3.接口中不能含有静态代码块以及静态方法,而抽象类可以有静态代码块和静态方法;4.一个类只能继承一个抽象类,而一个类却可以实现多个接口。

2.设计层面上的区别2.1抽象类是对一种事物的抽象,即对类抽象,而接口是对行为的抽象。

抽象类是对整个类整体进行抽象,包括属性、行为,但是接口却是对类局部(行为)进行抽象。

举个简单的例子,飞机和鸟是不同类的事物,但是它们都有一个共性,就是都会飞。

Class airplane Class BirdInterface Fly{void fly();}从这里可以看出,继承是一个"是不是"的关系,而接口实现则是"有没有"的关系。

如果一个类继承了某个抽象类,则子类必定是抽象类的种类,而接口实现则是有没有、具备不具备的关系,比如鸟是否能飞(或者是否具备飞行这个特点),能飞行则可以实现这个接口,不能飞行就不实现这个接口。

2.2设计层面不同,抽象类作为很多子类的父类,它是一种模板式设计。

而接口是一种行为规范,它是一种辐射式设计。

什么是模板式设计?如果它们的公共部分需要改动,则只需要改动模板A 就可以了,不需要重新对ppt B 和ppt C 进行改动。

什么是辐射式设计?Abstract class PPT 模板Class PPTA Class PPTBInterface class 警报器{void 警报();}Class DoorClass Elevator比如某个电梯和门都装了某种报警器,一旦要更新报警器,就必须全部更新。

也就是说对于抽象类,如果需要添加新的方法,可以直接在抽象类中添加具体的实现,子类可以不进行变更;而对于接口则不行,如果接口进行了变更,则所有实现这个接口的类都必须进行相应的改动。

接口和抽象类的使用,实现公司员工工资发放

接口和抽象类的使用,实现公司员工工资发放

接⼝和抽象类的使⽤,实现公司员⼯⼯资发放 接⼝与抽象类很相似,都可以实现类的多态,不过如果要在组件的所有实现间提供通⽤的已实现的功能,则使⽤抽象类。

抽象类可以提供已实现的成员。

因此,可以⽤抽象类确保特定数量的相同功能,抽象类允许部分实现类,⽽接⼝不包含任何成员的实现。

抽象类主要应⽤与关系密切的对象,⽽接⼝最适合为不相关的类提供通⽤功能。

下⾯我们就⽤抽象类和接⼝实现⼀下简单的部门⼯资发放问题。

⾸先先说⼀下需求分析,如下所⽰: /**某公司有多个部门和职位,不同类型员⼯之间九三⼯资⽅法不同*经理:固定⽉薪+奖⾦* 销售员;固定⽉薪+销售提成(⽉薪+销售额*提成率)*⼯⼈:固定⽉薪+加班费*员⼯⼯资需要缴纳个⼈所得税* <2000 ⽆* >=2000||<=2500 所得税 5%* >2500||<=4000 所得税 >=2000||<=2500 5% &&>2500 10%* >4000 所得税 >=2000||<2500 5% &&>2500<=4000 10% >4000 15%* HR发放薪⽔*/ 明⽩了需求之后我们就开始写⼀个接⼝了,代码如下1///<summary>2///薪⽔接⼝3///</summary>4interface ISalarySystem5 {6decimal Earnings();//计算薪⽔78string SelfInform();//显⽰员⼯信息9 }然后我们就写⼀个抽象类,⽤来实现提供的⼀组成员如name ,salary,enterdate,所得税的计算⽅法等。

提供抽象成员的Type属性。

⽬的是为了提供通⽤不变的⼀些功能。

代码如下:1///<summary>2///从业员⼯抽象类3///</summary>4public abstract class Employee5 {6private string name;7private decimal salary;8private DateTime entryadte;910public Employee()11 {12//13 }1415public Employee(string name, decimal salary, int year, int month, int day)16 { = name;18this.Salary = salary;19 Entryadte = new DateTime(year, month, day);20 }2122public string Name23 {24get25 {26return name;27 }2829set30 {31 name = value;32 }33 }3435public decimal Salary36 {37get38 {39return salary;4142set43 {44 salary = value;45 }46 }4748public DateTime Entryadte49 {50get51 {52return entryadte;53 }5455set56 {57 entryadte = value;58 }59 }6061public abstract string Type62 {63get;64 }6566public static double Tax(decimal earnings)67 {68decimal taxSal = earnings;69double Taxes = 0;70if (taxSal > 4000)71 {72 Taxes = Convert.ToDouble(taxSal - 4000) * 0.15;73 taxSal = 4000;74 }7576if (taxSal > 2500)77 {78 Taxes += Convert.ToDouble(taxSal - 2500) * 0.10;79 taxSal = 2500;80 }81if (taxSal > 2000)82 {83 Taxes += Convert.ToDouble(taxSal - 2000) * 0.05;84 taxSal = 2000;85 }8687return Taxes;88 }89 }下⾯就开始写各个成员类了.1//经理类2class Manager:Employee,ISalarySystem3 {4private decimal bonus;5public Manager(string name, decimal salary, int year, int month, int day, decimal bonus)6 :base(name,salary,year,month,day)7 {8this.Bonus = bonus;9 }1011public decimal Bonus12 {13get14 {15return bonus;16 }1718set19 {20 bonus = value;21 }22 }2324public override string Type25 {26get27 {28return"经理";29 }30 }31public decimal Earnings()33return Salary + bonus;34 }35public string SelfInform()36 {37return"姓名:" + Name +""+ Type + "" + "⼊职时间:" + Entryadte.ToShortDateString();38 }39 }1//销售员类2public class SalesMan:Employee,ISalarySystem3 {4private decimal commission;//提成5private float rate;6public SalesMan(string name, decimal salary, int year, int month, int day, decimal commission, float rate)7 : base(name,salary,year,month,day)8 {mission = commission;10this.Rate = rate;11 }1213public decimal Commission14 {15get16 {17return commission;18 }1920set21 {22 commission = value;23 }24 }2526public float Rate27 {28get29 {30return rate;31 }3233set34 {35 rate = value;36 }37 }3839public override string Type40 {41get42 {43return"销售员";44 }45 }46public decimal Earnings()47 {48return Salary + commission * (decimal)rate / 100;49 }5051public string SelfInform()52 {53//throw new NotImplementedException();54return"姓名:" + Name + "" + Type + "" + "⼊职时间:" + Entryadte.ToShortDateString()55 +"销售额:"+commission;56 }57 }1//⼯⼈2public class Worker : Employee, ISalarySystem3 {4private decimal overtimepay;5public Worker(string name, decimal salary, int year, int month, int day,decimal overtimepay)6 :base(name,salary,year,month,day)7 {8 Name = name;9 Salary = salary;10this.Overtimepay = overtimepay;11 }1213public decimal Overtimepay14 {15get16 {17return overtimepay;1920set21 {22 overtimepay = value;23 }24 }2526public override string Type27 {28get29 {30//throw new NotImplementedException();31return"⼯⼈";32 }33 }34public decimal Earnings()35 {36//throw new NotImplementedException();37return Salary + overtimepay;38 }3940public string SelfInform()41 {42//throw new NotImplementedException();43return"姓名:" + Name + "" + Type + "" + "⼊职时间:" + Entryadte.ToShortDateString()44 +"加班⼯资:"+overtimepay.ToString();45 }46 }1//HR 通过实现计算⼯资接⼝让后只要读取员⼯的的类型就可以发放⼯资2class HR3 {4private ISalarySystem member;5public HR()6 { }78internal ISalarySystem Member9 {10get11 {12return member;13 }1415set16 {17 member = value;18 }19 }2021public HR(ISalarySystem member)22 {23this.Member = member;24 }2526public decimal SetEarnings()27 {28decimal earnings = this.member.Earnings();29return earnings;30 }3132public string ReadInform()33 {34string inform = this.member.SelfInform();35return inform;36 }37 }所有的成员都实现接⼝和抽象类,每个成员⼜都有⾃⼰的属性,这样他们之间就可以实现多态了.最后我们就来测试⼀下实现的效果.static void Main(string[] args){string output=null;HR[] salType = new HR[3];Manager amanager = new Manager("李锦钧", 5000.00M, 2010, 6, 15, 800.00M);SalesMan asalesman = new SalesMan("lijinjun", 1800.00M, 2012, 4, 13, 800.00M, 20);Worker aworker = new Worker("⾦俊", 1500.00M, 2007, 5, 14, 80);HR Obj1 = new HR(amanager);HR Obj2 = new HR(asalesman);HR Obj3 = new HR(aworker);salType[1] = Obj2;salType[2] = Obj3;foreach(HR obj in salType){output += obj.ReadInform() + "⼯资:" + obj.SetEarnings().ToString() + "所得税:" + Employee.Tax(obj.SetEarnings()) + "\n"; }Console.Write(""+output);}以上就是接⼝和抽象类的使⽤案例,其中有什么不对的地⽅希望⼤家指正,不过就不要直接喷了。

抽象类与接口之间的区别

抽象类与接口之间的区别
谈抽象类与接口的区别之一
一、抽象类:
抽象类是特殊的类,只是不能被实例化;除此以外,具有类的其他特性;重要的是抽象类可以包括抽象方法,这是普通 类所不能的。抽象方法只能声明于抽象类中,且不包含任何实现,派生类必须覆盖它们。另外,抽象类可以派生自一个 抽象类,可以覆盖基类的抽象方法也可以不覆盖,如果不覆盖,则其派生类必须覆盖它们。
比如:如果我们进行一个图形编辑软件的开发,就会发现问题领域存在着圆、三角形 这样一些具体概念,它们是不同 的,但是它们又都属于形状这样一个概念,形状这个概念在问题领域是不存在的,它就是一个抽象概念。正是因为抽象 的概念在问题 领域没有对应的具体概念,所以用以表征抽象概念的抽象类是不能够实例化的。
在面向对象领域,抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行 为的抽象描述,但是这组行为却 能够有任意个可能的具体实现方式。这个抽象描述就是抽象类,而这一组任意个可能的具体实现则表现为所有可能的派 生类。模块可 以操作一个抽象体。由于模块依赖于一个固定的抽象体,因此它可以是不允许修改的;同时,通过从这 个抽象体派生,也可扩展此模块的行为功能。熟悉 OCP 的读 者一定知道,为了能够实现面向对象设计的一个最核心的 原则 OCP(Open-Closed Principle),抽象类是其中的关键所在。
同样,如果不能在抽象类中定义默认行为,就会导致同样的方法实现出现在该抽象类 的每一个派生类中,违反了"one
rule,one place"原则,造成代码重复,同样不利于以后的维护。因此,在 abstract class 和 interface 间进行选择
时要非常的小心。 三、从设计理念层面看 abstract class 和 interface
二、从语法定义层面看 abstract class 和 interface

接口和抽象类有什么区别

接口和抽象类有什么区别

接⼝和抽象类有什么区别他们都不能实例化对象,都可以包含抽象⽅法,⽽且抽象⽅法必须被继承的类全部实现。

区别:1、抽象类和接⼝都不能直接实例化,如果要实例化,抽象类变量必须指向实现所有抽象⽅法的⼦类对象,接⼝变量必须指向实现所有接⼝⽅法的类对象。

2、抽象类要被⼦类继承,接⼝要被类实现。

3、接⼝只能做⽅法申明,抽象类中可以做⽅法申明,也可以做⽅法实现4、接⼝⾥定义的变量只能是公共的静态的常量,抽象类中的变量是普通变量。

5、抽象类⾥的抽象⽅法必须全部被⼦类所实现,如果⼦类不能全部实现⽗类抽象⽅法,那么该⼦类只能是抽象类。

同样,⼀个实现接⼝的时候,如不能全部实现接⼝⽅法,那么该类也只能为抽象类。

6、抽象⽅法只能申明,不能实现,接⼝是设计的结果,抽象类是重构的结果7、抽象类⾥可以没有抽象⽅法8、如果⼀个类⾥有抽象⽅法,那么这个类只能是抽象类9、抽象⽅法要被实现,所以不能是静态的,也不能是私有的。

10、接⼝可继承接⼝,并可多继承接⼝,但类只能单根继承。

参数抽象类接⼝默认的⽅法实现它可以有默认的⽅法实现接⼝完全是抽象的。

它根本不存在⽅法的实现实现⼦类使⽤extends关键字来继承抽象类。

如果⼦类不是抽象类的话,它需要提供抽象类中所有声明的⽅法的实现。

⼦类使⽤关键字implements来实现接⼝。

它需要提供接⼝中所有声明的⽅法的实现构造器抽象类可以有构造器接⼝不能有构造器与正常Java类的区别除了你不能实例化抽象类之外,它和普通Java类没有任何区别接⼝是完全不同的类型访问修饰符抽象⽅法可以有public、protected和default这些修饰符接⼝⽅法默认修饰符是public。

你不可以使⽤其它修饰符。

main⽅法抽象⽅法可以有main⽅法并且我们可以运⾏它接⼝没有main⽅法,因此我们不能运⾏它。

(java8以后接⼝可以有default和static⽅法,所以可以运⾏main⽅法)多继承抽象⽅法可以继承⼀个类和实现多个接⼝接⼝只可以继承⼀个或多个其它接⼝速度它⽐接⼝速度要快接⼝是稍微有点慢的,因为它需要时间去寻找在类中实现的⽅法。

interface和abstract的区别

interface和abstract的区别

interface和abstract的区别抽象类(abstract)含有abstract修饰符的class即为抽象类,abstract 类不能创建的实例对象。

含有abstract⽅法的类必须定义为abstract class,abstract class类中的⽅法不必是抽象的。

abstract class类中定义抽象⽅法必须在具体(Concrete)⼦类中实现,所以,不能有抽象构造⽅法或抽象静态⽅法。

如果的⼦类没有实现抽象⽗类中的所有抽象⽅法,那么⼦类也必须定义为abstract类型。

接⼝(interface)interface 可以说成是抽象类的⼀种特例,接⼝中的所有⽅法都必须是抽象的。

接⼝中的⽅法定义默认为public abstract类型,接⼝中的成员变量类型默认为public static final。

下⾯⽐较⼀下两者的语法区别:1.抽象类可以有构造⽅法,接⼝中不能有构造⽅法。

2.抽象类中可以有普通成员变量,接⼝中没有普通成员变量3.抽象类中可以包含⾮抽象的普通⽅法,接⼝中的所有⽅法必须都是抽象的,不能有⾮抽象的普通⽅法。

4. 抽象类中的抽象⽅法的访问类型可以是public,protected和(默认类型,虽然eclipse下不报错,但应该也不⾏),但接⼝中的抽象⽅法只能是public类型的,并且默认即为public abstract类型。

5. 抽象类中可以包含静态⽅法,接⼝中不能包含静态⽅法6. 抽象类和接⼝中都可以包含静态成员变量,抽象类中的静态成员变量的访问类型可以任意,但接⼝中定义的变量只能是public static final 类型,并且默认即为public static final类型。

7. ⼀个类可以实现多个接⼝,但只能继承⼀个抽象类。

下⾯接着再说说两者在应⽤上的区别:接⼝更多的是在系统架构设计⽅法发挥作⽤,主要⽤于定义模块之间的通信契约。

⽽抽象类在代码实现⽅⾯发挥作⽤,可以实现代码的重⽤.例如,模板⽅法设计模式是抽象类的⼀个典型应⽤,假设某个项⽬的所有Servlet类都要⽤相同的⽅式进⾏权限判断、记录访问⽇志和处理异常,那么就可以定义⼀个抽象的基类,让所有的Servlet都继承这个抽象基类,在抽象基类的service⽅法中完成权限判断、记录访问⽇志和处理异常的代码,在各个⼦类中只是完成各⾃的业务逻辑代码,伪代码如下:import java.io.IOException;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;public abstract class BaseServlet extends HttpServlet {public final void service(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {//记录访问⽇志// 进⾏权限判断if (具有权限) {try {doService(request, response);} catch (Exception e) {记录异常信息}}}// 注意访问权限定义成protected,显得既专业,⼜严谨,因为它是专门给⼦类⽤的protected abstract void doService(HttpServletRequest request,HttpServletResponse response) throws IOException, ServletException;}⼦类:import javax.servlet.ServletException;import javax.servlet.http.HttpServletResponse;import java.io.IOException;public class MyServlet1 extends BaseServlet {protected void doService(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {本Servlet只处理的具体业务逻辑代码}}⽗类⽅法中间的某段代码不确定,留给⼦类⼲,就⽤模板⽅法设计模式。

类与接口的区别和详解

类与接口的区别和详解

类与接⼝的区别和详解
接⼝和抽象类的区别和联系
共同点:
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中抽象类和接口

1. 抽象类
• 抽象类: ---本身不能被实例化对象,只能作为其它类的超类 ---使用abstract修饰 • 定义: abstract class 类名{ 属性定义; 方法定义;=抽象方法+非抽象方法 } 引出:抽象方法定义 abstract 返回类型 方法名()
;
抽象类定义:
abstract class Figure{
class Triangle extends Figure{ double area() {........} }
抽象类举例:
abstract class Figure { private String shape; public Figure(String shape) { this.shape=shape;} public abstract double area(); public void print() { System.out.println(this.shape+”面积为:”+this.area()); } }
public double area() { if(boo) { double p=(sideA+sideB+sideC)/2.0; double area=Math.sqrt(p*(p-sideA)*(psideB)*(p-sideC)) ; return area; } else { System.out.println(“不是一个三角形,不 能计 算面积"); return 0; } return 0; } }//end of class Triangle
private String shape; //属性定义 Figure(String shape) //构造方法定义 {this.shape=shape;} public abstract double area(); //抽象方法定义 public void print() //实例方法定义 {System.out.println(this.area());}
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
abstract class Demo{
abstract void method1();
abstract void method2();


使用interface的方式定义Demo抽象类的方式如下:
javoid method1();
void method2();
从编程的角度来看,abstract class和interface都可以用来实现"design by contract"的思想。但是在具体的使用上面还是有一些区别的。
首先,abstract class在Java语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface。也许,这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。
在面向对象的概念中,我们知道所有的对象都是通过类来描绘的,但是反过来却不是这样。并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。
比如:如果我们进行一个图形编辑软件的开发,就会发现问题领域存在着圆、三角形这样一些具体概念,它们是不同的,但是它们又都属于形状这样一个概念,形状这个概念在问题领域是不存在的,它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念,所以用以表征抽象概念的抽象类是不能够实例化的。
在面向对象领域,抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述,但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类,而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体,因此它可以是不允许修改的;同时,通过从这个抽象体派生,也可扩展此模块的行为功能。熟悉OCP的读者一定知道,为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle),抽象类是其中的关键所在。
java代码
或者
java代码
interface Door {
void open();
void close();
void alarm();
}
那么具有报警功能的AlarmDoor的定义方式如下:
java代码
class AlarmDoor extends Door {
void open() { … }
void close() { … }
上面主要从语法定义和编程的角度论述了abstract class和interface的区别,这些层面的区别是比较低层次的、非本质的。本文将从另一个层面:abstract class和interface所反映出的设计理念,来分析一下二者的区别。作者认为,从这个层面进行分析才能理解二者概念的本质所在。
前面已经提到过,abstarct class在Java语言中体现了一种继承关系,要想使得继承关系合理,父类和派生类之间必须存在"is a"关系,即父类和派生类在概念本质上应该是相同的。对于interface来说则不然,并不要求interface的实现者和interface定义在概念本质上是一致的,仅仅是实现了interface定义的契约而已。为了使论述便于理解,下面将通过一个简单的实例进行说明。
解决方案二:
既然open、close和alarm属于两个不同的概念,根据ISP原则应该把它们分别定义在代表这两个概念的抽象类中。定义方式有:这两个概念都使用abstract class方式定义;两个概念都使用interface方式定义;一个概念使用abstract class方式定义,另一个概念使用interface方式定义。

}
在abstract class方式中,Demo可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface方式的实现中,Demo只能够有静态的不能被修改的数据成员(也就是必须是static final的,不过在interface中一般不定义数据成员),所有的成员方法都是abstract的。从某种意义上说,interface是一种特殊形式的abstract class。
abstract class和interface是Java语言中的两种定义抽象类的方式,它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理,因为它们表现了概念间的不同的关系(虽然都能够实现需求的功能)。这其实也是语言的一种的惯用法。
如果我们对于问题领域的理解是:AlarmDoor在概念本质上是Door,同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢?前面已经说过,abstract class在Java语言中表示一种继承关系,而继承关系在本质上是"is a"关系。所以对于Door这个概念,我们应该使用abstarct class方式来定义。另外,AlarmDoor又具有报警功能,说明它又能够完成报警概念中定义的行为,所以报警概念可以通过interface方式定义。如下所示:
同样,如果不能在抽象类中定义默认行为,就会导致同样的方法实现出现在该抽象类的每一个派生类中,违反了"one rule,one place"原则,造成代码重复,同样不利于以后的维护。因此,在abstract class和interface间进行选择时要非常的小心。
三、从设计理念层面看abstract class和interface
java代码
abstract class Door {
abstract void open();
abstract void close();
}
java代码
interface Alarm {
void alarm();
}
java代码
class AlarmDoor extends Door implements Alarm {
void open() { … }
void close() { … }
void alarm() { … }
}
这种实现方式基本上能够明确的反映出我们对于问题领域的理解,正确的揭示我们的设计意图。其实abstract class表示的是"is a"关系,interface表示的是"like a"关系,大家在选择时可以作为一个依据,当然这是建立在对问题领域的理解上的,比如:如果我们认为AlarmDoor在概念本质上是报警器,同时又具有Door的功能,那么上述的定义方式就要反过来了。
抽象类与接口的区别
abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制,正是由于这两种机制的存在,才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性,甚至可以相互替换,因此很多开发者在进行抽象类定义时对于abstract class和interface的选择显得比较随意。
abstract class Door {
abstract void open();
abstract void close();
}
使用interface方式定义Door:
java代码
interface Door {
void open();
void close();
}
其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。
二、从语法定义层面看abstract class和interface
在语法层面,Java语言对于abstract class和interface给出了不同的定义方式,下面以定义一个名为Demo的抽象类为例来说明这种不同。使用abstract class的方式定义Demo抽象类的方式如下:
java代码
其次,在abstract class的定义中,我们可以赋予方法的默认行为。但是在interface的定义中,方法却不能拥有默认行为,为了绕过这个限制,必须使用委托,但是这会增加一些复杂性,有时会造成很大的麻烦。
在抽象类中不能定义默认行为还存在另一个比较严重的问题,那就是可能会造成维护上的麻烦。因为如果后来想修改类的界面(一般通过abstract class或者interface来表示)以适应新的情况(比如,添加新的方法或者给已用的方法中添加新的参数)时,就会非常的麻烦,可能要花费很多的时间(对于派生类很多的情况,尤为如此)。但是如果界面是通过abstract class来实现的,那么可能就只需要修改定义在abstract class中的默认行为就可以了。
1、我们可能没有理解清楚问题领域,AlarmDoor在概念本质上到底是Door还是报警器?
2、如果我们对于问题领域的理解没有问题,比如:我们通过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的,那么我们在实现时就没有能够正确的揭示我们的设计意图,因为在这两个概念的定义上(均使用interface方式定义)反映不出上述含义。
其实,两者之间还是有很大的区别的,对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析,试图给开发者提供一个在二者之间进行选择的依据。
一、理解抽象类
abstract class和interface在Java语言中都是用来进行抽象类(本文中的抽象类并非从abstract class翻译而来,它表示的是一个抽象体,而abstract class为Java语言中用于定义抽象类的一种方法,请读者注意区分)定义的,那么什么是抽象类,使用抽象类能为我们带来什么好处呢?
相关文档
最新文档