JAVA--抽象类

抽象类(abstract)

定义方式:public abstract class XXXX{}

抽象类

1.抽象类不能创建对象(不能实例化),没有意义

2.抽象类可以提供构造器,也可以不提供.

3.抽象类中可以没有抽象方法.

4.abstract与final不能同时修饰一个类.

关于第4点,可以这么解释:抽象类必须要有子类来实现它的方法,而final修饰的类不能有子类,两者恰好矛盾.

继承抽象类

1.若一个类继承了抽象类,那么这个类必须实现这个类的所有抽象方法

2.若一个类没有实现抽象类的所有抽象方法,那么这个类必须使用abstract修饰.

抽象方法

1.用abstract修饰的方法不提供方法体.定义方式:public abstract 返回值方法名();

2.有抽象方法的类一定是抽象类.

抽象类的意义

1.给不同的子类定义一个父类,

2.抽象类可以封装子类的共同特征与共同行为

3.虽然子类方法可能有不同的实现逻辑,但是方法的定义是一致的.

下面这个实例包括了抽象类的主要知识点,可供参考.

抽象父类Shape:

public abstract class Shape {

    double perimeter;
    double area;

    public abstract double perimeter();//抽象方法的定义,求图形的周长
    public abstract double area();//抽象方法的定义,求图形的面积
}

子类Circle类:

public class Circle extends Shape{

    private  int rad;//半径

    public int getRad() {
        return rad;
    }

    public void setRad(int rad) {
        this.rad = rad;
    }

    public double perimeter() {//实现父类的方法
        perimeter=Math.PI*2*rad;
        return perimeter;
    }

    public double area() {//实现父类的方法
        area=Math.PI*rad*rad;
        return area;
    }
}

子类Square类:

public class Square extends Shape{

    private int width;
    private int length;

    public int getWidth() {
        return width;
    }

    public void setWidth(int width) {
        this.width = width;
    }

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public double perimeter() {//实现父类的方法
        perimeter=2*(width+length);
        return perimeter;
    }

    public double area() {//实现父类的方法
        area=width*length;
        return area;
    }
}

未实现全部父类方法的子类RegularTriangle类,必须使用abstract修饰:

public abstract class RegularTriangle extends Shape{
    /*
    * 如果不实现抽象父类的所有方法,则必须要定义为abstract类.
    * */

    private int length;//正三角形边长

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public double perimeter(){
        perimeter=length*3;
        return perimeter;
    }
        //未实现父类的area()方法
}

只有普通方法的抽象类Trapezoid,未继承Shape:

abstract class Trapezoid {

    int side1;
    int side2;
    int side3;
    int side4;
    int perimeter;

    public int getSide1() {
        return side1;
    }

    public void setSide1(int side1) {
        this.side1 = side1;
    }

    public int getSide2() {
        return side2;
    }

    public void setSide2(int side2) {
        this.side2 = side2;
    }

    public int getSide3() {
        return side3;
    }

    public void setSide3(int side3) {
        this.side3 = side3;
    }

    public int getSide4() {
        return side4;
    }

    public void setSide4(int side4) {
        this.side4 = side4;
    }

    /*
    * 抽象类内可以没有抽象方法.
    * */

    public double perimeter(){

        perimeter=side1+side2+side3+side4;
        return perimeter;
    }
}

测试类 TestShape:

public class TestShape {

    public static void main(String[] args) {

        Circle c=new Circle();
        Square s=new Square();
       // RegularTriangle r=new RegularTriangle();//会报错,抽象类不能实例化.

        s.setLength(7);
        s.setWidth(9);
        c.setRad(5);
        //为方便查看所以将结果强转为int型.
        System.out.println("圆的周长为:"+(int)c.perimeter());
        System.out.println("圆的面积为:"+(int)c.area());
        System.out.println("方形的周长为:"+(int)s.perimeter());
        System.out.println("方形的面积为:"+(int)s.area());
    }
}

运行结果:

圆的周长为:31
圆的面积为:78
方形的周长为:32
方形的面积为:63

抽象类(abstract)

猜你喜欢