More OOP

public interface Demo{
	int a = 5;
	void bar();
	void foo(){ }		// invalid; should've no body
}

public abstract interface Demo{
	public static final int a = 5;
	public abstract void bar();
}

public interface Demo extends Foo, Bar {	}		// Foo and Bar are interfaces

public class X implements Y, Z {	} 		// Y and Z are interfaces

public class A extends B implements C, D {	} 		// both inheriting and implementing

interface Test{
    public void foo();
}
class Super{
    public void foo(){ }		// implementation in superclass
}
public class MyClass extends Super implements Test {		// subclass inherits a foo() implementation
    public static void main(String args[]) {
    new MyClass();
    System.out.println("Test");
    }
}

// compiles fine

interface Test{
    public void foo();
}
class Super{
    public int foo(){ return 1; }		// incompatible return type
}
public class MyClass extends Super implements Test {	// subclass doesn't have a "void foo()" impl
    public static void main(String args[]) {
    new MyClass();
    System.out.println("Test");
    }
}

// compiler error

interface Demo{
	int a = 5;		// "public static final" implicitly; must initialize inline
}

class Main implements Demo{
	public static void main(String[] args){
		System.out.println(a);			// 5 (inherited)
		System.out.println(Main.a);		// 5 (same as above)
		System.out.println(Demo.a);		// 5
	}
}

interface X{
	default int foobar(){
		return 2;
	}
}

class Demo implements X{
	foobar();		// avaliable to class
}

interface P{
	static void foobar(){ }
}

// interface to interface - inheritance
interface C extends P{
	static int foobar() { return 0; }	// valid; since static method wasn't inherited
}

// interface to class - implementation
class Main implements P{
	foobar();		// invalid
	Main.foobar();	// invalid
	P.foobar();		// valid
}

interface P{
    void foo();
}

interface Q extends P{
    default void foo(){ }		// valid; foo gets impl
}

----------------------------------

interface P{
    void foo();
}

interface Q extends P{
    static void foo(){ }		// compiler-error; static method method cannot override an abstract method; since it won't be going to the implementing class anyways even if we accept its impl here
}

interface X{
	
	private String foobar(){	// allowed to have a body
		return "lorem ipsum";
	}

	private static String foobar(){		// same; allowed to have a body
		return "lorem ipsum";
	}
}

interface X{
	String foo();
	String bar();

	void foobar(){
		return foo()+bar();
	}
}

// when we call them, there will be an instance of the class implemeting the interface so it's safe

enum Days{ MON, TUE, WED, THURS FRI, SAT, SUN; }		// semi-colon is optional for simple enums

Days s = Days.TUE;
System.out.println(Days.TUE);		// TUE
System.out.println(s == Days.TUE);	// true

Days.TUE == 1		// error; comparing (TUE == 1) doesn't make any sense

for(var d: Days.values()){
	System.out.println(d.name() + " " + d.ordinal());
}

/*
MON 0
TUE 1
WED 2
...
*/

Days d = Days.valueOf("TUE");	// TUE

// bare-minimum complex enum
enum Alphabet {
    A("Z"), 
    B("Y"),
    C("X");

    Alphabet(String a) { }		// mandatory for complex enums; can only be private or package-access

    // create an optional instance field and set its value in the constructor
    // create and use its getter to access - "Z", "Y", "X"
}

// multiple-constants complex enum
enum Alphabet {
    A("Z", 26), 
    B("Y", 25),
    C("X", 24);

    Alphabet(String s, Integer i) { }
}

public enum Season{
	WINTER("Low"), SPRING("Medium"), SUMMER("High");	// constructor calls to initialize
	// ; not optional, values always comes before construtors, methods

	public final String expVis;		// optional field to set to and access value "Low"/"Medium"/"High", can be non-final too but bad practice

	private Season(String expVis){		// mandatory constructor, always implicitly private, runs only on first access to a constant, never runs again on subsequent accesses
		this.expVis = expVis;	 	// important; set value to enum instance var
	}

	public void getExpVis(){				// getter method
		System.out.println(expVis);
	}
}

Season s = Season.SUMMER;			// RHS is a constructor call but without "new", LHS is reference variable assignment
System.out.println(Season.SUMMER);	 // SUMMER

System.out.println(Season.SUMMER.ordinal());	// 2	

Season.SUMMER.printExpVis(); 	// enum method call

s.getExpVis();					// "High"; enum method call with reference object
s.expVis;						// "High"; enum instance variable direct access

public enum Seasons{
	WINTER { public int getTemp(){ return 5;  } },		// override
	SPRING { public int getTemp(){ return 25; } };		// override
	public abstract int getTemp();						// abstract method (override is a must)
}

public enum Seasons{
	WINTER { public int getTemp(){ return 5;  } },		// override
	SPRING { public int getTemp(){ return 25; } },		// override
	SUMMER, FALL;										// use shared method for these
	public int getTemp(){ return 30; }					// method shared by all (override is optional)
}

sealed class Demo permits Foo, Bar{ }		// sealed parent
final class Foo extends Demo { }			// final child (no inheritance possible)
non-sealed class Bar extends Demo{ }		// non-sealed child (can be inherited by any other classes)

record Demo(int foo, String bar){ }

record DemoEmpty(){ }

public interface Foobar{ }
public record Demo(int foo, String bar) implements Foobar{ }

public record Demo(int foo, String bar){
	public Demo{									// notice no parentheses ()
		bar = bar.substring(0, 1).toUpperCase();			// modification to constructor argument only
		this.foo = foo;			// compiler-error; foo is final in instance yet to be created
		if(foo < 0) throw new IllegalArgumentException();	// validation
	}
}

public record Demo(int foo, String bar){
	public Demo(String foo, String bar){		// overloaded constructor; notice types
		this(0, foo+bar);
		foo = "John";			// modifies constructor argument
		this.bar = "Doe";		// compiler error
	}
}

public record Demo(int foo, String bar){
	public int foo(){ return 10; }
	public String toString(){ return "Testing..."; }
}

record Demo(String name, int age){
    static final int marks = 5;
}

--------------------------------------

record Demo(String name, int age){
    static final int marks;

    static { marks = 5; }
}

// access from anywhere using: Demo.marks

// from within outer class
class Out{
	class In{	}
	
	void createObj(){
		var obj = new In();
	}
}

// from out of both classes
class Out{
	class In{
		void say(){ }
	}
}
class My{
public static void main(String args[]){
	Out o = new Out();
	In i = o.new In();					// new syntax
	i.say();
	}
}

//we can also use
new Out().new In().say();


// class files for nested classes
Out.class
Out$In.class

class Out{
	class In{ }				// non-static member
		public static void main(String args[]){
			new In();		// error; accessing non-static from static context
		}
}

class Out{
	class In{ }
		public static void main(String args[]){
			Out o = new Out();
			o.new In();		// instance reference provided; no errors
		}
}

class Out{
	static class In{ }
		public static void main(String args[]){
			new In();		// no error since we are accessing from static context
		}
}

void foo(){
	final int a = 5;
	int b = 6;
	int c = 7;
	class In{
		void bar(){ System.out.println(a+b+c); }		// error; c isn't final or effectively final
	}

	c = 8;
}

Demo d = new Demo(){			// anon class extends "Demo" class

	// define our own members and methods inside
	// just like a typical class
	int getCost(){ return 5; }
};

class Demo(){ }
Demo o = new Demo(){ };		// extends
Foobar o = new Foobar(1, "abc"){ };		// extends; with parameterized constructor of superclass

interface Demo(){ }
Demo o = new Demo(){ };		// implements "Demo" interface

class Super{ }

// anon class in main()
Super s = new Super(){
	void getSup(){ }
};

s.getSup();		// compiler-error; cannot resolve method

public class X{
	public char foo(){
		return 'A';
	}
}

public interface Y{
	public abstract char bar(); 
}

public class Z extends X implements Y{
	char n = 'C';
	char bar(){ return 'B'; }
}

Z o = new Z();				// self ref
o.bar();					// B
System.out.println(o.n);	// C

Y p = o;					// interface ref
p.bar();					// B
p.n;						// error

X q = p;					// parent ref
System.out.println(o.n);	// error
q.foo();					// A
q.bar();					// error

// Only one object was created in heap memory, but we see so many access levels depending on ref variable we use to access it

Dog d = new Dog();
Cat c = d;	// error; incompatible types: Dog can't be called a Cat

// Casting
Child c = new Child();

Parent p = c;		 // implicit cast to supertype, storing in ref of Parent

Child c2 = p;		 // error (can't cast from super type to subtype even if object is Child's)

Child c3 = (Child)p; // explicit cast to subtype; p is Child's object only, but stored in ref of Parent, that's why this explicit cast works otherwise compiler error


// a ClassCastException is thrown at runtime if they're NOT COMPATIBLE and explicit cast is used like in the below example
Object i = Integer.valueOf(42);
String s = (String) i;            // ClassCastException thrown here


// compiler throws error on UNRELATED type casts like in the below example
class Foo{ }

class Bar{
	public static void main(String args[]){
		Foo o1 = new Foo();
		Bar o2 = (Bar)o1;			// error; unrelated class objects
	}
}

public interface FourLegged{ }
public interface Canine{ }

public class Wolf implements Canine{ }

Canine c = new Wolf();					// or Wolf w = new Wolf();
FourLegged dog = (FourLegged)c;			// compiles just fine; even tho both interface are unrelated

// throws ClassCastException at runtime

// in the above case, class Wolf may have a subclass Dog which implements FourLegged interface, in that case above will be valid if "Canine c = new Dog();"
// this is why it is allowed to compile; since that subclass will be both a "Canine" and a "FourLegged" (multiple inheritance using interface)

// EXCEPTION - if class is marked "final" then the compiler will know that there are no possible subclasses that might implement an interface we are casting to, so in that case it leads to a compile-time error

// instanceof operator checks for compatible types and returns boolean; prevents ClassCastException at runtime

if(obj instanceof FoobarClass){ }

// applying it to unrelated types leads to compile-time error

// instanceof on null always returns false
null instanceof String
// false