Java,
Week 4

public abstract class Shape {
    public abstract double perimeter();
}

public class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double perimeter() {
        return 2 * Math.PI * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape[] shapearr = new Shape[3];
        double[] sizearr = new double[3];

        shapearr[0] = new Circle(1);
        shapearr[1] = new Square(2);
        shapearr[2] = new Rectangle(2, 3);

        for (int i = 0; i < 3; ++i) {
            sizearr[i] = shapearr[i].perimeter();   // each object runs its own perimeter()
            System.out.println(sizearr[i]);
        }
    }
}

6.283185307179586
8.0
10.0

public abstract class Square extends Shape {
    protected double side = 2;

    public double perimeter() {
        return 4 * side;
    }
    // area() still missing: fine, because Square is abstract too
}

public class Unit extends Square {
    public double area() {
        return side * side;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape s = new Unit();
        System.out.println(s.perimeter() + " " + s.area());
    }
}

8.0 4.0

public class Main {
    public static void main(String[] args) {
        Shape s;                       // a variable of an abstract type: fine
        s = new Circle(1);             // it can refer to any concrete subclass object
        System.out.println(s.perimeter());
        System.out.println(s instanceof Circle);
    }
}

6.283185307179586
true

public abstract class Shape {
    private String name;

    public Shape(String name) {                 // an abstract class can have a constructor
        this.name = name;
    }

    public abstract double perimeter();         // the part every subclass must supply

    public String describe() {                  // a normal method, already written
        return name + " with perimeter " + perimeter();
    }
}

public class Main {
    public static void main(String[] args) {
        Shape s = new Square(2);
        System.out.println(s.describe());
    }
}

Square with perimeter 8.0

public class Main {
    public static void main(String[] args) {
        Shape s = new Square(2);            // an abstract class is built as part of its subclass object
        System.out.println(s.perimeter());
    }
}

Shape constructor
Square constructor
8.0

public abstract class Comparable {
    public abstract int cmp(Comparable s);
    // return -1 if this < s
    // return 0  if this == s
    // return 1  if this > s
}

public class SortFunctions {
    public static void quicksort(Comparable[] a) {
        quicksort(a, 0, a.length - 1);
    }

    private static void quicksort(Comparable[] a, int lo, int hi) {
        if (lo >= hi) return;
        Comparable pivot = a[hi];
        int p = lo;
        for (int i = lo; i < hi; ++i) {
            if (a[i].cmp(pivot) < 0) {         // compare with cmp(), nothing else
                Comparable t = a[i]; a[i] = a[p]; a[p] = t;
                ++p;
            }
        }
        Comparable t = a[p]; a[p] = a[hi]; a[hi] = t;
        quicksort(a, lo, p - 1);
        quicksort(a, p + 1, hi);
    }
}

public class Myclass extends Comparable {
    private double size;          // quantity used for comparison

    public Myclass(double size) {
        this.size = size;
    }

    public double getSize() {
        return size;
    }

    public int cmp(Comparable s) {
        if (s instanceof Myclass) {
            double other = ((Myclass) s).size;     // cast, to reach s.size
            if (this.size < other) return -1;
            if (this.size > other) return 1;
            return 0;
        }
        return 0;
    }
}

public class Main {
    public static void main(String[] args) {
        Myclass[] a = { new Myclass(3.5), new Myclass(1.25), new Myclass(9), new Myclass(2) };
        SortFunctions.quicksort(a);
        for (Myclass m : a) {
            System.out.println(m.getSize());
        }
    }
}

1.25
2.0
3.5
9.0

public class Main {
    public static void main(String[] args) {
        System.out.println(Comparable.class.getName());
        System.out.println(java.lang.Comparable.class.getName());
        System.out.println("abc".compareTo("abd"));   // the real one: compareTo, not cmp
    }
}

Comparable
java.lang.Comparable
-1

public interface Comparable {
    public abstract int cmp(Comparable s);
}

public class Circle extends Shape implements Comparable {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double perimeter() {
        return 2 * Math.PI * radius;
    }

    public int cmp(Comparable s) {
        Circle other = (Circle) s;
        return Double.compare(this.perimeter(), other.perimeter());
    }
}

public class Main {
    public static void main(String[] args) {
        Circle[] c = { new Circle(3), new Circle(1), new Circle(2) };
        SortFunctions.quicksort(c);                 // a Circle[] is a Comparable[]
        for (Circle x : c) {
            System.out.println(x.perimeter());
        }
    }
}

6.283185307179586
12.566370614359172
18.84955592153876

public class Circle extends Shape implements Comparable, Printable {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double perimeter() {
        return 2 * Math.PI * radius;
    }

    public int cmp(Comparable s) {
        return Double.compare(perimeter(), ((Circle) s).perimeter());
    }

    public void print() {
        System.out.println("Circle, perimeter " + perimeter());
    }
}

public class Main {
    public static void main(String[] args) {
        Circle c = new Circle(1);
        Shape s = c;          // a Circle is a Shape
        Comparable k = c;     // ... and a Comparable
        Printable p = c;      // ... and a Printable
        p.print();
        System.out.println(s instanceof Comparable);
    }
}

Circle, perimeter 6.283185307179586
true

public class Main {
    public static void main(String[] args) {
        Employee[] e = { new Employee("Ravi", 2000), new Employee("Asha", 1000), new Employee("Meena", 1500) };
        SortFunctions.quicksort(e);
        for (Employee x : e) System.out.println(x.getName());

        Dnum[] d = { new Dnum(30), new Dnum(10), new Dnum(20) };
        SortFunctions.quicksort(d);                  // same function, a completely different type
        for (Dnum x : d) System.out.println(x.value);
    }
}

Asha
Meena
Ravi
10
20
30

public interface Limits {
    int MAX = 100;                  // implicitly public static final
}

public class Main implements Limits {
    public static void main(String[] args) {
        System.out.println(MAX);
        System.out.println(Limits.MAX);
    }
}

100
100

public interface Comparable {
    public abstract int cmp(Comparable s);

    public static String cmpdoc() {
        String s;
        s = "Return -1 if this < s, ";
        s += "0 if this == s, ";
        s += "+1 if this > s.";
        return s;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Comparable.cmpdoc());
    }
}

Return -1 if this < s, 0 if this == s, +1 if this > s.

public interface Comparable {
    public default int cmp(Comparable s) {
        return 0;                       // default: everything is "equal"
    }
}

public class Dnum implements Comparable {
    public int value;

    public Dnum(int value) {
        this.value = value;
    }

    @Override
    public int cmp(Comparable s) {        // overrides the default
        return Integer.compare(value, ((Dnum) s).value);
    }
}

public class Main {
    public static void main(String[] args) {
        Comparable p = new Plain();
        System.out.println(p.cmp(new Plain()));            // the default runs

        Comparable a = new Dnum(1);
        System.out.println(a.cmp(new Dnum(5)));            // the override runs
    }
}

0
-1

public class C implements I1, I2 {
    @Override
    public String hello() {                       // a fresh implementation
        return "C picks: " + I1.super.hello();    // or write something brand new
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new C().hello());
    }
}

C picks: from I1

public class Person {
    public String getName() {
        return "No name";
    }
}

public interface Designation {
    public default String getName() {
        return "No designation";
    }
}

public class Employee extends Person implements Designation {
}

public class Main {
    public static void main(String[] args) {
        Employee e = new Employee();
        System.out.println(e.getName());
        Designation d = e;                       // through the interface type: still the class's method
        System.out.println(d.getName());
    }
}

No name
No name

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("Asha");
        names.add("Ravi");
        names.forEach(n -> System.out.println("hello " + n));    // forEach is a default method of Iterable
    }
}

hello Asha
hello Ravi

public class Employee {
    private String name;
    private double salary;
    private Date joinDate;              // a nested object: an instance variable of a user defined type

    public Employee(String name, double salary, Date joinDate) {
        this.name = name;
        this.salary = salary;
        this.joinDate = joinDate;
    }

    public String toString() {
        return name + " joined on " + joinDate;
    }
}

public class Main {
    public static void main(String[] args) {
        Employee e = new Employee("Asha", 1000, new Date(14, 1, 2022));
        System.out.println(e);
    }
}

Asha joined on 14-1-2022

public class Node {
    public Object data;
    public Node next;

    public Node(Object data) {
        this.data = data;
    }
}

public class Main {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.insert("a");
        list.insert("b");
        list.insert("c");
        System.out.println(list.head());     // the most recently inserted comes out first
        System.out.println(list.head());
        System.out.println(list.size());

        Node loose = new Node("anyone can build a node");   // Node is public: other code can use it
        loose.next = loose;                                 // ... and even tie it into a loop
        System.out.println(loose.next.data);
    }
}

c
b
1
anyone can build a node

public class LinkedList {
    private class Node {
        private Object data;
        private Node next;

        private Node(Object data) {
            this.data = data;
        }
    }

    private int size;
    private Node first;

    public Object head() {
        Object returnval = null;
        if (first != null) {
            returnval = first.data;      // the outer class may read Node's private fields
            first = first.next;
            size--;
        }
        return returnval;
    }

    public void insert(Object newData) {
        Node n = new Node(newData);
        n.next = first;
        first = n;
        size++;
    }

    public int size() {
        return size;
    }
}

public class Main {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.insert("a");
        list.insert("b");
        list.insert("c");
        System.out.println(list.head());
        System.out.println(list.head());
        System.out.println(list.size());
    }
}

c
b
1

public class Counter {
    private int count = 0;                       // private to Counter

    private class Step {
        void bump() {
            count++;                              // the inner class reaches the outer private field
            System.out.println("count is now " + Counter.this.count);
        }
    }

    public void run() {
        Step s = new Step();
        s.bump();
        s.bump();
    }
}

public class Main {
    public static void main(String[] args) {
        new Counter().run();
    }
}

count is now 1
count is now 2

public class Outer {
    private int x = 7;

    private class Inner {                 // ordinary inner class: tied to one Outer object
        int twice() { return 2 * x; }
    }

    private static class Plain {           // static nested class: no Outer object needed
        int five() { return 5; }
    }

    public void show() {
        Inner a = new Inner();
        Plain b = new Plain();
        System.out.println(a.twice());
        System.out.println(b.five());
    }
}

14
5

public class Main {
    public static void main(String[] args) {
        Outer o = new Outer();
        Outer.Inner in = o.new Inner();             // an inner object needs an outer object
        in.show();
    }
}

inner
inner
outer

public class Main {
    public static void main(String[] args) {
        Date d = new Date();
        d.setDay(31);
        d.setMonth(1);
        d.setYear(2024);          // 31 January: fine
        d.setMonth(4);            // now it says 31 April, and nothing stopped us
        System.out.println(d);
    }
}

31-4-2024

public interface QIF {
    public abstract int getStatus(int trainno, Date d);
}

public class RailwayBooking {
    private BookingDB railwayDB = new BookingDB();

    private boolean validLogin(String u, String p) {
        return u.equals("asha") && p.equals("secret");
    }

    public QIF login(String u, String p) {          // the caller only ever sees the interface
        if (validLogin(u, p)) {
            return new QueryObject();
        }
        return null;
    }

    private class QueryObject implements QIF {
        public int getStatus(int trainno, Date d) {
            return railwayDB.seatsOn(trainno, d);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        RailwayBooking rb = new RailwayBooking();
        QIF q = rb.login("asha", "secret");
        System.out.println(q.getStatus(12627, new Date(14, 1, 2022)));
        System.out.println(rb.login("asha", "wrong"));      // a failed login gives no object at all
    }
}

27
null

public class RailwayBooking {
    private BookingDB railwayDB = new BookingDB();

    private boolean validLogin(String u, String p) {
        return u.equals("asha") || u.equals("ravi");
    }

    public QIF login(String u, String p) {
        if (validLogin(u, p)) {
            return new QueryObject(2);                 // each login gets its own object, limit 2
        }
        return null;
    }

    private class QueryObject implements QIF {
        private int numQueries;
        private final int QLIM;

        private QueryObject(int limit) {
            QLIM = limit;
        }

        public int getStatus(int trainno, Date d) {
            if (numQueries < QLIM) {
                numQueries++;                          // remember the state of the interaction
                return railwayDB.seatsOn(trainno, d);
            }
            return -1;                                 // quota used up
        }
    }
}

public class Main {
    public static void main(String[] args) {
        RailwayBooking rb = new RailwayBooking();
        Date d = new Date(14, 1, 2022);

        QIF asha = rb.login("asha", "x");
        QIF ravi = rb.login("ravi", "x");

        System.out.println(asha.getStatus(12627, d));
        System.out.println(asha.getStatus(12627, d));
        System.out.println(asha.getStatus(12627, d));     // third query: refused
        System.out.println(ravi.getStatus(12628, d));     // Ravi has his own counter
    }
}

27
27
-1
28

public class MyClass {
    public void f() throws InterruptedException {
        Timer t = new Timer(this);                 // this object created t
        Thread th = new Thread(t);                 // (extra) a thread so that t runs in parallel
        th.start();                                // start t
        System.out.println("f: timer started, f carries on");
        th.join();                                 // (extra) wait, so the output order is fixed
    }

    public void timerDone() {
        System.out.println("MyClass.timerDone() called");
    }
}

public class Timer implements Runnable {
    // Timer can be invoked in parallel
    private MyClass owner;

    public Timer(MyClass o) {
        owner = o;                                 // creator
    }

    public void run() {
        try {
            Thread.sleep(100);                     // the "time limit"
        } catch (InterruptedException e) { }
        owner.timerDone();                         // notify the owner
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        new MyClass().f();
    }
}

f: timer started, f carries on
MyClass.timerDone() called

public interface TimerOwner {
    public abstract void timerDone();
}

public class Timer implements Runnable {
    private TimerOwner owner;

    public Timer(TimerOwner o) {
        owner = o;
    }

    public void run() {
        try { Thread.sleep(100); } catch (InterruptedException e) { }
        owner.timerDone();                         // no cast, no guessing the class
    }
}

public class MyClass implements TimerOwner {
    public void f() throws InterruptedException {
        Timer t = new Timer(this);
        Thread th = new Thread(t);
        th.start();
        System.out.println("f: timer started, f carries on");
        th.join();
    }

    public void timerDone() {
        System.out.println("MyClass.timerDone() called");
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        new MyClass().f();

        // owner need not be the object that created the Timer
        Thread th = new Thread(new Timer(new Other()));
        th.start();
        th.join();
    }
}

f: timer started, f carries on
MyClass.timerDone() called
Other.timerDone() called

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // TimerOwner has one abstract method, so a lambda can stand in for the object
        Thread th = new Thread(new Timer(() -> System.out.println("done, said a lambda")));
        th.start();
        th.join();
    }
}

done, said a lambda

public class Main {
    public static void main(String[] args) {
        TimerOwner o = new TimerOwner() {                  // an object of an unnamed class
            public void timerDone() {
                System.out.println("done, said an anonymous class");
            }
        };
        o.timerDone();
    }
}

done, said an anonymous class

public class LinearList {
    // Array implementation
    private int limit = 100;
    private Object[] data = new Object[limit];
    private int size;

    public LinearList() { size = 0; }

    public void append(Object o) {
        data[size++] = o;
    }
}

int i;
for (i = 0; i < data.length; ++i) {
    ...  // do something with data[i]
}

Node m;
for (m = head; m != null; m = m.next) {
    ...  // do something with m.data
}

Start at the beginning of the list
while (there is a next element) {
    get the next element;
    do something with it
}

public interface Iterator {
    public abstract boolean has_next();
    public abstract Object get_next();
}

public class LinearList {
    private Node head;
    private int size;

    public LinearList() { size = 0; }

    public void append(Object o) {
        Node n = new Node(o);
        if (head == null) {                      // the empty list needs its own case
            head = n;
        } else {
            Node m = head;
            while (m.next != null) m = m.next;
            m.next = n;
        }
        size++;
    }

    private class Node {
        private Object data;
        private Node next;

        private Node(Object data) {
            this.data = data;
        }
    }

    private class Iter implements Iterator {
        private Node position;                   // remembers where this iterator is

        public Iter() {
            position = head;
        }

        public boolean has_next() {
            return position != null;
        }

        public Object get_next() {
            Object o = position.data;
            position = position.next;
            return o;
        }
    }

    // export a fresh iterator
    public Iterator get_iterator() {
        Iter it = new Iter();
        return it;
    }
}

public class Main {
    public static void main(String[] args) {
        LinearList l = new LinearList();
        l.append("A");
        l.append("B");
        l.append("C");

        Object o;
        Iterator i = l.get_iterator();
        while (i.has_next()) {
            o = i.get_next();
            System.out.println(o);
        }
    }
}

A
B
C

public class Main {
    public static void main(String[] args) {
        Bad l = new Bad();
        while (l.hasNext()) {
            String oi = l.next();
            // the inner loop uses the same pointer, so it eats the rest of the list
            while (l.hasNext()) {
                System.out.println(oi + "," + l.next());
            }
        }
    }
}

A,B
A,C

public class LinearList {
    private int limit = 100;
    private Object[] data = new Object[limit];
    private int size;

    public LinearList() { size = 0; }

    public void append(Object o) {
        data[size++] = o;
    }

    private class Iter implements Iterator {
        private int position = 0;                // an index this time, not a node

        public boolean has_next() {
            return position < size;
        }

        public Object get_next() {
            return data[position++];
        }
    }

    public Iterator get_iterator() {
        return new Iter();
    }
}

public class Main {
    public static void main(String[] args) {
        LinearList l = new LinearList();
        l.append("A");
        l.append("B");
        l.append("C");

        Iterator i = l.get_iterator();          // exactly the same client code as before
        while (i.has_next()) {
            System.out.println(i.get_next());
        }
    }
}

A
B
C

public class Main {
    public static void main(String[] args) {
        LinearList l = new LinearList();
        l.append("A");
        l.append("B");
        l.append("C");

        Object oi, oj;
        Iterator i, j;

        i = l.get_iterator();
        while (i.has_next()) {
            oi = i.get_next();
            j = l.get_iterator();               // a fresh iterator for every pass of the outer loop
            while (j.has_next()) {
                oj = j.get_next();
                System.out.println(oi + "," + oj);
            }
        }
    }
}

A,A
A,B
A,C
B,A
B,B
B,C
C,A
C,B
C,C

for (type x : a) {
    do something with x;
}

import java.util.Iterator;

public class LinearList implements Iterable<Object> {
    private Object[] data = new Object[100];
    private int size;

    public void append(Object o) {
        data[size++] = o;
    }

    public Iterator<Object> iterator() {            // the one method Iterable asks for
        return new Iterator<Object>() {
            private int position = 0;

            public boolean hasNext() {
                return position < size;
            }

            public Object next() {
                return data[position++];
            }
        };
    }
}

public class Main {
    public static void main(String[] args) {
        LinearList l = new LinearList();
        l.append("A");
        l.append("B");
        l.append("C");

        for (Object x : l) {                         // the compiler builds the iterator loop for us
            System.out.println(x);
        }
    }
}

A
B
C

import java.util.ArrayList;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("Asha");
        names.add("Ravi");

        for (String s : names) {                     // what you write
            System.out.println(s);
        }

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

Asha
Ravi
Asha
Ravi

import java.util.ArrayList;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("Asha");
        names.add("Ravi");
        names.add("Meena");

        Iterator<String> it = names.iterator();
        while (it.hasNext()) {
            if (it.next().equals("Asha")) {
                it.remove();                         // the iterator itself may remove safely
            }
        }
        System.out.println(names);
    }
}

[Ravi, Meena]