Wie führe ich die Kapselung in das folgende Java-Programm ein?

Question

Ich habe das folgende Java-Programm erstellt. Seine Grundfunktionalität besteht darin, Addition, Subtraktion, Multiplikation, Division und modulare Aufteilung auf zwei Zahlen durchzuführen.

Ich habe das Konzept der objektorientierten Programmierung implementiert, aber es fehlt Kapselung.

Wie führe ich eine Verkapselung ein?

Mein Code ist:

/* 
* 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

Nun, wenn Sie wahre OOP und Verkapselung wollen, dann erstellen Schnittstelle Calculation Das hat eine Methode int calculate().

public interface Calculation { 

    int calculate(); 
} 

Jetzt Klassen erstellen, die diese Schnittstelle wie Addition oder Subtraction usw.

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

Main-Methode implementiert

public static void main(String[] args) { 

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

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

Vorteile einer solchen Konstruktion ist, dass, wenn Sie hinzufügen möchten Zusätzliche mathematische Operationen wie root, prozentual oder sogar Ableitung, müssen Sie keine Implementierung der Klasse ändern. Schreiben Sie einfach eine zusätzliche Klasse, die Calculation implementiert.

Answer 2

Verwenden Sie das Konzept von Getter und 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 3

Ich glaube nicht, dass es hier viel zu kapseln gibt. Das sieht so aus, als ob es eine einfache mathematische Bibliothek sein möchte, und da es keine Datenelemente oder Hilfsfunktionen hat, können Sie hier nicht viel tun, um es einzukapseln.

Da das Erstellen einer Instanz dieser Klasse etwas albern ist (siehe zum Beispiel die Java Math-Bibliothek), machen Sie die Methoden statisch und machen Sie den Konstruktor privat.

Ich denke, keine Form der Kapselung, aber einige Design-Tipps: Sie sollten Variablen machen, die Sie nicht endgültig ändern. Sie sollten auch alle unnötigen Variablen entfernen, wenn Sie sie nicht verwenden. Sie machen nichts für die Lesbarkeit, und sie verwenden nur zusätzliche Speicherblöcke (außer die JVM optimiert sie aus).

Verbesserte Code:

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

Auf diese Weise können Sie jetzt Ihre Berechnung Bibliothek mit so etwas wie dies nennen:

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