关于java抽象方法

Posted 2023-04-04

下面是抽象方法声明时采用的语法：abstract void f();
如果从一个抽象类继承，而且想生成新类型的一个对象，就必须为基础类中的所有抽象方法提供方法定义。如果不这样做（完全可以选择不做），则衍生类也会是抽象的，而且编译器会强迫我们用abstract 关键字标志那个类的“抽象”本质。即使不包括任何abstract 方法，亦可将一个类声明成“抽象类”。如果一个类没必要拥有任何抽象方法，而且我们想禁止那个类的所有实例，这种能力就会显得非常有用。
在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。比如：如果我们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。在面向对象领域，抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允许修改的；同时，通过从这个抽象体派生，也可扩展此模块的行为功能。熟悉OCP的读者一定知道，为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)，抽象类是其中的关键所在。 参考技术A 1、抽象方法实际上可以理解为是一种虚方法，可以被重载，不同之处是抽象方法必须被子类重载，而虚方法可以被重载，也可以不被重载，意思就是说抽象方法是基类设计者认为该类必须实现的功能，例如设计一个人的类时，吃饭就必须被重载，因为如果不吃饭人就会死，但是可能有人吃米饭，有人吃馒头；
2、delphi中除了虚方法还有一种称之为动态方法的方法，印象里好像跟虚方法类似，只是一个先绑定还是候绑定的问题。 参考技术B 在类中没有方法体的方法，就是抽象方法。
含有抽象方法的类，即为抽象类。
如果一个子类没有实现抽象基类中所有的抽象方法，则子类也成为一个抽象类。
我们可以将一个没有任何抽象方法的类声明为abstract，避免由这个类产生任何的对象。
构造方法、静态方法、私有方法、final方法不能被声明为抽象的方法。

接口中所有的方法都是public abstract。
在接口中声明方法时，不能使用native、static 、final 、synchronized 、private 、protected等修饰符。
和public类一样，public接口也必须定义在与接口同名的文件中。
接口中可以有数据成员，这些成员默认都是public static final。
Math.java
interface Math

double PI=3.1415926;

class Arithmetic implements Math

double roundArea(double radius)

return PI*radius*radius;


class Student

public static void main(String[] args)

Arithmetic a=new Arithmetic();
System.out.println(a.roundArea(3));
System.out.println(Math.PI); //ok
System.out.println(Arithmetic.PI); //ok
System.out.println(a.PI); //ok



一个接口可以继承自另一个接口。
Java中不允许类的多继承，但允许接口的多继承。
Sofa.java
interface Sittable

void sit();

interface Lie

void sleep();

interface Chair extends Sittable


interface Sofa extends Sittable, Lie



Sofa.java
//在继承类的同时，实现多个接口
interface Sittable

void sit();

interface Lie

void sleep();

interface HealthCare

void massage();

class Chair implements Sittable

public void sit();

class Sofa extends Chair implements Lie, HealthCare

public void sleep();
public void massage();
参考技术C 在我们所有乐器（Instrument）例子中，基础类Instrument内的方法都肯定是“伪”方法。若去调用这些方法，就会出现错误。那是由于Instrument的意图是为从它衍生出去的所有类都创建一个通用接口。
之所以要建立这个通用接口，唯一的原因就是它能为不同的子类型作出不同的表示。它为我们建立了一种基本形式，使我们能定义在所有衍生类里“通用”的一些东西。为阐述这个观念，另一个方法是把Instrument称为“抽象基础类”（简称“抽象类”）。若想通过该通用接口处理一系列类，就需要创建一个抽象类。对所有与基础类声明的签名相符的衍生类方法，都可以通过动态绑定机制进行调用（然而，正如上一节指出的那样，如果方法名与基础类相同，但自变量或参数不同，就会出现过载现象，那或许并非我们所愿意的）。
如果有一个象Instrument那样的抽象类，那个类的对象几乎肯定没有什么意义。换言之，Instrument的作用仅仅是表达接口，而不是表达一些具体的实施细节。所以创建一个Instrument对象是没有意义的，而且我们通常都应禁止用户那样做。为达到这个目的，可令Instrument内的所有方法都显示出错消息。但这样做会延迟信息到运行期，并要求在用户那一面进行彻底、可靠的测试。无论如何，最好的方法都是在编译期间捕捉到问题。
针对这个问题，Java专门提供了一种机制，名为“抽象方法”。它属于一种不完整的方法，只含有一个声明，没有方法主体。下面是抽象方法声明时采用的语法：
abstract void X();
包含了抽象方法的一个类叫作“抽象类”。如果一个类里包含了一个或多个抽象方法，类就必须指定成abstract（抽象）。否则，编译器会向我们报告一条出错消息。
若一个抽象类是不完整的，那么一旦有人试图生成那个类的一个对象，编译器又会采取什么行动呢？由于不能安全地为一个抽象类创建属于它的对象，所以会从编译器那里获得一条出错提示。通过这种方法，编译器可保证抽象类的“纯洁性”，我们不必担心会误用它。
如果从一个抽象类继承，而且想生成新类型的一个对象，就必须为基础类中的所有抽象方法提供方法定义。如果不这样做（完全可以选择不做），则衍生类也会是抽象的，而且编译器会强迫我们用abstract关键字标志那个类的“抽象”本质。
即使不包括任何abstract方法，亦可将一个类声明成“抽象类”。如果一个类没必要拥有任何抽象方法，而且我们想禁止那个类的所有实例，这种能力就会显得非常有用。
Instrument类可很轻松地转换成一个抽象类。只有其中一部分方法会变成抽象方法，因为使一个类抽象以后，并不会强迫我们将它的所有方法都同时变成抽象。

java 中 关于抽象类和接口的一些知识

　　　　　　【抽象类】

1、概念：包含一个抽象方法的类就是抽象类。

2、抽象方法：声明而未被实现的方法。

3、抽象类被子类继承时，子类必须重写抽象类中的所有抽象方法。

4、抽象类关键字：abstract

5、定义格式：

　  abstract class   className  {

　　属性

 　  方法

       抽象方法

}

6、重点：抽象类不能直接实例化，必须通过子类进行实例化。书写子类 使用extends 关键字时 需要注意要重写父抽象类的所有抽象方法。

（解读：简单来说，抽象类就是不能直接实例的类。

 例如    形状类，我们不能直接实例化形状类，因为不能说直接实例一个  形状  对象。   这样的类就是抽象 形状类

  但是可以说实例化一个圆形类，继承自(extends)  抽象的形状父类。）

-----------------------------------------------------------------------------------------------------------------------------------------------------

举例：

创建一个抽样类。

abstract  class  ABC{

private String name;

public void  tell(){

System.out.println("我是ABC类中的tell方法");

}

public  abstract void say();

}　　　　　　　　　　　　　　　　　　　　　　　　　　

// 如上则是一个标准的抽样类，类名是ABC，属性有String 类型的 name,   其中包含一个普通的tell()方法，和一个抽样方法  say();

// 因为该类包含一个抽象的 say(); 方法  所以 ABC类是一个抽样类。

//可以尝试去掉ABC类前的abstract 关键字。 编译器会报错。因为包含抽象方法的类是抽样类才行，必须声明abstract 关键字。

 

主方法：

　　public class Demo{

　　　　public static void main(String [ ] args)　　{

　　　　// ABC  abc=new ABC();   

　　　　// 编译器报错，因为抽样类不能实例化。 必须创建子类 继承抽象类，并重写抽象方法。以下将书写重写格式。

　　　　　

　　　　　Son s=new Son();

　　　　　s.tell();

　　　　　s.say();

　　　　//直接使用抽象类的子类Son类，调用tell和say方法。

　}

}

创建子类：

　class  Son  extends ABC{

　　pulic void say(){

　　System.out.println("我是Son类的say方法。 重写了ABC抽象类的say方法");

　　}

}

 

-----------------------------------------------------------------------------------------------------------------------------------------------------

【接口】

1、接口：可以理解为一种特殊类。

（java中 只能单继承 ，也就是说一个或多个子类只能继承 extends一个父类 。

   但是   接口是可以被类给多  实现 implements  的。）

2、接口中： 全部由 全局常量和公共的抽象方法。

3、全局常量：  public static final  int MAX=100;   即全局公共的、静态的、不可更改的。

3、接口的实现也必须通过子类实现。 但此时使用关键字 implements，而不是extends ，且一个类可以使用多个implements关键字， 也就是可以多实现。

4、格式：

interface  Name{

　　全局常量

　　抽象方法

}

 

-----------------------------------------------------------------------------------------------------------------------------------------------------

interface  Inter1{

　　public static final  int MAX=100;    //全局常量

　　public abstract void tell();　　　　//静态方法

}

interface Inter2{

　　public abstract void say();

}

class A implements Inter1,Inter2{                                 //接口的多实现。不像子类只能继承一个父类一样。

　　public void tell(){

　　}

}

 

　　public class Demo{

　　　　public static void main(String [ ] args)　　{

　　　　 A a=new A();             

　　　　a.tell();

　　　　a.say();

　　　　System.out.println(Inter.MAX);

　　}

}

-----------------------------------------------------------------------------------------------------------------------------------------------------

重点: 

1、一个类可以同时继承某一个类和实现某些接口。

即： class A extends ABC implements Inter1,Inter2{

     //书写对应接口的抽象方法  的重写。

}

2、接口不能继承抽象类。 但是可以使用extends关键字继承多个接口。

即：Inter  extends Inter1,Inter2{

}                          //接口的多继承

接口可以多继承， 但类不能多继承。

 

 

抽象类和接口的区别

• 1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
• 2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的（全局常量）。
• 3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
• 4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。