Page History

class SuperClass { // SuperClass maintains all banking related data such as account balance
  private double balance = 100;
 
  double getBalance() {
    return balance;  
  }

 

class SuperClass { // The SuperClass class maintains all bank data during program execution
  private double balance = 0;
 
  protected boolean withdraw(double amount) {
    balance -= amount;
    System.out.println("Withdrawal successful. The balance is : " + balance);
    return true;	 
  }
 
  protected void overdraft() { // thisThis method is added at a later date
    balance += 300;  // addAdd 300 in case there is an overdraft
    System.out.println("The balanceAdded back-up amount. The balance is :" + balance);
  }
}

class SubClass extends SuperClass { //all usersSubclass have to subclass this to proceedhandles authentication
  public@Override booleandouble withdrawgetBalance(double amount) {
    // inputValidationsecurityManagerCheck();
    // securityManagerCheckreturn super.getBalance();
  }

  //@Override Loginboolean by checking credentials using database and then call a method in SuperClass withdraw(double amount) {
    // inputValidation(), securityManagerCheck() and authenticateUser()

    // that updates the balance field to reflect current balance, other details
    if ((super.getBalance() - amount) >= 0) {	
      super.withdraw(amount);
      return true;
    } else {
      return false;
    }
  }	
 		
 
  public static void doLogic(SuperClass sc, double amount) {
    sc.withdraw(amount);
  }
}

public class Affect {
  public static void main(String[] args) {
    SuperClass sc = new SubClass(); // Override
    SubClass sub = new SubClass();  // Need instance of SubClass to call methods

    if(sc.withdraw(200.0)) {  // Validate and enforce security manager check 
      sc = new SuperClass();  // If allowed perform the withdrawal
      sub.doLogic(sc, 200.0); // Pass the instance of SuperClass to use it
    }
    else// ...
  }
}

public class Client {
  public static void main(String[] args) {
    SuperClass sc = new SubClass(); // Override
    
    if(sc.withdraw(200.0)) {        // Validate and enforce security manager check 
      SystemSubClass.out.println("You do not have permission/input validation failed!");	doLogic(sc, 200.0);  // Withdraw 200.0 from superclass
    } else {
      sc.overdraft(); // Newly added method, has no security manager checks. 
    }
  }
}

class CalendarSubclass extends Calendar {
  @Override public boolean after(Object when) {
    // correctly calls Calendar.compareTo()
    if(when instanceof Calendar && super.compareTo((Calendar)when) == 0) {
      return true;
    }
    return super.after(when); // Calls CalendarSubclass.compareTo() instead of Calendar.compareTo() 
  }
	
  @Override public int compareTo(Calendar anotherCalendar) {
    // This method is erroneously invoked by Calendar.after()
    return compareDays(this.getFirstDayOfWeek(), anotherCalendar.getFirstDayOfWeek());
  }

  private int compareDays(int currentFirstDayOfWeek, int anotherFirstDayOfWeek) {
    return (currentFirstDayOfWeek > anotherFirstDayOfWeek) ?
           1 : (currentFirstDayOfWeek == anotherFirstDayOfWeek) ? 0 : -1;
  }

  public static void main(String[] args

class CalendarSubclass extends Calendar {
  @Override public boolean after(Object when) {
    if(when instanceof Calendar && super.compareTo((Calendar)when) == 0) {
      // correctly calls Calendar.compareTo()
      return true;
    }
    return super.after(when); // Calls CalendarSubclass.compareTo() instead of Calendar.compareTo() 
  }
	
  @Override public int compareTo(Calendar anotherCalendar) {
    //CalendarSubclass Thiscs1 method= is erroneously invoked by Calendar.after()
    return compareTo(anotherCalendar.getFirstDayOfWeek(), anotherCalendar);
  }

  private int compareTo(int firstDayOfWeek, Calendar c) {new CalendarSubclass(); 
    CalendarSubclass cs2 = new CalendarSubclass(); // Wed Dec 31 19:00:00 EST 1969
    int thisTime = c.get(Calendar.DAY_OF_WEEK);
cs1.setTime(new Date());      return (thisTime > firstDayOfWeek) ? 1 : (thisTime == firstDayOfWeek) ? 0 : -1;
  }

  public// staticCurrent void main(String[] args) {day's date 
    CalendarSubclass cs1 = new CalendarSubclass();
System.out.println(cs1.after(cs2));     CalendarSubclass cs2 = new CalendarSubclass();
    cs1.setTime(new Date());
    System.out.println(cs1.after(cs2));  // // prints false
  }

  // Implementation of other abstract methods 
}

// The implementation of java.util.Calendar.after() method is shown below
public boolean after(Object when) {
  return when instanceof Calendar && compareTo((Calendar)when) > 0;
     // forwards to the subclass's implementation erroneously
}

// The CalendarImplementation object is a concrete implementation of the abstract Calendar class
// Class ForwardingCalendar
public class ForwardingCalendar {
  private final CalendarImplementation c;

  public ForwardingCalendar(CalendarImplementation c) {
    this.c = c;
  }

  CalendarImplementation getCalendarImplementation() {
    return c;
  }

  public boolean after(Object when) {
    return c.after(when);
  }

  public int compareTo(Calendar anotherCalendar) {
    // CalendarImplementation.compareTo() will be called
    return c.compareTo(anotherCalendar);
  }
}

//Class CompositeCalendar
class CompositeCalendar extends ForwardingCalendar {
  public CompositeCalendar(CalendarImplementation ci) {
    super(ci);  
  }
  
  @Override public boolean after(Object when) {
    // This will call the overridden version i.e. CompositeClass.compareTo();

// The CalendarImplementation object is a concrete implementation of the abstract Calendar class
// Class ForwardingCalendar
public class ForwardingCalendar {
  private final CalendarImplementation c;

  public ForwardingCalendar(CalendarImplementation c) {
    this.c = c;
  }

  public boolean after(Object when) {
    return c.after(when);
  }

  public int compareTo(Calendar anotherCalendar) {
    // CalendarImplementation.compareTo() will be called
    return c.compareTo(anotherCalendar);
  }
}

//Class CompositeCalendar
class CompositeCalendar extends ForwardingCalendar {
  public CompositeCalendar(CalendarImplementation ci) {
    super(ci);  
  }
  
  @Override public boolean after(Object when) {
    if(when instanceof Calendar && super.compareTo((Calendar)when) == 0) {
      // This will call the overridden version
      // i.e. CompositeClass.compareTo();
      // Return true if it is the first day of week
      return true;
    }
    return super.after(when); // Does not compare with first day of week anymore;
                              // Uses default comparison with epoch
  }
	
  @Override public int compareTo(Calendar anotherCalendar) {
     // CompositeCalendar.compareTo() will not be called now
return compareDays(super.getCalendarImplementation().getFirstDayOfWeek(),
                      return compareTo(anotherCalendar.getFirstDayOfWeek(), anotherCalendar);
  }

  private int compareTocompareDays(int firstDayOfWeekcurrentFirstDayOfWeek, Calendarint canotherFirstDayOfWeek) {
    intreturn thisTime(currentFirstDayOfWeek = c.get(Calendar.DAY_OF_WEEK);
> anotherFirstDayOfWeek) ?
      return (thisTime > firstDayOfWeek) ? 1 : (thisTimecurrentFirstDayOfWeek == firstDayOfWeekanotherFirstDayOfWeek) ? 0 : -1;
  }

  public static void main(String[] args) {
    CalendarImplementation ci1 = new CalendarImplementation();
    CalendarImplementation ci2 = new CalendarImplementation();
    CompositeCalendar c = new CompositeCalendar(ci1);
    ci1.setTime(new Date());
    System.out.println(c.after(ci2)); // prints true 
  }
}
 CompositeCalendar(ci1);
    ci1.setTime(new Date());
    System.out.println(c.after(ci2)); // prints true 
  }
}