抽象类与接口

合集下载

Java抽象类、接口能否有构造方法

Java抽象类、接口能否有构造方法

Java抽象类、接⼝能否有构造⽅法
构造⽅法作⽤:对类进⾏初始化
结论:Java中接⼝不能有构造⽅法,抽象类可以有构造⽅法
原因:
⼀、接⼝可以理解为“完全抽象类”,接⼝中的⽅法默认被 public 、abstract 修饰,不能有⽅法体,所以接⼝中不能有构造⽅法。

⼆、抽象类可以有构造⽅法
1. 抽象类中可以有抽象⽅法和普通⽅法,
2. 普通⽅法可以有⽅法体,构造⽅法是没有返回值的⽅法,在new实例化对象时被调⽤。

所以抽象类可以有构造⽅法。

补充:
类会有⼀个默认⽆参构造⽅法,就算编码中没有写这个⽆参构造⽅法,在编译时也会被加到编译⽂件中。

抽象类也是类的⼀种,所以就算没写构造⽅法,抽象类也是有这个默认⽆参构造⽅法的。

C#中抽象类与接口的分析与比较

C#中抽象类与接口的分析与比较



l l ∞ W r i t e L i n e (“ 食 肉动物 只吃 肉!”) ; }
C t a ss n 0 、 h r ( “ j s : 槲 ㈨㈣ j
{p u b l i c O V e ) ‘ r i d e w) i d F o o d H a b i t s 0
成员都 隐式地 具有p u b l i c 访 问权限 。类 可 以从单个类继承但 可以实现多 个接 口,实现接 口的类 需要实现接 口的所 有成员 。接 口可以从现有接 口 中继承 ,一个实现接 口的类也实现它 的继承接 口的基类接 口。 虽然 不能创建接 口对象 ,但 可 以声明接 口变量 ,接 口变量必须指 向 个实现 了接 口的类的对象 。如下例 中的T y p e U s e [ ] t = n e w T y p e U s e[ 4 ] : 声 明了一个接 口类型 的数组 ,它包含4 个接 口类 型的变 量。以下语句 声明 了类 的对 象,并实例化 ,接 口变量 ( 接 口数组元素 )指 向类 的对 象。 [ e I I C  ̄ , e、t e a l=n e w r (“ 李静 ”,3 O , “ 语文 ”) :
基类 ,抽象类不 能实例 化 ,必须在继承 中实现 。抽 象类 中可 以包含非抽 口。一个接 口定义一个协定 ,实现接 口的类或 结构必须遵守其 协定 。接 象成 员。抽象类 的 目的是提供一个合 适的基类 ,以派生 其他的类 。使 用 口可 以从 多个 基接 口继承 ,而类或结构可 以实现多个接 口中。接 口声 明 抽 象类的好处之 一是,当要求组 建新 版本时 ,可根据 需要将附加方法 添 可 以声 明零个 或多个成 员,接 口的成员必须 是方法、属性 、事件或索 引 加到基类 。如 下例 : 器 。接 口不 以包 含常数 、字段 、运算符 、实例 构造函数 、析构 函数或类 抽象类应用实例: 型 ,也不 能包 含任何种类 的静态成员 。接 口本 身不提供它所 定义的成员 a b s t I I a cI Cl a s s r l r i j 1 j 的实现 ,接 口只指定实现 该接 口的类或接 口必须提供 的成 员。所有接 口

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

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

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

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

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

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

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

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

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

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

如果修饰符是public。

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

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

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

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方法。

Java抽象类与接口-笔记

Java抽象类与接口-笔记

抽象类与接口-笔记关键字:接口抽象类,接口与类是一个层次的概念,是java中极其重要的概念抽象类是从多个类中抽象出来的公共模板,提供子类均具有的功能。

接口是从多个类中抽象出来的规范,体现的是规范和实现分离的原则,同时也有效的解决Java单重继承的缺陷。

*******普通方法与抽象方法的不同*******普通方法需要有访问修饰符,返回类型,方法名,还要有一个方法体,抽象方法也有访问修饰符,返回类型,方法名,但是它还多了一个修饰符——abstract,同时没有方法体,也就是说抽象方法没有实现。

普通方法与抽象方法的区别:1,普通方法必须要有实现体,抽象方法不能有实现体,抽象方法要用abstract修饰符来修饰。

********普通类与抽象类的区别*********普通类:要有访问修饰符,class关键字和类名。

抽象类:在普通类的基础之上,还多了一个abstract修饰符。

在使用的时候抽象类与普通类也不一样:普通类:可以通过new关键字实例化。

抽象类:不能使用new关键字来实例化。

**********抽象类********************抽象类:是一个不能实例化的类,它可以具有抽象方法或者普通方法。

定义抽象类的语法与定义普通类类似,只是多了一个关键字abstract。

注意:抽象类中可以定义抽象方法,也可以拥有普通方法,而普通类当中只能定义普通方法。

********对比抽象类与接口***************抽象类用abstract修饰符来定义,而且抽象类中可以有抽象方法,也可以有普通方法。

**接口是使用interface关键字来定义,关键字后面是接口名。

注意::定义接口的时候不再使用class关键字。

同时,接口只能拥有抽象方法。

***从定义就可以看出抽象类与接口的区别:1,抽象类使用abstract声明,接口使用interface声明。

2,抽象类除了抽象方法,还可以有普通方法,而接口中只能有抽象方法。

JAVA继承、抽象类、接口

JAVA继承、抽象类、接口

JA V A继承、抽象类、接口编辑人:星辰·樱联系QQ:838826112一.类的继承通过继承可以实现代码的复用,被继承的类称为父类或超类(superclass),由继承而得到的类称为子类(subclass)。

一个父类可以拥有多个子类,但一个类只能有一个直接父类,这是因为JA V A语言中不支多重继承。

子类继承父类的成员变量和成员方法,同时可以修改父类的成员变量或重写父类的方法,还可以添加新的成员变量或成员方法。

JA V A语言中有一个名为ng.Object的特殊类,所有的类都是直接或间接地继承该类而得到的。

1.子类的创建类的继承是通过extends关键字来实现的,在定义类时若使用ectends关键字指出新定义类的父类,就是在两个类之间建立了继承关系。

新定义的类称为子类,它可以从父类那里继承所有非private的成员作为自己的成员。

子类的创建:* 格式:class SubClass extends SuperClass* {* .* .* .* }2.调用父类中特定的构造方法在没有明确地指定构造方法时,子类还是会先调用父类中没有参数的构造方法,以便进行初始化的操作。

在子类的构造方法中可以通过super()来调用父类特定的构造方法。

例://以Person作为父类,创建学生子类Student,并在子类中调用父类里某指定的构造方法。

class Person2{private String name;private int age;public Person2()//定义Person2类的无参构造方法{System.out.println("调用了Person2类的无参构造方法");}public Person2(String name,int age)//定义Person2类的有参构造方法{System.out.println("调用了Person2类的有参构造方法");=name;this.age=age;}public void show(){System.out.println("姓名:"+name+" 年龄:"+age);}}class Student2extends Person2//定义继承自Person2类的子类Student2{private String department;public Student2()//定义Student2类的无参构造方法{System.out.println("调用了学生类的无参构造方法Student2()");}public Student2(String name,int age,String dep)//定义Student2类的有参构造方法{super(name,age);//调用父类的胡参构造方法department=dep;System.out.println("我是"+department+"学生");System.out.println("调用了学生类的有参构造方法Student2(String name,int age,String dep)");}}public class App8_2 {public static void main(String[] args){Student2 stu1=new Student2();//创建对象,并调用无参构造方法Student2 stu2=new Student2("李小四",23,"信息系");//创建对象并调用有参构造方法stu1.show();stu2.show();}}/*在子类中访问你类的构造方法,其格式为super(参数列表)。

C#中接口与抽象类的应用辨析

C#中接口与抽象类的应用辨析
{i t t it a; n s r n vl t a;

其 中 , 了 i t fc 除 n e ae和接 口名 称 , 它 都 是可 选 项 。 接 fr 其 而 口 内容主 要 是 接 口的各 项 成 员 的 声 明 。每个 成 员 都不 包 括 具
p bi C mbr {t tOv 10 l u l Nu e( s r :a : c ) a : =
题 , 时保 证 多 重继 承 带 给程 序 员 的诸 多 好 处 , 抖 出 了接 口 同 C提 概 念 ,通 过 接 口实 现 多 重继 承 。接 口定义 类 要 实现 的 一 系列 们 。而 这种 特 性 与 抽 象 类 又极 为 相似 。 1接 口的概 念
C noeWre ie” 行 rS t) 法 重 置 初始 值 为 O o sl . i Ln (执 t e e(方 及
关键 词 :接 口 抽 象 类
中图分类号 :T 3 P9
文献标识码 :A
文章编号 :10 —9 3 2 1 ) 2020 0 737 ( 0 0 0 -6 —2
20 0 0年 9月 , C E MA 为 c 定 义 了 一个 Mi oot 议标 c sf建 r 准 , 而 使 C 成 为微 软 .E 从 撑 N T平 台上 量 身定 做 的 开发 语 言 。 萍 c 的 简单 、 全 、 向对 象 等特 征 , 安 面 使其 迅 速 成 为 目前 市场 上 开 发 软 件 流 行 的编 程 语 言 c 中类 的单 一继 承 使 其较 C + 言 +语 更 稳 定 。C 不支 持多 重 继 承 ,但 客观 世 界 多重 继 承 的情 况 又 撑

实现接 口的方法必须声明为 pbi, u l 且必须与接口中定义 c 样。下面通过一个范例介绍如何实现接 口及接 口的应用。

什么是抽象类什么是接口两者有什么区别?如何使用它

什么是抽象类什么是接口两者有什么区别?如何使用它

什么是抽象类什么是接⼝两者有什么区别?如何使⽤它⼀、抽象类:抽象类是特殊的类,只是不能被实例化;除此以外,具有类的其他特性;重要的是抽象类可以包括抽象⽅法,这是普通类所不能的。

抽象⽅法只能声明于抽象类中,且不包含任何实现,派⽣类必须覆盖它们。

另外,抽象类可以派⽣⾃⼀个抽象类,可以覆盖基类的抽象⽅法也可以不覆盖,如果不覆盖,则其派⽣类必须覆盖它们。

⼆、接⼝:接⼝是引⽤类型的,类似于类,和抽象类的相似之处有三点:1、不能实例化;2、包含未实现的⽅法声明;3、派⽣类必须实现未实现的⽅法,抽象类是抽象⽅法,接⼝则是所有成员(不仅是⽅法包括其他成员);另外,接⼝有如下特性:接⼝除了可以包含⽅法之外,还可以包含属性、索引器、事件,⽽且这些成员都被定义为公有的。

除此之外,不能包含任何其他的成员,例如:常量、域、构造函数、析构函数、静态成员。

⼀个类可以直接继承多个接⼝,但只能直接继承⼀个类(包括抽象类)。

三、抽象类和接⼝的区别:1.类是对对象的抽象,可以把抽象类理解为把类当作对象,抽象成的类叫做抽象类.⽽接⼝只是⼀个⾏为的规范或规定,微软的⾃定义接⼝总是后带able字段,证明其是表述⼀类类“我能做。

”.抽象类更多的是定义在⼀系列紧密相关的类间,⽽接⼝⼤多数是关系疏松但都实现某⼀功能的类中.2.接⼝基本上不具备继承的任何具体特点,它仅仅承诺了能够调⽤的⽅法;3.⼀个类⼀次可以实现若⼲个接⼝,但是只能扩展⼀个⽗类4.接⼝可以⽤于⽀持回调,⽽继承并不具备这个特点.5.抽象类不能被密封。

6.抽象类实现的具体⽅法默认为虚的,但实现接⼝的类中的接⼝⽅法却默认为⾮虚的,当然您也可以声明为虚的.7.(接⼝)与⾮抽象类类似,抽象类也必须为在该类的基类列表中列出的接⼝的所有成员提供它⾃⼰的实现。

但是,允许抽象类将接⼝⽅法映射到抽象⽅法上。

8.抽象类实现了oop中的⼀个原则,把可变的与不可变的分离。

抽象类和接⼝就是定义为不可变的,⽽把可变的座位⼦类去实现。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

final和abstract修饰符1 final修饰符使用final修饰符可以修饰类的成员变量、类的成员方法和类。

前面我们知道,用final 修饰成员变量或局部变量,则该变量为常值变量(常量),一旦赋值便不能改变,一般与static 组合定义类常量。

也可以用final修饰成员方法。

如果一个方法使用final修饰,则该方法不能在子类中被覆盖。

例如下面的代码会发生编译错误:class A{final void method(){}}class B extends A{void method(){}}final关键字还可以修饰一个类。

如果一个类使用final修饰,则该类就为最终类(final class),最终类是不能被继承的类。

定义final类的格式为:final class ClassName{//…}下面代码会发生编译错误:final class A{//…}class B extends A{//…}有时为了安全的考虑,防止类被继承,可以在类的定义时使用final修饰符。

在Java的类库中就有一些类声明为final类,如Math类和String类都是final类,它们都不能被继承。

声明为final的类隐含声明了其中的方法都为final方法。

2 abstract修饰符在继承的层次结构中,随着一个个新子类的出现,类变得越来越专门、越具体。

如果从一个子类上溯到父类,类就变得更一般、更通用。

类的设计应该保证父类和子类能够共享特征。

有时将一个类的设计得非常抽象,以至于它没有具体的实例。

前面我们定义了圆的类,假设我们还要设计一个矩形(Rectangle)类和三角形(Triangle)类,这些类也需要定义求周长和面积的方法。

它们具有共同的特征和行为。

这时我们就可以设计一个更一般的类,比如几何形状(GeometricShape)类,来模拟圆、矩形、三角形等。

在该类中定义那些求周长和面积的方法,然后在定义具体形状的类时继承该类并覆盖其中的方法。

由于几何形状不能有一个具体的对象,因此方法的实现需要依赖于具体的形状,这些方法就不能实现,因此要定义为抽象的方法(abstract method)。

抽象方法是只有方法的声明,没有方法的实现,定义抽象方法需要在方法前加上abstract修饰符。

包含抽象方法的类应该定义为抽象类(abstract class),定义抽象类需要的类前加上abstract修饰符。

下面定义的GeometricShape类即为抽象类,其中定义了两个抽象方法。

程序GeometricShape.javapublic abstract class GeometricShape{public int color;public String name;public GeometricShape(){color = 0;name = "shape";}public GeometricShape(int color,String name){this.color = color; = name;}public void setColor(int color){this.color = color;}public int getColor(){return color;}public void setName(String name){ = name;}public String getName(){return name;}public abstract double circum();public abstract double area();}_____________________________________________________________________________▃抽象类不能被实例化,即不能生成抽象类的对象,如下列语句将会产生编译错误:GeometricShape gs=new GeometricShape();可以创建抽象类的子类,抽象类的子类还可以是抽象类。

只有非抽象的子类才能使用new创建该类的对象。

在抽象类中可以定义构造方法,这些构造方法可以在子类的构造方法中调用。

在抽象类中可以定义非抽象的方法。

抽象方法的作用是为所有子类提供一个统一的接口。

对抽象方法只需声明,不需实现,即在声明后用一个分号(;)结束,而不需要用大括号,例如上面类定义的最后两行就声明了两个抽象方法。

抽象类中可以没有抽象方法,但仍然需要被子类继承,才能实例化。

注意因为abstract类必须被继承而final类不能被继承,所以final和abstract 不能在定义类时同时使用。

下面重新定义了Circle类,它继承了GeometricShape类并实现了其中的抽象方法。

程序Circle.javapublic class Circle extends GeometricShape{public double radius;public Circle(){this(1.0,"Circle",255);}public Circle(double radius){super(192,"red");this.radius = radius;}public Circle(double radius,String name,int color){super(color,name);this.radius = radius;}public void setRadius(double radius){this.radius = radius;}public double getRadius(){return radius;}public double circum(){return 2*Math.PI*radius;}public double area(){return Math.PI*radius*radius;}public boolean equals(Circle circle){return this.radius==circle.getRadius();}public String toString(){return "[Circle] radius="+radius;}}_____________________________________________________________________________▃这里定义的Circle类不是抽象类,继承了抽象类。

因此它必须实现抽象类中所有的方法,否则该类也要被定义为抽象类。

再定义一个Rectangle类继承GeometricShape类。

程序RectangleTest.javaclass Rectangle extends GeometricShape{double length;double width;public Rectangle(){this("Rectangle",128,100,50);}public Rectangle(String name,int color){super(name,color);}public Rectangle(double length,double width){super();this.length=length;this.width=width;}public Rectangle(String name,int color,double length,double width){super(name,color);this.length=length;this.width=width;}public void setLength(double length){this.length=length;}public double getLength(){return length;}public double circum(){return 2*length+2*width;}public double area(){return length*width;}}public class RectangleTest{public static void main(String[] args){Rectangle rect=new Rectangle(200,100);System.out.println("Name="+rect.getName());System.out.println("Color="+rect.getColor());System.out.println("The circumference ="+rect.circum());System.out.println("The area ="+rect.area());}}_____________________________________________________________________________▃GeometricShape类及其子类的继承关系如图1所示:图 1 GeometricShape类及其继承关系图接口Java 语言中所有的类都处于一个类层次结构中,除Object类以外,所有的类都只有一个直接超类,即子类与超类之间是单继承的关系,而不允许多重继承。

而现实问题类之间的继承关系往往是多继承的关系,为了实现多重继承,Java 语言通过接口(interface)使得处于不同层次、甚至互不相关的类具有相同的行为。

接口是一个常量和方法的集合,这些方法只有定义没有实现。

接口主要用来实现多重继承。

接口定义了一种可以被类层次中的任何类实现的行为的协议。

1定义接口接口的定义与类的定义类似,包括接口声明和接口体两部分。

1. 接口声明接口声明的一般格式如下:[public] interface InterfaceName [extends SuperInterfaces ]{[public][static][final] type name= value;[public][abstract] returnType methodName([paramlist])[throws ExceptionList];}接口声明使用interface关键字,InterfaceName为接口名。

extends表示该接口继承(扩展)了哪些接口。

一个接口可以继承多个接口。

如果接口使用public修饰,则该接口可以被所有的类使用,否则接口只能被同一个包中的类使用。

相关文档
最新文档