Object-Oriented Programming 1

// short * int        => int
// float + int        => float
// int / double       => double
// int + long * float => float
// 0.0 / 0.f          => NaN
long l = 1L;
long ll = 0b1l;
float f = 0.0f;
double d = 0.0d;
12 == '.'; // implicit int/char conversion
0.1 + 0.1 != 0.2; // true
5/2 == 2;  // true, int div truncates to 0
NaN == NaN; // false
Integer.MAX_VALUE + 1 == Integer.MIN_VALUE;
1 / 0.0 == Double.POSITIVE_INFINITY; // true
var ints = new ArrayList<Integer>();
int[] jnts = new int[69];
int[][] matrix = new int[6][9];
if (obj instanceof ArrayList<Integer>)
  ((ArrayList<Integer>)obj).add(2);
public List<String> method(
  BiFunction<Integer, String, List<String>> fn) {
  return fn.apply(5, "FooBar");
}

// explicit casting
float f = (float) 1;
// type conversion
Integer.parseInt("2");
Float.parseFloat("2.0");

static int sum(int... numbers) {
  int sum  = 0;
  for (int i = 0; i < numbers.length; i++)
    sum += numbers[i];
  return sum;
}

int[] intarr = new int[] {1, 2, 3, 4, 5};
int[] sub = Arrays.copyOfRange(intarr, 1, 3); // 2,3
var intlist = new ArrayList<Integer>();
intarr.length;
intlist.size();
// Multiply first to not lose precision
int percent = (int)((filled * 100) / capacity);
obj.clone();
Math.min(x, y);
Math.max(x, y);

s.equals(sOther);           // Strings / Objects
Arrays.equals(a1, a2);      // arrays
Arrays.deepEquals(a1, a2);  // nested arrays
class Student extends Person {
  @Override
  public boolean equals(Object obj) {
    if (obj == null) return false;
    if (getClass() != obj.getClass()) return false;
    if (!super.equals(obj)) return false;
    Student other = (Student) obj;
    return getNumber() == other.getNumber();
  }
}

String multiline = """
  Hello, "world"
""";
"a:b:c".split(":",2).length == 2; // true
String str = Integer.toString(123456789);
str.length();                     // 9
str.charAt(1);                    // 2
str.toUpperCase();
str.toLowerCase();
str.trim();
str.substring(1, 3);              // 2,3

String first = "hello", second = "hello";
System.out.println(first == second);      // true
String third = new String("hello");
String fourth = new String("hello");
System.out.println(third == fourth);      // false
System.out.println(third.equals(fourth)); // true
String a = "A", b = "B", ab = "AB";
System.out.println(a + b == ab);          // false
final String d = "D", e = "E", de = "DE";
System.out.println(d + e == de);          // true

package p1; // public class A { }
package p2; // public class A { }
// OK
import p1.A;
import p2.*;
// reference to A is ambiguous
import p1.*;
import p2.*;
// sin, PI
import static java.lang.Math.*;

// ./foo/module-info.java
module foo.bar.baz {
  exports com.my.package.foo;
}
// ./main/module-info.java
module main.module {
  requires com.my.package.foo;
}

public enum Weekday {
  MONDAY(true),
  TUESDAY(true),
  WEDNESDAY(true),
  THURSDAY(true),
  FRIDAY(true),
  SATURDAY(false),
  SUNDAY(false);
  private boolean workDay;
  Weekday(boolean workDay) { // private constructor
    this.workDay = workDay;
  }
  public boolean isWorkDay() {
    return workDay;
  }
}
switch (wd) {
  case Weekday.MONDAY:
  case Weekday.TUESDAY:
    System.out.println("First two");
    break;
  default:
    System.out.println("Rest");
}
public enum Level {
  LOW,
  MEDIUM,
  HIGH
}

switch (x) {
  case 'a':
    System.out.println("1");
    break;
  default:
    System.out.println("2");
}
int y = switch (x) {
  case 'a' -> 1;
  default -> 2;
}

super.description == ((Vehicle)this).description
super.super // doesn't exist, use v
((SuperSuperClass)this).variable
// for multiple parent interfaces v
ParentInterface1.super.defaultMethod();
// ^ executes defaultMethod on ParentInterface1
ParentInterface2.super.defaultMethod();

void print(int i, double j) { }    // 1
void print(double i, int j) { }    // 2
void print(double i, double j) { } // 3
print(1.0, 2.0);        // 3
print(1,2);// error: reference to print is ambiguous
print(1.0, 2);          // 2
print(2.0, (double) 2); // 3

class Fruit {
  void eat(Fruit f) { System.out.println("1"); }
}
class Apple extends Fruit {
  void eat(Fruit f) { System.out.println("2"); }
  void eat(Apple a) { System.out.println("3"); }
}
Apple a = new Apple();
Fruit fa = new Apple();
Fruit f = new Fruit();
a.eat(fa);            // 2
a.eat(a);             // 3
fa.eat(a);            // 2
fa.eat(fa);           // 2
f.eat(fa);            // 1
f.eat(a);             // 1
((Fruit) a).eat(fa);  // 3
((Apple) fa).eat(a);  // 2
((Apple) f).eat(a);   // ClassCastException

public abstract class Vehicle {
  private int speed;
  public abstract void drive();
  public void accelerate(int acc) {
    this.speed += acc;
  }
}
public class Car extends Vehicle {
  @Override
  public void drive() { }
  @Override
  public void accelerate (int acc) { }
}

interface RoadV {
  int MAX_SPEED = 120;
  void drive();
}
interface WaterV {
  int MAX_SPEED = 80;
  void drive();
}
class AmphibianMobile implements RoadV, WaterV {
  @Override // because ambiguous
  public void drive() {
    println(RoadV.MAX_SPEED); // MAX_SPEED ambiguous
  }
}
interface RoadV { String getModel(); }
interface WaterV { int getModel(); }
// Error, because of different return types
class AmphibianMobile implements RoadV, WaterV { }

interface Vehicle {
  default void printModel() {
     System.out.println("Undefined vehicle model");
  }
}

var v = new RoadV() {
    @Override
    public void drive() {
      System.out.println("Anon");
    }
}

public class Vehicle {
   private int speed;
   public Vehicle(int speed) {
     this.speed = speed;
   }
}
public class Car extends Vehicle {
   private int doors;
   public Car(int speed, int doors) {
      super(speed);
      this.doors = doors;
   }
}
Car c     = new Car(); // Points to Car
Vehicle v = new Car(); // Points to Car
Object o  = new Car(); // Points to Car
// ^static      ^dynamic
Car c = (Car) new Vehicle(); // ClassCastException

public class Qwer {
  public void print() {
    System.out.println("1");
  }
}
public class Asdf extends Qwer {
  @Override
  public void print() {
    System.out.println("2");
  }
  public void dostuff () { }
}
var x = new Asdf();
x.print();            // 2
((Qwer) x).print();   // 2
((Qwer) x).dostuff(); // cannot find symbol

Iterator<String> it = stringList.iterator();
while (it.hasNext()) {
  String s = it.next();
  System.out.println(s);
}

void test() throws ExceptionA, ExceptionB {
  String c = clip("asdf");
  throw new ExceptionB("wack");
}
// finally ALWAYS executes, even on unhandled Exc.
try {
  test();
} catch (ExceptionA | ExceptionB e) {
  // ...
} finally { }
try { ... } catch(NullPointerException e) {
  throw e; // -->leaves blocks-->
} catch (Exception e) {
  // above e won't get caught!
} finally {
  // will still get executed
}
1 / 0; // ArithmeticException div by zero
String s = "";
s = null;
s.toUpperCase(); // NullPointerException
int[] arr = new int[] {1, 2, 3};
int elem = arr[8]; // ArrayIndexOutOfBoundsException

try (var fr = new FileReader("text.txt")) {
  int input = fr.read();
  while (input >= 0) {
    if (input == ';') { /* do something */ }
    input = fr.read();
  }
}
try (FileWriter writer = new FileWriter("out.txt",
    StandardCharsets.UTF_8, true)) { // append
  writer.write("weeoo\n");
}
try {
  var input = new FileInputStream("text.txt");
  int i = input.read();
  while(i != -1) {
     System.out.print((char)i);
     i = input.read();
  }
  input.close();
} catch (Exception e) {
  e.printStackTrace();
}
try (BufferedReader reader = new BufferedReader(
    new FileReader("text.txt",
      StandardCharsets.UTF_8))) {
  String line;
  while ((line = reader.readLine()) != null) {
      System.out.println(line);
  }
}
try (
    FileReader reader = new FileReader("in.txt");
    FileWriter writer = new FileWriter("out.txt")
  ) {
  int i = input.read();
  while(i >= 0) {
    writer.write(i);
    i = input.read();
  }
}

try (var output = new FileOutputStream("f.txt")) {
  output.write("Hello".getBytes());
} catch (IOException e) {
  System.out.println("Error writing file");
} finally {
  System.out.println("Done");
}

class X implements Serializable { }
// Serializing
try (var stream = new ObjectOutputStream(
    new FileOutputStream("s.bin"))) {
  stream.writeObject(new X());
}
// Deserializing
try (var stream = new ObjectInputStream(
    new FileInputStream("s.bin"))) {
  X x = (X) stream.readObject();
}

public interface Function<T, R> {
  R apply(T t);
  static <T> Function<T, T> identity();
  <V> Function <T, V> andThen(
    Function<? super R, ? extends V> after);
  <V> Function <V, R> compose(
    Function<? super V, ? extends T> before);
}

public interface Predicate<T> {
  boolean test(T t);
}
static void removeAll(Collection<Person> collection,
    Predicate criterion) {
  var it = collection.iterator();
  while (it.hasNext())
    if (criterion.test(it.next()))
      it.remove();
}

public interface Comparable<T> {
  int compareTo(T obj);
}
var l = new ArrayList<Integer>(asList(3,2,4,5,1));
l.sort((a, b) -> a > b ? 1 : -1); // ==
l.sort((a, b) -> a - b);          // 1,2,3,4,5
class Person implements Comparable<Person> {
  private final String firstName, lastName;
  @Override
  public int compareTo(Person other) {
    int result = lastName.compareTo(other.lastName);
    if (result == 0)
      result = firstName.compareTo(other.firstName);
    return result;
  }
  static int compareByAge(Person a, Person b) {
    return Integer.compare(a.getAge(), b.getAge());
  }
}
List<Person> people = ...;
Collections.sort(people);
people.sort(Person::compareByAge);