Java抽象和封装的区别和例子

介绍

Java中的抽象和封装是面向对象编程中重要的概念，也是面向对象编程的基石。抽象和封装本质不同，但它们都是为了达到一定的编程目的。

• 抽象是一种基于概念的思维方式，它的目的是通过忽略与具体任务无关的细节，把问题的本质抽象出来，从而更容易理解和实现。
• 封装指的是将一组数据或者一段代码封装起来，达到隐藏细节、确保安全、提高抽象层次等目的。

抽象

抽象是一种思维方式，它核心思想是“屏蔽细节”。Java中的抽象一般指两个方面，一方面是抽象类（abstract class），另一方面是接口（interface）。

抽象类

抽象类不能被实例化，只能作为其他类的父类。它可以包含已实现方法的实现和未实现方法的声明。使用抽象类，我们可以在子类中覆盖已实现方法、实现未实现方法。Java中的抽象类使用abstract关键字修饰。

public abstract class Shape {
    protected double area;

    // 抽象方法
    public abstract double calcArea();

    // 已实现方法
    public void printArea() {
        System.out.println("面积为：" + area);
    }
}

public class Circle extends Shape {
    protected double radius;

    public Circle(double r) {
        radius = r;
    }

    public double calcArea() {
        area = 3.14 * radius * radius;
        return area;
    }
}

public class Rectangle extends Shape {
    protected double width;
    protected double height;

    public Rectangle(double w, double h) {
        width = w;
        height = h;
    }

    public double calcArea() {
        area = width * height;
        return area;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle(5);
        circle.calcArea();
        circle.printArea();

        Rectangle rectangle = new Rectangle(3, 4);
        rectangle.calcArea();
        rectangle.printArea();
    }
}

接口

接口是一个结果只包含方法声明和常量定义的抽象类型。实现接口（implement interface）的类必须重新声明接口的所有方法。Java中使用interface关键字来定义接口。

public interface Shape {
    double calcArea();
}

public class Circle implements Shape {
    protected double radius;

    public Circle(double r) {
        radius = r;
    }

    public double calcArea() {
        return 3.14 * radius * radius;
    }
}

public class Rectangle implements Shape {
    protected double width;
    protected double height;

    public Rectangle(double w, double h) {
        width = w;
        height = h;
    }

    public double calcArea() {
        return width * height;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Circle(5);
        System.out.println("圆的面积："+shape1.calcArea());

        Shape shape2 = new Rectangle(3, 4);
        System.out.println("矩形的面积："+shape2.calcArea());
    }
}

封装

封装是将类的数据和方法包装在一起，形成一个独立的单元。封装的目的是把数据和方法组合成一个独立的单元，这个单元对外部不可见，外部只能通过一个受控的接口来访问里面的数据和代码。Java中的封装主要使用Java访问控制修饰符来实现：

• public ：表示该数据或方法是公共的，其他类可以访问；
• protected ：表示该数据或方法仅仅对包内和它的子类可见；
• private ：表示该数据或方法仅仅在本类中可见。

public class Student {
    private String name;
    private int age;
    private String sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

public class Main {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三");
        student.setAge(18);
        student.setSex("男");

        System.out.println("姓名：" + student.getName());
        System.out.println("年龄：" + student.getAge());
        System.out.println("性别：" + student.getSex());
    }
}

总结

抽象和封装是面向对象编程中基本的思想和工具，它们可以协助我们创建高质量的代码，提高软件的可维护性和可扩展性。抽象和封装的使用也需要我们根据具体的场景和问题灵活选择对应的方式来实现。