让知识连接你我
投稿赚钱
当前位置: 首页 > 后端开发 > java中的抽象类abstract怎么使用?
  • 101
  • 微信分享

    扫一扫,在手机上查看

java中的抽象类abstract怎么使用?

2019.09.24 10:47 263 浏览 举报

  抽象类简述

  当编辑一个类时,大家通常会为此类界定某些形式,这类形式是用来表述此类的作用实际构建形式,因此这类形式都是实际的形式体。

  可是有的情况下,某些父类仅仅知晓子类应当包括要怎样的形式,可是没法精准知晓子类要怎样构建这类形式。例如一个图表类应当有个求周长的形式,可是有所不同的图表求周长的算法有所不同。那咋办呢?

  解析事情时,察觉了统一性內容,就发生向前提取。会有这种一种独特状况,便是形式作用声明一致,但形式作用行为主体有所不同。因此这时也能够提取,但只提取形式声明,不提取形式行为主体。因此此形式便是一个抽象方法。

  1、案例代码 :

  package com.itheima_01;

  /*

  * abstract: 关键字,用来修饰形式和类

  * 抽象方法:有所不同类的形式是类似,可是详细内容又有所不同,因此大家只可以提取他的声明,并没有实际的形式体,并没有具体步骤体的形式便是抽象方法

  * 抽象类:有抽象方法的类都要是抽象类

  *

  * 留意:一个类拥有了抽象类都要重写他任何的抽象方法 , 不然这些类就得是抽象类

  */

  public class AbstractDemo {
  }
  abstract class Animal1 {
  public abstract void eat();

  // 非抽象方法子类能够不重写

  public void run() {
      }
  }
  class Cat1 extends Animal1 {
    @Override
    public void eat() {
          System.out.println(" 猫吃鱼 ");
  }
  /*public void eat() {
          System.out.println(" 猫吃鱼 ");
          }*/
  }
  abstract class Dog1 extends Animal1 {
  /*public void eat() {
          System.out.println(" 狗吃屎 ");
      }*/
  }

  2 、 抽象类的特征

  抽象类的特征:

  抽象方法只可以在抽象类里边

  抽象类和抽象方法都要被 abstract 修饰

  抽象类不能创建对象(不能实例化)

  抽象类中能够有非抽象的形式

  抽象类和类的关联都是拥有

  一个类拥有了抽象类只要重写任何的抽象方法,只要他自身是抽象类

  案例代码:

  package com.itheima_01;

  /*

  * 抽象类的特征:

  * 抽象方法只可以在抽象类里边

  * 抽象类和抽象方法都要被abstract 修饰

  * 抽象类不能创建对象(不能实例化)

  * 抽象类中能够有非抽象的形式

  * 抽象类和类的关联都是拥有

  * 一个类拥有了抽象类只要重写任何的抽象方法,只要他自身是抽象类

  */

  public class AbstractDemo2 {
      public static void main(String[] args) {
          //Animal a = new Animal();
      }
  }
  abstract class Animal2 {
          public abstract void eat();
          public void run() {
      }
  }
  class Cat2 extends Animal2 {
  @Override
  public void eat() {
      // TODO Auto-generated method stub
      }
  }

  3 、抽象类的成员的特征

  A: 抽象类的成员特征:

  成员变量

  能够有成员变量

  能够有常量

  成员形式

  能够有抽象方法

  能够有非抽象方法

  构造方法

  能够有构造方法的,都要对抽象类的成员变量完成初始化

  案例代码:

  package com.itheima_01;

  /*

  * 抽象类的成员特征:

  * 成员变量

  * 能够有成员变量

  * 能够有常量

  * 成员形式

  * 能够有抽象方法

  *   可以有非抽象方法

  *   构造方法

  *   可以有构造方法的,需要对抽象类的成员变量进行初始化

  *

  * final: 修饰类、成员变量、成员方法

  */

  public class AbstractDemo3 {
  public static void main(String[] args) {
          Dog d = new Dog();
          d.barking();
      }
  }
  abstract class Animal {
      String name = " 哮天犬 ";
      final int num = 10;
  public Animal() {
      System.out.println(" 我是抽象类的构造方法 ");
  }
  public abstract void eat();
      public void run() {}
  }
  class Dog extends Animal {
  public void barking() {
      System.out.println(name);
      System.out.println(num);
  }
  @Override
  public void eat() {
      // TODO Auto-generated method stub
      }
  }

  4 、抽象类的细节

  A: 抽象类关键字 abstract 可以和哪些关键字共存 ?

  1.private :

  私有的方法子类是无法继承到的,也不存在覆盖,而abstract 和 private 一起使用修饰方法, abstract 既要子类去实现这个方法,而 private 修饰子类根本无法得到父类这个方法。互相矛盾。

  2.final:

  抽象类不能和 final 共存 , 因为抽象类自身无法创建对象 , 我们需要通过子类创建对象 , 一旦抽象类使用 final 关键字 , 那么抽象类就没有子类

  抽象方法不能和 final 共存 , 因为抽象方法后期需要被子类重写 , 一旦加 final 无法重写

  3.static:

  抽象方法不能和 static 关键字共存 , 因为一旦加 static 我们就可以通过类名直接访问抽象方法 , 由于抽象方法没有方法体 , 没有任何意义 , 也不允许这样做

  B: 抽象类中是否可以不定义抽象方法 ?

  是可以的,那这个抽象类的存在到底有什么意义呢?不让该类创建对象, 方法可以直接让子类去使用

  C: 抽象类是否有构造函数 ?

  有, 抽象类的构造函数 , 是由子类的 super 语句来调用 , 用于给抽象类中的成员初始化

  用关键字abstract 修饰的方法称为抽象方法。

  对于抽象方法,只允许声明,不允许实现(没有方法体),而且不允许finnal 和 abstract 修饰同一方法或类,也不允许 static 修饰 abstr 方法,即 abstract 方法必须是实列方法。

  abstra 类不能用 new 运算符创建对象

  abstract 类的子类必需重写 abstra 类中的方法

  abstra 类的对象作为上转型对象

  abstract class GirlFriend {
      abstract void speak();
      abstract void cooking();
  }
  class ChinaGirlFriend extends GirlFriend {
      void speak() {
      System.out.println(" 你好 ");
  }
  void cooking() {
      System.out.println(" 水煮鱼 ");
      }
  }
  class AmericanGirlFriend extends GirlFriend {
  void speak() {
      System.out.println("Hello!");
  }
  void cooking() {
      System.out.println("Roast beef");
      }
  }
  class Boy {
      GirlFriend friend;
  void SetGirFriend(GirlFriend f) {
      friend = f;
  }
  void showGirlFriend() {
      friend.speak();
      friend.cooking();
      }
  }
  public class Test {
  public static void main(String[] args) {
          GirlFriend girl = new ChinaGirlFriend(); //girl is Upper  Transition Object
          Boy boy = new Boy();
          boy.SetGirFriend(girl);
          boy.showGirlFriend();
          girl = new AmericanGirlFriend();
          boy.SetGirFriend(girl);
          boy.showGirlFriend();
      }
  }

  面向抽象编程

  在程序设计中我们经常会使用abstra 类,因为它只关心操作,而不在意具体实现细节。

  所谓的面向抽象编程,是指设计某种重要的类时,不让该类面向具体的类,而是面向抽象类。

  import java.awt.*;
  public class Test {
  public static void main(String[] args) {
          double a,b;
          Pillar pillar;
          Geometry bottom=null;
          pillar=new Pillar(bottom,100);
          System.out.println(" 体积 "+pillar.getVolume());
          bottom=new Rectangle(12,22);
          pillar=new Pillar(bottom,58);
          System.out.println(" 体积 "+pillar.getVolume());
          bottom=new Circle(10);
          pillar=new Pillar(bottom,58);
          System.out.println(" 体积 "+pillar.getVolume());
      }
  }
  abstract class Geometry {
      abstract double getArea();
  }
  class  Pillar {
      Geometry bottom;  //bottom is a variable by  the abstract class geometry
      double height;
  Pillar(Geometry bottom, double height) {
      this.bottom = bottom;
      this.height = height;
  }
  public double getVolume() {
  if (bottom == null) {
      System.out.println(" 没有底,无法计算面积! ");
      return  -1;
  }
      return bottom.getArea() * height;  //Bottom can call the getArea method that the subclass overrides
  }
  }
  class Circle extends Geometry {
      double r;
  Circle(double r) {
      this.r = r;
  }
          public double getArea() {
          return (3.14 * 3.14 * r);
      }
  }
  class Rectangle extends Geometry{
      double a, b;
  Rectangle(double a, double b) {
      this.a = a;
      this.b = b;
  }
  double getArea() {
          return a * b;
      }
  }

  为什么使用抽象类

  首先做一个分析如下:

  1 :定义 Dog 类

  有颜色属性和叫的方法

  2 :定义 Bird 类

  有颜色属性和叫的方法

  3 :定义其父类 Animal

  1 :抽取共性颜色属性和叫的方法

  1 :颜色的属性可以使用默认初始化值。

  2 :叫的方法在父类中如何定义?

  1 :狗是旺旺

  2 :鸟是叽叽喳喳

  3 :可以将父类的方法定义为狗叫让鸟继承父类重写叫的方法

  1 :鸟怎么确定是否要重写父类方法。

  2 :不重写,编译和运行都没有问题,只是执行鸟叫的方法就会出现狗叫

  4 :父类的方法很难确定。

  上方描述代码如下:

  function(){   //外汇返佣:http://www.kaifx.cn/
  class Animal {
      String color;
  void shout(){
      // 如何定义呢 ? 是旺旺还是叽叽喳喳 ?
      }
  }
  class Dog extends Animal {
  void shout() {
          System.out.println(" 旺旺 ");
      }
  }
  class Bird extends Animal {
  void shout() {
          System.out.println(" 叽叽喳喳 ");
      }
  }

  那么此时使用abstract 能够解决这个问题 。

  4 :抽象类

  1 :当描述一个类的时候,如果不能确定功能函数如何定义,那么该类就可以定义为抽象类,功能函数应该描述为抽象函数。

  5 :抽象类的实现方式

  1 :定义 animal 类

  1 :定义叫的方法,无法确定方法体,不写方法体

  1 : public void shout (); 编译失败

  2 :根据提示在 shout 的方法加入 abstract 修饰

  1 :编译失败,有新的提示

  3 :根据提示将类加入 abstract 修饰

  1 :编译通过

  abstract class Animal {
      String color;
      abstract void shout();
  }
  class Dog extends Animal {
  void shout() {
          System.out.println(" 旺旺 ");
      }
  }
  class Bird extends Animal {
  void shout() {
          System.out.println(" 叽叽喳喳 ");
      }
  }

  6 :抽象类的特点

  1 :有抽象函数的类,该类一定是抽象类。

  2 :抽象类中不一定要有抽象函数。

  3 :抽象类不能使用 new 创建对象

  1 :创建对象,使用对象的功能,抽象类的方法,没有方法体。

  4 :抽象类主要为了提高代码的复用性,让子类继承来使用。

  5 :编译器强制子类实现抽象类父类的未实现的方法。

  1 :可以不实现,前提是子类的也要声明为抽象的。

  7 :抽象的优点

  1 :提高代码复用性

  2 :强制子类实现父类中没有实现的功能

  3 :提高代码的扩展性,便于后期的代码维护

  8 :抽象类不能创建对象,那么抽象类中是否有构造函数?

  抽象类中一定有构造函数。主要为了初始化抽象类中的属性。通常由子类实现。

  9 : final 和 abstract 是否可以同时修饰一个类?

  一定不能同时修饰。

  abstract class Animal {
      String name;
      // 抽象类可以有构造函数
      Animal() {
  }
  Animal(String name) {
      this.name = name;
  }
      abstract void shout();
  }
  class Dog extends Animal {
      Dog() {
  }
      Dog(String name) {
      super(name);
  }
  void shout() {
          System.out.println(" 旺旺 ");
      }
  }
  class Demo3 {
  public static void main(String[] args) {
          // 抽象类不能创建对象
          // Animal a=new Animal();
          Dog d = new Dog(" 旺财 ");
          System.out.println();
      }
  }


本文首次发布于开创者素材 ,转载请注明出处,谢谢合作!

相关文章推荐