Erstellen einer Utility-Klasse in Java

Hilfsklassen in Java werden auch als Hilfsklasse bezeichnet. Es ist eine effiziente Möglichkeit, Methoden zu erstellen, die wiederverwendet werden können. Der Code, den wir immer wieder verwenden müssen, kann in eine Utility-Klasse eingefügt werden.

Verwendung der Utility-Klasse in Java

Die Java-Dienstprogrammklasse ist eine zustandslose Klasse, die nicht mit den Schlüsselwörtern final und public instanziiert und deklariert werden kann. In dem unten angegebenen Beispiel haben wir ein UtilityClassExample, das einen privaten Konstruktor hat, der die Instanziierung verhindert. Beispielsweise gibt es viele Beispiele für Util-Klassen in Java wie Apache StringUtils, CollectionUtils oder java.lang.Math.

Die Methoden in der Hilfsklasse sollten als statisch und nicht als abstrakt deklariert werden, da Objektmethoden instanziiert werden müssen. Das letzte Schlüsselwort verhindert die Unterklassenbildung. Hier erstellen wir unsere eigene Utility-Klasse mit einem private Konstruktor, der beim Aufruf eine Ausnahme auslöst. Da wir einen private Konstruktor deklariert haben, kann default nicht erstellt werden; Daher kann die Klasse nicht instanziiert werden.

Im unten angegebenen Code haben wir alle Mitglieder der Statik UtilityClassExample. Wenn wir zwei Variablen vom Typ int oder float addieren oder subtrahieren müssen, haben wir Methoden in der Utility-Klasse erstellt, um den Code wiederzuverwenden. Wir haben auch eine Methode, die eine mit zehn multiplizierte Zahl zurückgibt.

In der Methode addFloatValues() haben wir zusätzlich mit Math.round() das Ergebnis auf den nächsten Int gerundet. Die Klasse Float hat die Methode sum(), die die Summe zweier Float-Argumente zurückgibt. Wir rufen jede Mitgliedsmethode dieser Utility-Klasse auf, übergeben Argumente und geben die Ausgabe in der main()-Methode der Klasse TestUtity aus. Daher hat diese Utility-Klasse Methoden, die sehr oft verwendet werden.

public final class UtilityClassExample {
  private static final int constantValue = 10;
  private UtilityClassExample() {
    throw new java.lang.UnsupportedOperationException("Utility class and cannot be instantiated");
  }
  public static int addIntValues(int i, int j) {
    int sum = i + j;
    return sum;
  }
  public static int subIntValues(int i, int j) {
    int diff = 0;
    if (i > j) {
      diff = i - j;
    } else {
      diff = j - i;
    }
    return diff;
  }
  public static float addFloatValues(float i, float j) {
    float sum = Float.sum(i, j);
    return Math.round(sum);
  }
  public static float subFloatValues(float i, float j) {
    float diff = 0.00f;
    if (i > j) {
      diff = i - j;
    } else {
      diff = j - i;
    }
    return diff;
  }

  public static int returnValAfterMultiplying(int i) {
    return i * constantValue;
  }
}
class TestUtility {
  public static void main(String[] args) {
    int a = 4;
    int b = 9;
    int c = 7;
    float d = 3.12f;
    float e = 6.85f;

    System.out.println(+a + " multiplied by ten is : 				     "
        + UtilityClassExample.returnValAfterMultiplying(a));
    System.out.println(b + "+" + c + " is : " + UtilityClassExample.addIntValues(b, c));
    System.out.println(d + "+" + e + " is : " + UtilityClassExample.addFloatValues(d, e));
    System.out.println(b + "-" + a + " is : " + UtilityClassExample.subIntValues(b, a));
    System.out.println(e + "-" + d + " is : " + UtilityClassExample.subFloatValues(e, d));
  }
}

Ausgabe:

4 multiplied by ten is : 40
9+7 is : 16
3.12+6.85 is : 10.0
9-4 is : 5
6.85-3.12 is : 3.73

Es wird nicht empfohlen, eine eigene Utility-Klasse zu verwenden, da dies die Flexibilität verringert.