Калькулятор для операций над двумя дробями

private int a;
    private int b;
    
    private int full; //2 5/8 
    
    public Drob(int full, int a, int b){ }
    
    public void simplify(){}
    public boolean equals(Drob d2){}
    
    public void sum(Drob d2){}
    public void substract(Drob d2){}
    public void multiply(Drob d2){}
    public void divide(Drob d2){}
    
    public String toString(){//2 5/8 }
}

public Drob(int full, int a, int b) {
  this.full = full;
  this.a = a;
  this.b = b;
}

public class MixedFraction {
    private int full; //2 5/8
    private int a;
    private int b;
 
    public MixedFraction(int full, int a, int b) {
        this.full = full;
        this.a = a;
        this.b = b;
    }
 
    public static void main(String[] args) {
        final var mixedFraction = new MixedFraction(2, 5, 8);
        System.out.println("First fraction: " + mixedFraction);
 
        mixedFraction.simplify();
        System.out.println("Simplied first fraction: " + mixedFraction);
 
        final var mixedFraction1 = new MixedFraction(2, 2, 8);
        System.out.println("Second fraction: " + mixedFraction1);
 
        final var equals = mixedFraction.equals(mixedFraction1);
        System.out.println("Is equals? " + equals + ", first fraction: " + mixedFraction + ", second fraction: " + mixedFraction1);
 
        mixedFraction.sum(mixedFraction1);
        System.out.println("First fraction after addition: " + mixedFraction);
 
        mixedFraction.substract(mixedFraction1);
        System.out.println("First fraction after subtraction: " + mixedFraction);
 
        mixedFraction.multiply(mixedFraction1);
        System.out.println("First fraction after multiplication: " + mixedFraction);
 
        mixedFraction.divide(mixedFraction1);
        System.out.println("First fraction after division: " + mixedFraction);
    }
 
    public void simplify() {
        set(FractionMapper.toFraction(this));
    }
 
    private void set(Fraction fraction) {
        final var drob = FractionMapper.toDrob(fraction);
        this.full = drob.full;
        this.a = drob.a;
        this.b = drob.b;
    }
 
    public boolean equals(MixedFraction d2) {
        simplify();
        if (d2 != null) {
            d2.simplify();
        }
        if (this == d2) {
            return true;
        }
        if (d2 == null || getClass() != d2.getClass()) {
            return false;
        }
        return this.full == d2.full && this.a == d2.a && this.b == d2.b;
    }
 
    public void sum(MixedFraction d2) {
        set(FractionMapper.toFraction(this).add(FractionMapper.toFraction(d2)));
    }
 
    public void substract(MixedFraction d2) {
        set(FractionMapper.toFraction(this).subtract(FractionMapper.toFraction(d2)));
    }
 
    public void multiply(MixedFraction d2) {
        set(FractionMapper.toFraction(this).multiply(FractionMapper.toFraction(d2)));
    }
 
    public void divide(MixedFraction d2) {
        set(FractionMapper.toFraction(this).divide(FractionMapper.toFraction(d2)));
    }
 
    public String toString() {//2 5/8 }
        return this.full + " " + this.a + "/" + this.b;
    }
 
    private static class Fraction {
        private final int a;
        private final int b;
 
        private Fraction(int a, int b) {
            if (b < 0) {
                a = -a;
                b = -b;
            }
            final var gcd = gcd(a, b);
            this.a = a / gcd;
            this.b = b / gcd;
        }
 
        private static int gcd(int a, int b) {
            return b == 0 ? a : gcd(b, a % b);
        }
 
        private Fraction negate() {
            return new Fraction(-this.a, this.b);
        }
 
        private Fraction swap() {
            return new Fraction(this.b, this.a);
        }
 
        private Fraction add(Fraction fraction) {
            return new Fraction(this.a * fraction.b + fraction.a * this.b, this.b * fraction.b);
        }
 
        private Fraction subtract(Fraction fraction) {
            return add(fraction.negate());
        }
 
        private Fraction multiply(Fraction fraction) {
            return new Fraction(this.a * fraction.a, this.b * fraction.b);
        }
 
        private Fraction divide(Fraction fraction) {
            return multiply(fraction.swap());
        }
    }
 
    private static class FractionMapper {
        private static MixedFraction toDrob(Fraction fraction) {
            if (fraction.b == 0) {
                // Целая часть от деления 1 / 0 (О_о)
                return new MixedFraction(0, fraction.a, fraction.b);
            }
            return new MixedFraction(fraction.a / fraction.b, fraction.a % fraction.b, fraction.b);
        }
 
        private static Fraction toFraction(MixedFraction mixedFraction) {
            return new Fraction(mixedFraction.full * mixedFraction.b + mixedFraction.a, mixedFraction.b);
        }
    }
}