Question

please who can help with this question in Java

1.  Write a class called Pair that stores a pair of numbers in private fields. Include a two-arg constructor, mutators and accessors. Override the equals method so that a Pair (1,2) would be considered equal to Pair (2,1). Write an appropriate toString method and make the toString method non-overrideable.

2.  Write an interface called Comparable that includes a method isGreater, isLesser, and isSame. These methods should each take a Pair object as a parameter. 

3.  Write an interface called Nameable that includes method setName and method getName.

4.  Write a child class of Pair called GoodPair that implements the two interfaces above. The isSame method should consider Pair (1,2) to be the same as Pair (1,2) but not the same as Pair (2,1). You can interpret isGreater as returning true if the sum of the two elements of a pair is greater than the sum of the two element of the other pair that it is being compared to, and you can interpret isLesser similarly.

*****************
Use the following code in the demo class:

public static void main(String[] args)
{
        Pair pairA = new Pair(2, 1);
        Pair pairB = new Pair(1, 2);
        System.out.println("The pair A = " + pairA + "\nThe pair B = " + pairB);
        if(pairA.equals(pairB))
            System.out.println("The pair A is equal to pair B.");
        else
            System.out.println("The pair A is NOT equal to pair B.");

        GoodPair gPairA = new GoodPair(2, 1);
        GoodPair gPairB = new GoodPair(1, 2);
        System.out.println("The good pair A = " + pairA + "\nThe good pair B = " + pairB);
        if(gPairA.isSame(gPairB))
            System.out.println("The good pair A is the same as good pair B.");
        else
            System.out.println("The good pair A is NOT the same as good pair B.");

        if(gPairA.isGreater(gPairB))
            System.out.println("The good pair A is greater than good pair B.");
        else
            System.out.println("The good pair A is NOT greater than good pair B.");
}

Answer 1

Please let me know if you need more information :-
==========================================

public class PairTester {
   public static void main(String[] args) {
       Pair pairA = new Pair(2, 1);
       Pair pairB = new Pair(1, 2);
       System.out.println("The pair A = " + pairA + "\nThe pair B = " + pairB);
       if (pairA.equals(pairB))
           System.out.println("The pair A is equal to pair B.");
       else
           System.out.println("The pair A is NOT equal to pair B.");

       GoodPair gPairA = new GoodPair(2, 1);
       GoodPair gPairB = new GoodPair(1, 2);
       System.out.println("The good pair A = " + pairA + "\nThe good pair B = " + pairB);
       if (gPairA.isSame(gPairB))
           System.out.println("The good pair A is the same as good pair B.");
       else
           System.out.println("The good pair A is NOT the same as good pair B.");

       if (gPairA.isGreater(gPairB))
           System.out.println("The good pair A is greater than good pair B.");
       else
           System.out.println("The good pair A is NOT greater than good pair B.");
   }
}

interface Comparable {
   public boolean isGreater(Pair other);

   public boolean isLesser(Pair other);

   public boolean isSame(Pair other);
}

interface Nameable {
   public boolean setName();

   public boolean getName();
}

class Pair {
   private int p1;
   private int p2;

   public Pair(int p1, int p2) {
       super();
       this.p1 = p1;
       this.p2 = p2;
   }

   public int getP1() {
       return p1;
   }

   public void setP1(int p1) {
       this.p1 = p1;
   }

   public int getP2() {
       return p2;
   }

   public void setP2(int p2) {
       this.p2 = p2;
   }

   @Override
   public boolean equals(Object obj) {
       if (this == obj)
           return true;
       if (obj == null)
           return false;
       if (getClass() != obj.getClass())
           return false;
       Pair other = (Pair) obj;
       // Override the equals method so that a Pair (1,2) would be considered equal to
       // Pair (2,1)
       return ((p1 == other.p1 && p2 == other.p2) || (p1 == other.p2 && p2 == other.p1));
   }

   @Override
   public final String toString() {
       return "Pair [p1=" + p1 + ", p2=" + p2 + "]";
   }

}

class GoodPair extends Pair implements Comparable, Nameable {

   public GoodPair(int p1, int p2) {
       super(p1, p2);
   }

   @Override
   public boolean setName() {
       return false;
   }

   @Override
   public boolean getName() {
       return false;
   }

   @Override
   public boolean isGreater(Pair other) {
       // You can interpret isGreater as returning true if the sum of the two elements
       // of a pair is greater than the sum of the two element of the other pair that
       // it is being compared to
       return (this.getP1() + this.getP2() > other.getP1() + other.getP2());
   }

   @Override
   public boolean isLesser(Pair other) {
       // You can interpret isLesser as returning true if the sum of the two elements
       // of a pair is lesser than the sum of the two element of the other pair that
       // it is being compared to
       return (this.getP1() + this.getP2() < other.getP1() + other.getP2());
   }

   @Override
   public boolean isSame(Pair other) {
       // The isSame method should consider Pair (1,2) to be the same as Pair (1,2) but
       // not the same as Pair (2,1).
       return (this.getP1() == other.getP1() && this.getP1() == other.getP2());
   }

}
=======
OUTPUT:-

===

The pair A = Pair [p1=2, p2=1]
The pair B = Pair [p1=1, p2=2]
The pair A is equal to pair B.
The good pair A = Pair [p1=2, p2=1]
The good pair B = Pair [p1=1, p2=2]
The good pair A is NOT the same as good pair B.
The good pair A is NOT greater than good pair B.

===

The pair A = Pair [p1=2, P2=1] The pair B = Pair [p1=1, p2=2] The pair A is equal to pair B. The good pair A = Pair [p1=2, p2=1] The good pair B = Pair [p1=1, p2=2] The good pair A is NOT the same as good pair B. The good pair A is NOT greater than good pair B.

===

public class PairTester { public static void main(String[] args) { Pair pairA = new Pair(2, 1); Pair pairB = new Pair(1, 2); System.out.println("The pair A = " + pairA + "\nThe pair B = " + pairB); if (pairA.equals(pairB)) System.out.println("The pair A is equal to pair B."); else System.out.println("The pair A is NOT equal to pair B."); GoodPair gPairA = new GoodPair(2, 1); GoodPair gPairB = new GoodPair(1, 2); System.out.println("The good pair A = " + pairA + "\nThe good pair B = " + pairs); if (gPairA.isSame (gPairB)) System.out.println("The good pair A is the same as good pair B."); else System.out.println("The good pair A is NOT the same as good pair B."); if (gPairA.isGreater(gPairB)) System.out.println("The good pair A is greater than good pair B."); else System.out.println("The good pair A is NOT greater than good pair B."); interface Comparable { public boolean isGreater(Pair other); public boolean isLesser(Pair other); public boolean isSame(Pair other); interface Nameable { public boolean setName(); public boolean getName(); class Pair { private int p1; private int p2; public Pair(int p1, int p2) { super();

==

this.p1 = p1; this.p2 = p2; public int getP1() { return p1; public void setP1(int pl) { this.p1 = p1; public int getP2() { return p2; public void setP2(int p2) { this.p2 = p2; @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Pair other = (Pair) obj; // Override the equals method so that a Pair (1,2) would be considered equal to // Pair (2,1) return ((p1 == other.p1 && p2 == other.p2) || (p1 == other.p2 && p2 == other.p1)); @Override public final String toString() { return "Pair [p1=" + p1 + ", p2=" + p2 + "]"; class GoodPair extends Pair implements Comparable, Nameable { public GoodPair(int p1, int p2) { super(p1, p2); @Override

==

public boolean setName() { return false; @Override public boolean getName() { return false; @Override public boolean isGreater(Pair other) { // You can interpret isGreater as returning true if the sum of the two elements // of a pair is greater than the sum of the two element of the other pair that // it is being compared to return (this.getP1() + this.getP2() > other.getP1() + other.getP2()); @Override public boolean isLesser(Pair other) { // You can interpret isLesser as returning true if the sum of the two elements // of a pair is lesser than the sum of the two element of the other pair that // it is being compared to return (this.getP1() + this.getP2() < other.getP1() + other.getP2()); @Override public boolean isSame (Pair other) { // The issame method should consider Pair (1,2) to be the same as Pair (1,2) but // not the same as Pair (2,1). return (this.getP1() == other.getP1() && this.getP1() == other.getP2());

==

===

Thanks