38.Java抽象类

2021-03-30 09:26

阅读:647

标签:它的   bst   函数   tle   矛盾   如何   定义   类重写   vat   

抽象类

为什么使用抽象类

   1:定义Dog类

      有颜色属性和叫的方法

   2:定义Bird类

      有颜色属性和叫的方法

   3:定义其父类Animal

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

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

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

             1:狗是旺旺

             2:鸟是叽叽喳喳

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

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

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

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

class Animal {
    String color;

     void shout(){
         //如何定义呢?是旺旺还是叽叽喳喳?
     }
}

class Dog extends Animal {

    void shout() {
        System.out.println("旺旺");
    }

}

class Bird extends Animal {

    void shout() {
        System.out.println("叽叽喳喳");
    }
}

2:使用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:强制子类实现父类中没有实现的功能

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

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

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

      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();
    }
}

2:抽象练习

1:定义抽象类MyShape(图形)

      1:定义抽象方法获取图形的长度和面积

2:定义子类Rect继承父类MyShape  

      1:定义自身特有的长和宽(成员变量)  width height;

      2:实现父类未实现的函数。

   3:定义子类 Circle实现父类MyShape

      1:定义自身特有的半径和圆周率(使用常量)

      2:实现父类为实现的方法。

/*
 }
 2:抽象练习 
 1:定义抽象类MyShape(图形)
 1:定义抽象方法获取图形的长度和面积
 2:定义子类Rect继承父类MyShape   
 1:定义自身特有的长和宽(成员变量)  width height;
 2:实现父类未实现的函数。
 3:定义子类 Circle实现父类MyShape
 1:定义自身特有的半径和圆周率(使用常量)
 2:实现父类为实现的方法。
 */
abstract class MyShape {

    abstract double getLen();

    abstract double getArea();

}

class Rect extends MyShape {
    double width;
    double height;

    Rect() {

    }

    Rect(double width, double height) {
        this.width = width;
        this.height = height;
    }

    double getLen() {
        return 2 * (width + height);
    }

    double getArea() {
        return width * height;
    }
}

class Circle extends MyShape {
    double r;
    public static final double PI = 3.14;

    Circle() {

    }

    Circle(double r) {
        this.r = r;
    }

    double getLen() {
        return 2 * PI * r;
    }

    double getArea() {
        return PI * r * r;
    }
}

class Demo4 {

    public static void main(String[] args) {
        Rect r = new Rect(5, 5);
        System.out.println(r.getLen());
        System.out.println(r.getArea());
        System.out.println();

        Circle c = new Circle(5);
        System.out.println(c.getLen());
        System.out.println(c.getArea());

    }
}

抽象类注意细节

抽象类可以没有抽象方法(java.awt.*的类就是这样子操作的)。

抽象类可以继承普通类与抽象类。

抽象类不能直接使用类名创建实例,但是有构造方法,构造方法是让子类进行初始化。

抽象类一定有构造方法。

abstract与其他修饰符的关系:

       final与abstract不能共存:

              final:它的作用  修饰类代表不可以继承  修饰方法不可重写

              abstract修饰类就是用来被继承的,修饰方法就是用来被重写的。

       static static修饰的方法可以用类名调用,

               对于abstract修饰的方法没有具体的方法实现,所有不能直接调用,

              也就是说不可以与static共存。

       private

              private修饰的只能在本类中使用,

              abstract方法是用来被子类进行重写的,有矛盾

              所有不能共存.

练习:使用抽象类计算一个矩形与圆形的面积。

 

 

38.Java抽象类

标签:它的   bst   函数   tle   矛盾   如何   定义   类重写   vat   

原文地址:https://www.cnblogs.com/gzgBlog/p/13584937.html


评论


亲,登录后才可以留言!