下面的Java程序如何引入封装？

Question

我创建了以下 Java 程序。它的基本功能是对两个数进行加减乘除和模除。

我已经实现了面向对象编程的概念，但是缺少封装。

如何在其中引入封装？

我的代码是：

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */


/**
 *
 * @author piyali
 */

public class Calculator {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {

        // TODO code application logic here
        int x, y;
        x = 13;
        y = 5;

        calculation add = new calculation();
        calculation sub = new calculation();
        calculation mul = new calculation();
        calculation div = new calculation();
        calculation mod = new calculation();

        int addResult = add.addition(x, y);
        int subResult = sub.subtraction(x, y);
        int mulResult = mul.multiplication(x, y);
        int divResult = mul.division(x, y);
        int modResult = mod.modularDivision(x, y);

        System.out.println("The addition of the numbers is " +addResult);
        System.out.println("The subtraction of the two numbers is " +subResult);
        System.out.println("The multiplication of the two numbers is " + mulResult);
        System.out.println("The division of the two numbers is " +divResult);
        System.out.println("The modular division of the two numbers is " + modResult);
    }
}

class calculation {

    int addition(int x, int y){
        int z;
        z = x + y;
        return(z);
    }

    int subtraction(int x, int y){
        int z;
        z = x - y;
        return(z);
    }

    int multiplication(int x, int y){
        int z;
        z = x * y;
        return(z);
    }

    int division(int x, int y){
        int z;
        z = x / y;
        return(z);
    }

    int modularDivision(int x, int y){
        int z;
        z = x % y;
        return(z);
    }
}

Answer 1

使用getter和setter的概念。

class Calculator{
private int x, y, z;

void setValue(int a, int b){
    x=a;
    y=b;
}

int getValue(){
    return z;
}

void addition(){
    z=x+y;
}

void subtraction(){
    z=x-y;
}

void multiplication(){
    z=x*y;
}

void division(){
    z=x/y;
}

void modDivision(){
    z=x%y;
}
}


public class CalculatorTestDrive {

/**
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    int num1, num2, result;

    num1=13;
    num2=5;

    Calculator add = new Calculator();
    Calculator sub = new Calculator();
    Calculator mul = new Calculator();
    Calculator div = new Calculator();
    Calculator mod = new Calculator();

    add.setValue(num1, num2);
    add.addition();
    result = add.getValue();
    System.out.println("The addition of " + num1 + " and " + num2 + " is " +result);

    sub.setValue(num1, num2);
    sub.subtraction();
    result = sub.getValue();
    System.out.println("The subtraction of " + num1 + " and " + num2 + " is " +result);

    mul.setValue(num1, num2);
    mul.multiplication();
    result = mul.getValue();
    System.out.println("The multiplication of " + num1 + " and " + num2 + " is " +result);

    div.setValue(num1, num2);
    div.division();
    result = div.getValue();
    System.out.println("The division of " + num1 + " and " + num2 + " is " +result);

    mod.setValue(num1, num2);
    mod.modDivision();
    result = mod.getValue();
    System.out.println("The modular division of " + num1 + " and " + num2 + " is " +result);
}

}

Answer 2

我认为这里没有太多要概括的内容。这看起来像是一个基本的数学库，并且由于它没有数据成员或辅助函数，所以您不能在这里做很多封装。

由于创建此 class 的实例有点傻（例如，请参阅 Java 数学库），请将方法设为静态，并将构造函数设为私有。

我想这不是一种封装形式，而是一些设计技巧：您应该将不修改的变量设为最终变量。如果您不使用它们，您还应该删除所有不必要的变量。他们没有为可读性做任何事情，他们只是使用额外的内存块（除非 JVM 优化它们）。

改进代码：

class calculation {
    private calculation() {
        throw new RuntimeException("Don't instantiate a math library!");
    }

    public static int addition(final int x, final int y){
        return x + y;
     }

    public static int subtraction(final int x, final int y){
        return x - y;
    }

    public static int multiplication(final int x, final int y){
        return x * y;
    }

    public static int division(final int x, final int y){
        return x / y;
    }

    public static int modularDivision(final int x, final int y){
        return x % y;
    }
}

通过这样做，现在您可以像这样调用您的计算库：

int additionResult = calculation.addition(5, 5);
System.out.println(additionResult);

Answer 3

好吧，如果你想要真正的 OOP 和封装，那么创建接口 Calculation，它有一个方法 int calculate()。

public interface Calculation {

     int calculate();
}

现在创建 classes 实现此接口，例如 Addition 或 Subtraction 等

public class Addition implements Calculation {

     private final int x;
     private final int y;

     public Addition(int x, int y) {
         this.x = x;
         this.y = y;
     }

     @Override
     public int calculate(){
         return x + y;
     }
 }

主要方法

public static void main(String[] args) {

    int x, y;
    x = 13;
    y = 5;

    Calculation add = new Addition(x, y);
    System.out.println(add.calculate());
}

这种设计的优点是，如果您想要添加任何额外的数学运算，例如根、百分比甚至推导，您将不需要修改 class 的任何实现。只需编写额外的 class 即可实现 Calculation.

下面的Java程序如何引入封装？

How do I introduce encapsulation in the following Java program?

java

oop

encapsulation