Add Java OOP (part I) code snippets

02-oop-in-java-i/snippets/README.md

@@ -0,0 +1 @@
+# OOP in Java (part I) / Code snippets

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/adorable/AbstractCoolPerson.java

@@ -0,0 +1,7 @@
+package bg.sofia.uni.fmi.mjt.adorable;
+
+public abstract class AbstractCoolPerson implements Adorable {
+
+ // We are not required to implement the methods in an abstract class.
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/adorable/Adorable.java

@@ -0,0 +1,8 @@
+package bg.sofia.uni.fmi.mjt.adorable;
+
+interface Adorable extends Likeable, Lovable {
+
+ // This interface inherits both like() and love() methods and does not define new methods.
+ // Any class that will implement it, is required to implement both like() and love(), or declare itself as abstract.
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/adorable/CoolPerson.java

@@ -0,0 +1,17 @@
+package bg.sofia.uni.fmi.mjt.adorable;
+
+public class CoolPerson implements Adorable {
+ // If we do not implement all Adorable methods, we will get a compile-time error:
+ // "CoolPerson is not abstract and does not override abstract method like() in Likeable"
+
+ @Override
+ public void like() {
+ System.out.println("I am liked!");
+ }
+
+ @Override
+ public void love() {
+ System.out.println("I am loved!");
+ }
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/adorable/Likeable.java

@@ -0,0 +1,7 @@
+package bg.sofia.uni.fmi.mjt.adorable;
+
+interface Likeable {
+
+ void like();
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/adorable/Lovable.java

@@ -0,0 +1,7 @@
+package bg.sofia.uni.fmi.mjt.adorable;
+
+interface Lovable {
+
+ void love();
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/instanceoff/InstanceOfExample.java

@@ -0,0 +1,59 @@
+package bg.sofia.uni.fmi.mjt.instanceoff;
+
+class Shape {
+ void draw() {
+ System.out.println("Drawing a shape");
+ }
+}
+
+class Circle extends Shape {
+ @Override
+ void draw() {
+ System.out.println("Drawing a circle");
+ }
+}
+
+class Rectangle extends Shape {
+ @Override
+ void draw() {
+ System.out.println("Drawing a rectangle");
+ }
+}
+
+public class InstanceOfExample {
+
+ public static void main(String[] args) {
+ Shape[] shapes = new Shape[]{
+ new Circle(),
+ new Rectangle(),
+ new Circle(),
+ new Rectangle(),
+ };
+
+ // old-school way:
+ for (Shape shape : shapes) {
+ if (shape instanceof Circle) {
+ System.out.println("Circle detected:");
+ Circle circle = (Circle) shape; // Cast to Circle
+ circle.draw();
+ } else if (shape instanceof Rectangle) {
+ System.out.println("Rectangle detected:");
+ Rectangle rectangle = (Rectangle) shape; // Cast to Rectangle
+ rectangle.draw();
+ } else {
+ System.out.println("Unknown shape detected.");
+ shape.draw();
+ }
+ }
+
+ // equivalent with enhanced switch
+ for (Shape shape : shapes) {
+ switch (shape) {
+ case Circle c -> c.draw();
+ case Rectangle r -> r.draw();
+ default -> System.out.println("Unexpected value: " + shape);
+ }
+ }
+ }
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/lockable/DefaultInterfaceExamples.java

@@ -0,0 +1,29 @@
+package bg.sofia.uni.fmi.mjt.lockable;
+
+public class DefaultInterfaceExamples {
+
+ public static void main(String... args) {
+
+ Door door = new Door();
+ Lockable anotherDoor = new Door();
+ Lockable safe = new Safe();
+ anotherDoor.lock(); // Door locked.
+ System.out.println(safe.isLocked()); // false
+ System.out.println(door.isLocked()); // true
+
+ Object obj = new Safe();
+ Lockable lockable = Lockable.getInstance(true);
+
+ // classic instanceof: explicit cast is needed in the if body
+ if (obj instanceof Lockable) {
+ ((Lockable) obj).lock(); // Safe locked.
+ }
+
+ // New in Java 17: pattern matching for instanceof
+ if (lockable instanceof Door d) {
+ d.lock(); // Door locked.
+ }
+
+ }
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/lockable/Door.java

@@ -0,0 +1,15 @@
+package bg.sofia.uni.fmi.mjt.lockable;
+
+public class Door implements Lockable, OldLockable {
+
+ @Override
+ public void lock() {
+ System.out.println("Door locked.");
+ }
+
+ @Override
+ public boolean isLocked() {
+ return true;
+ }
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/lockable/Lockable.java

@@ -0,0 +1,21 @@
+package bg.sofia.uni.fmi.mjt.lockable;
+
+public interface Lockable {
+
+ void lock();
+
+ default boolean isLocked() {
+ return false;
+ }
+
+ // Static factory method: typical use of static methods in interfaces.
+ // Keep calm - will learn what Factory is in the Design Patterns lecture
+ static Lockable getInstance(boolean isDoor) {
+ if (isDoor) {
+ return new Door();
+ } else {
+ return new Safe();
+ }
+ }
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/lockable/OldLockable.java

@@ -0,0 +1,9 @@
+package bg.sofia.uni.fmi.mjt.lockable;
+
+public interface OldLockable {
+
+ default boolean isLocked() {
+ return true;
+ }
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/lockable/Safe.java

@@ -0,0 +1,17 @@
+package bg.sofia.uni.fmi.mjt.lockable;
+
+public class Safe implements Lockable, OldLockable {
+
+ @Override
+ public void lock() {
+ System.out.println("Safe locked.");
+ }
+
+ @Override
+ public boolean isLocked() {
+ // We will get a compile-time error, if we don't override the isLocked() method here:
+ // - "Safe inherits unrelated defaults for isLocked() from types Lockable and OldLockable"
+ return Lockable.super.isLocked();
+ }
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/overridings/Audi.java

@@ -0,0 +1,5 @@
+package bg.sofia.uni.fmi.mjt.overridings;
+
+public class Audi extends Car {
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/overridings/AudiGarage.java

@@ -0,0 +1,23 @@
+package bg.sofia.uni.fmi.mjt.overridings;
+
+public class AudiGarage extends Garage {
+
+ public AudiGarage() {
+ // Note that parent default constructor will be invoked prior to this one.
+ // Calling it explicitly with super() here will have the same effect
+ System.out.println("Audi garage constructed");
+ }
+
+ public static void main(String... args) { // varargs syntax
+ new AudiGarage();
+ }
+
+ @Override
+ public Audi repair(Car c) {
+ // 1. access modifier upgraded from protected to public. Trying to reduce it to private will not compile
+ // 2. covariant return type: overriden method in parent returns Car
+ // 3. signature remains identical: otherwise, with the @Override annotation in place, will not compile
+ return new Audi();
+ }
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/overridings/Car.java

@@ -0,0 +1,5 @@
+package bg.sofia.uni.fmi.mjt.overridings;
+
+public class Car {
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/overridings/Garage.java

@@ -0,0 +1,22 @@
+package bg.sofia.uni.fmi.mjt.overridings;
+
+public class Garage {
+
+ public Garage() {
+ System.out.println("Garage constructed");
+ }
+
+ protected Car repair(Car c) {
+ return new Car();
+ }
+
+ public Car repair(Car c, String customerName) {
+ // overloaded method:
+ // 1. access modifier may be any
+ // 2. return type may be any
+ // 3. name should be identical
+ // 4. parameter list should be different
+ return this.repair(c); // "this." is optional here
+ }
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/statics/MethodHidingExample.java

@@ -0,0 +1,41 @@
+package bg.sofia.uni.fmi.mjt.statics;
+
+class Parent {
+ void display() {
+ System.out.println("Non-static method in Parent");
+ }
+
+ static void staticDisplay() {
+ System.out.println("Static method in Parent");
+ }
+}
+
+class Child extends Parent {
+ @Override
+ void display() {
+ System.out.println("Non-static method in Child");
+ }
+
+ static void staticDisplay() {
+ System.out.println("Static method in Child (Hidden)");
+ }
+}
+
+public class MethodHidingExample {
+ public static void main(String[] args) {
+ Parent parent = new Parent();
+ Parent childAsParent = new Child();
+ Child child = new Child();
+
+ parent.display(); // Output: Non-static method in Parent
+ childAsParent.display(); // Output: Non-static method in Child
+
+ parent.staticDisplay(); // Output: Static method in Parent; same as calling Parent.staticDisplay();
+ childAsParent.staticDisplay(); // Output: Static method in Parent, because the reference type is Parent; same as calling Parent.staticDisplay();
+ child.staticDisplay(); // Output: Static method in Child (Hidden), because the reference type is Child;same as calling Child.staticDisplay();
+
+ // In summary - static methods belong to the class and no overriding is possible -
+ // it's possible to redefine the same method in the child class, but that's not overriding.
+ }
+}
+

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/statics/Project.java

@@ -0,0 +1,40 @@
+package bg.sofia.uni.fmi.mjt.statics;
+
+public class Project {
+
+ private static final String PROJECT_PREFIX = "proj-"; // constant
+ private static int totalProjectInstances;
+
+ private String name;
+
+ public Project() {
+ // We can use static variable to count the number of Project instances created.
+ // All instances of Project will share the same copy of the variable.
+
+ name = PROJECT_PREFIX + totalProjectInstances++;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public static int getTotalProjectInstances() {
+ return totalProjectInstances;
+ }
+
+ // We cannot use instance variables/methods in static methods because
+ // static methods are not bound to any instance, but rather to the class itself
+ // Uncommenting the method below will not compile:
+ // "non-static variable name cannot be referenced from a static context"
+
+ //public static void printName() {
+ // System.out.println(name);
+ //}
+
+ public static void main(String... s) {
+ System.out.println(new Project().getName());
+ System.out.println(new Project().getName());
+ System.out.println(new Project().getName());
+ }
+
+}

02-oop-in-java-i/snippets/src/bg/sofia/uni/fmi/mjt/suuper/SuperExample.java

@@ -0,0 +1,40 @@
+package bg.sofia.uni.fmi.mjt.suuper;
+
+class Parent {
+ int parentValue;
+
+ Parent(int parentValue) {
+ this.parentValue = parentValue;
+ }
+
+ void displayParent() {
+ System.out.println("Parent value: " + parentValue);
+ }
+}
+
+class Child extends Parent {
+ int childValue;
+
+ Child(int parentValue, int childValue) {
+ super(parentValue); // Call the superclass constructor
+ this.childValue = childValue;
+ }
+
+ void displayChild() {
+ System.out.println("Child value: " + childValue);
+ }
+
+ void displayParentAndChild() {
+ super.displayParent(); // Call the parent class method using super
+ displayChild();
+ }
+}
+
+public class SuperExample {
+ public static void main(String[] args) {
+ Child child = new Child(10, 20);
+
+ child.displayParentAndChild();
+ }
+}
+