美文网首页
面向对象第三篇

面向对象第三篇

作者: 陶然然_niit | 来源:发表于2018-11-26 14:50 被阅读0次

    1.抽象类

    1.1实例

    描述:定义一个抽象类Shape,具有受保护类型的x和y属性,以及公有的抽象方法获得面积。
    Rectangle类继承于Shape类,在构造方法中给父类属性x和y初始化,并重写父类中求面积的抽象方法。
    Triangle类也继承于Shape类,在构造方法中给父类属性x和y初始化,并重写父类中求面积的抽象方法。
    Cube类继承于Rectangle类,独有的属性是height,其构造方法需要调用父类的构造方法完成对x和y的初始化(立方体的底面长和宽),并对height初始化;独有的方法是求体积。
    创建上转型对象,求矩形的面积和三角形面积。
    创建对象,求立方体的体积。

    代码:
    Shape类

    /**
     * 父类Shape,抽象类
     */
    public abstract class Shape {
        //声明两个受保护类型的属性x、y
        protected  double x;
        protected  double y;
    
        //无参构造器
        public Shape() {
        }
    
        //全参构造器,只做声明, 具体属性初始化到子类中做
        public Shape(double x, double y) {
        }
    
        //声明了一个抽象方法,抽象方法不能带方法体
        public abstract double getArea();
    }
    

    Rectangle类

    /**
     * 矩形子类,继承Shape类,Java是单一继承,只能有一个父类
     */
    public class Rectangle extends Shape {
        public Rectangle() {
            super();
        }
    
        public Rectangle(double x, double y) {
            //在构造方法中给父类属性x和y初始化,通过super.x和super.y访问父类属性
           super.x = x;
           super.y = y;
        }
    
        //重写父类中的的抽象方法getArea(),求出具体形状的面积
        @Override
        public double getArea() {
            //this.x和 this.y是访问当前对象的x和y属性,此处用super.x*super.y也可以
            return this.x * this.y;
        }
    }
    

    Triangle类

    /**
     * 三角形子类,继承Shape,实现方式同Rectangle
     */
    public class Triangle extends Shape{
    
        public Triangle() {
            super();
        }
    
        public Triangle(double x, double y) {
            super.x = x;
            super.y = y;
        }
    
    
        @Override
        public double getArea() {
            return this.x * this.y * 0.5;
        }
    }
    

    Cube类

    /**
     * 立方体子类,继承Rectangle类,为最终类,不再被继承
     */
    public final class Cube extends Rectangle {
        //声明一个私有属性,为立方体的高
        private double height;
    
        public Cube() {
        }
    
        public Cube(double x, double y, double height) {
            //调用父类构造方法,完成对底面矩形的长、宽的初始化
            super(x, y);
            //通过this关键字,完成当前立方体对象的高的初始化
            this.height = height;
        }
        
        //本类独有的成员方法,求体积
        public double getVolumn(){
            //调用父类的求面积方法,求出底面矩形面积,使用this.height访问当前立方体的高,最终求出立方体的体积
            return  super.getArea() * this.height;
        }
    }
    

    主程序ShapeTest

    /**
     * 主程序,用来测试各种子类及方法
     */
    public class ShapeTest {
        public static void main(String[] args) {
            //通过上转型对象创建一个三角形的对象
            Shape shape = new Triangle(4.0, 3.0);
            System.out.println("三角形面积是:" + shape.getArea());
    
            //通过上转型对象创建一个矩形的对象
            Shape shape1 = new Rectangle(4.0, 3.0);
            System.out.println("矩形面积是:" + shape1.getArea());
    
            //通过最终类创建一个立方体对象
            Cube cube = new Cube(4.0, 3.0, 2.0);
            System.out.println("立方体体积是:" + cube.getVolumn());
        }
    }
    
    

    运行结果

    运行结果

    1.2 注意点

    1.super关键字的三个作用

    • 访问父类属性
    • 调用父类构造方法
    • 调用父类成员方法

    2. 抽象类的说明

    • 抽象类中可以有抽象方法和非抽象方法共存
    • 如果一个类中含有抽象方法,则该类一定是抽象类
    • 子类如果继承抽象类,必须强制重写父类中的抽象方法!

    3.final关键字的说明

    • final修饰的变量就是常量
    • final修饰的类不能被继承
    • final修饰的方法不能被子类重写

    2.接口

    和抽象类相似,但是更严格
    接口中只能有抽象方法
    接口中不能声明属性
    一个类可以实现多个接口

    实例:Fly接口、FlyObject抽象类、Plane类、Bird类、FlyTest类
    2.1 新建Fly接口,做法是新建一个class的时候,选择一下Kind类型为interface,如图:


    新建接口

    Fly接口代码:

    /**
     * 飞行接口
     * 接口中所有的方法都是公有的,抽象的
     * 接口中不能定义属性
     */
    public interface Fly {
        /**
         * 省略了public和abstract修饰符的fly方法,返回飞行信息字符串
         * @return String
         */
        String fly();
    }
    
    

    2.2 新建FlyObject抽象类,实现Fly接口

    /**
     * 飞行物抽象类,实现了Fly接口
     *  抽象类中可以有属性变量
     */
    public abstract class FlyObject implements Fly {
        //飞行物名称
        protected String name;
        //飞行时速
        protected double speed;
    
        //构造方法,给飞行物的两个属性初始化
        public FlyObject(String name, double speed) {
            this.name = name;
            this.speed = speed;
        }
    }
    

    2.3 新建Plane类,继承FlyObject抽象类,重写fly()方法

    /**
     * 飞机类,继承FlyObject抽象类
     */
    public class Plane extends FlyObject {
    
        public Plane(String name, double speed) {
            //通过super调用父类构造方法
            super(name, speed);
        }
    
        @Override
        public String fly() {
            //重写fly抽象方法,返回飞机的飞行信息
            return "飞机型号:" + this.name + ",飞行时速:" + this.speed + "km/h";
        }
    }
    

    2.4 新建Bird类,继承FlyObject抽象类,重写fly()方法

    /**
     * 飞禽类,继承FlyObject抽象类
     */
    public class Bird extends FlyObject {
    
        public Bird(String name, double speed) {
            //通过super调用父类构造方法
            super(name, speed);
        }
    
        @Override
        public String fly() {
            //重写fly抽象方法,返回飞禽的飞行信息
            return "飞禽名称:" + this.name + ",飞行时速:" + this.speed + "km/h";
        }
    }
    

    2.5 新建FlyTest测试主类,通过接口回调,创建具体实例并输出飞行结果

    public class FlyTest {
        public static void main(String[] args) {
            //通过接口回调,创建一个Plane的实例给接口变量
            Fly fly1 = new Plane("波音747", 940.0);
            //调用fly()方法,输出飞机的飞行信息
            System.out.println(fly1.fly());
    
            //通过接口回调,创建一个Bird的实例给接口变量
            Fly fly2 = new Bird("老鹰", 80.8);
            //调用fly()方法,输出飞禽的飞行信息
            System.out.println(fly2.fly());
        }
    }
    

    2.6 运行结果


    运行结果

    相关文章

      网友评论

          本文标题:面向对象第三篇

          本文链接:https://www.haomeiwen.com/subject/arrbqqtx.html