public void processIntegers(List<Integer> integers) {

  for (Integer value: integers) {
    for (int i = integers.size() - 1; i >= 0; i--) {
      value += integers.get(i);
    }
  }
}

public class HttpResponseCodes {
  public static final int OK = 200;
  public static final int NOT_FOUND = 404;
  public static final int FORBIDDEN = 403;
}
if (getHttpResponse().getStatusCode() == HttpResponseCodes.OK) {
  // Do something if the response code is OK 
}

public class HttpResponseHandler {
  public static void printMessage(int statusCode) {
    System.out.println("Recieved status of " + statusCode); 
  }
}
HttpResponseHandler.printMessage(15000);

public class HttpResponseCodes {
  public static final int OK = 200;
  public static final int NOT_FOUND = 404;
  public static final int FORBIDDEN = 403;
  public static boolean isSuccess(int statusCode) {
    return statusCode >= 200 && statusCode < 300; 
  }
}
if (HttpResponseCodes.isSuccess(getHttpResponse().getStatusCode())) {
  // Do something if the response code is a success code 
}

public enum HttpResponseCodes {
  OK(200),
  FORBIDDEN(403),
  NOT_FOUND(404);
  private final int code; 
  HttpResponseCodes(int code) {
    this.code = code;
  }
  public int getCode() {
    return code;
  }
  public boolean isSuccess() {
    return code >= 200 && code < 300;
  }
}
if (getHttpResponse().getStatusCode().isSuccess()) {
  // Do something if the response code is a success code 
}

public class HttpResponseHandler {
  public static void printMessage(HttpResponseCode statusCode) {
    System.out.println("Recieved status of " + statusCode.getCode()); 
  }
}
HttpResponseHandler.printMessage(HttpResponseCode.OK);

public class NumericConstants {
  public static final double PI = 3.14;
  public static final double UNIT_CIRCLE_AREA = PI * PI;
}
public class Rug {
  private final double area;
  public class Run(double area) {
    this.area = area;
  }
  public double getCost() {
    return area * 2;
  }
}
// Create a carpet that is 4 feet in diameter (radius of 2 feet)
Rug fourFootRug = new Rug(2 * NumericConstants.UNIT_CIRCLE_AREA);

public class Purchase {
  private long id;
  public long getId() {
    return id;
  }
  public void setId(long id) {
    this.id = id;
  }
}

Purchase originalPurchase = new Purchase();
Purchase updatedPurchase = new Purchase();
if (originalPurchase.getId() == updatedPurchase.getId()) {
  // Execute some logic for equal purchases 
}

public class Purchase {
  private long id;
  public boolean isSame(Purchase other) {
    return getId() == other.gerId();  
  }
}

public boolean equals(Object obj) {
return (this == obj);
}

public class Purchase {
  private long id;
  public long getId() {
    return id;
  }
  public void setId(long id) {
    this.id = id;
  }
  @Override
  public boolean equals(Object other) {
    if (this == other) {
      return true;
    }
    else if (!(other instanceof Purchase)) {
      return false;
    }
    else {
      return ((Purchase) other).getId() == getId();
    }
  }
}

Purchase originalPurchase = new Purchase();
Purchase updatedPurchase = new Purchase();
if (originalPurchase.equals(updatedPurchase)) {
  // Execute some logic for equal purchases 
}

List<Purchase> purchases = new ArrayList<>();
purchases.add(originalPurchase);
purchases.contains(updatedPurchase); // True

if (originalPurchase == updatedPurchase) {
  // The two objects are the same objects in memory 
}

public enum BankAccountType {
  CHECKING,
  SAVINGS,
  CERTIFICATE_OF_DEPOSIT;
}
public class BankAccount {
  private final BankAccountType type;
  public BankAccount(BankAccountType type) {
    this.type = type;
  }
  public double getInterestRate() {
    switch(type) {
      case CHECKING:
        return 0.03; // 3%
      case SAVINGS:
        return 0.04; // 4%
      case CERTIFICATE_OF_DEPOSIT:
        return 0.05; // 5%
      default:
        throw new UnsupportedOperationException();
    }
  }
  public boolean supportsDeposits() {
    switch(type) {
      case CHECKING:
        return true;
      case SAVINGS:
        return true;
      case CERTIFICATE_OF_DEPOSIT:
        return false;
      default:
        throw new UnsupportedOperationException();
    }
  }
}

/**
 * Java学习交流QQ群：589809992 我们一起学Java！
 */
public interface BankAccount {
  public double getInterestRate();
  public boolean supportsDeposits();
}
public class CheckingAccount implements BankAccount {
  @Override
  public double getIntestRate() {
    return 0.03;
  }
  @Override
  public boolean supportsDeposits() {
    return true;
  }
}
public class SavingsAccount implements BankAccount {
  @Override
  public double getIntestRate() {
    return 0.04;
  }
  @Override
  public boolean supportsDeposits() {
    return true;
  }
}
public class CertificateOfDepositAccount implements BankAccount {
  @Override
  public double getIntestRate() {
    return 0.05;
  }
  @Override
  public boolean supportsDeposits() {
    return false;
  }
}

BankAccount checkingAccount = new BankAccount(BankAccountType.CHECKING);
System.out.println(checkingAccount.getInterestRate()); // Output: 0.03

BankAccount checkingAccount = new CheckingAccount();
System.out.println(checkingAccount.getInterestRate()); // Output: 0.03

public class ConditionalAccountFactory {
  public static BankAccount createCheckingAccount() {
     return new BankAccount(BankAccountType.CHECKING);
  }
}
public class PolymorphicAccountFactory {
  public static BankAccount createCheckingAccount() {
     return new CheckingAccount();
  }
}
// In both cases, we create the accounts using a factory
BankAccount conditionalCheckingAccount = ConditionalAccountFactory.createCheckingAccount();
BankAccount polymorphicCheckingAccount = PolymorphicAccountFactory.createCheckingAccount();
// In both cases, the call to obtain the interest rate is the same
System.out.println(conditionalCheckingAccount.getInterestRate()); // Output: 0.03
System.out.println(polymorphicCheckingAccount.getInterestRate()); // Output: 0.03