Merge pull request #3 from m0rk4/classes-and-interfaces-4

Classes and interfaces 4

Author: m0rk4

src/main/java/by/morka/effective/java/classesandinterfaces/compositionoverinheritance/ForwardingSet.java

@@ -0,0 +1,36 @@
+package by.morka.effective.java.classesandinterfaces.compositionoverinheritance;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Set;
+
+// Reusable forwarding class, simply forwards methods, api is strong and independent from impl.
+/*
+Important fact is that it IMPLEMENTS, not extends
+ */
+public class ForwardingSet<E> implements Set<E> {
+    private final Set<E> s;
+    public ForwardingSet(Set<E> s) { this.s = s; }
+
+    public void clear()               { s.clear();            }
+    public boolean contains(Object o) { return s.contains(o); }
+    public boolean isEmpty()          { return s.isEmpty();   }
+    public int size()                 { return s.size();      }
+    public Iterator<E> iterator()     { return s.iterator();  }
+    public boolean add(E e)           { return s.add(e);      }
+    public boolean remove(Object o)   { return s.remove(o);   }
+    public boolean containsAll(Collection<?> c)
+    { return s.containsAll(c); }
+    public boolean addAll(Collection<? extends E> c)
+    { return s.addAll(c);      }
+    public boolean removeAll(Collection<?> c)
+    { return s.removeAll(c);   }
+    public boolean retainAll(Collection<?> c)
+    { return s.retainAll(c);   }
+    public Object[] toArray()          { return s.toArray();  }
+    public <T> T[] toArray(T[] a)      { return s.toArray(a); }
+    @Override public boolean equals(Object o)
+    { return s.equals(o);  }
+    @Override public int hashCode()    { return s.hashCode(); }
+    @Override public String toString() { return s.toString(); }
+}

src/main/java/by/morka/effective/java/classesandinterfaces/compositionoverinheritance/InstrumentedHashSet.java

@@ -0,0 +1,46 @@
+package by.morka.effective.java.classesandinterfaces.compositionoverinheritance;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+
+// Broken - Inappropriate use of inheritance!
+public class InstrumentedHashSet<E> extends HashSet<E> {
+    // The number of attempted element insertions
+    private int addCount = 0;
+
+    public InstrumentedHashSet() {
+    }
+
+    public InstrumentedHashSet(int initCap, float loadFactor) {
+        super(initCap, loadFactor);
+    }
+
+    @Override
+    public boolean add(E e) {
+        addCount++;
+        return super.add(e);
+    }
+
+    /*
+    We don't know that addAll() calls all() under the hood,
+    the contract might change over time and our class will be broken.
+    So such inheritance is broken.
+    Even if API is documented well, still no trust.
+     */
+    @Override
+    public boolean addAll(Collection<? extends E> c) {
+        addCount += c.size();
+        return super.addAll(c);
+    }
+
+    public int getAddCount() {
+        return addCount;
+    }
+
+    public static void main(String[] args) {
+        InstrumentedHashSet<String> s = new InstrumentedHashSet<>();
+        s.addAll(List.of("Snap", "Crackle", "Pop"));
+        System.out.println(s.getAddCount());
+    }
+}

src/main/java/by/morka/effective/java/classesandinterfaces/compositionoverinheritance/InstrumentedSet.java

@@ -0,0 +1,36 @@
+package by.morka.effective.java.classesandinterfaces.compositionoverinheritance;
+
+import java.util.*;
+
+/*
+Decorator pattern in action!
+ */
+// Wrapper class - uses composition in place of inheritance
+/*
+Now api is not broken
+ */
+public class InstrumentedSet<E> extends ForwardingSet<E> {
+    private int addCount = 0;
+
+    public InstrumentedSet(Set<E> s) {
+        super(s);
+    }
+
+    @Override public boolean add(E e) {
+        addCount++;
+        return super.add(e);
+    }
+    @Override public boolean addAll(Collection<? extends E> c) {
+        addCount += c.size();
+        return super.addAll(c);
+    }
+    public int getAddCount() {
+        return addCount;
+    }
+
+    public static void main(String[] args) {
+        InstrumentedSet<String> s = new InstrumentedSet<>(new HashSet<>());
+        s.addAll(List.of("Snap", "Crackle", "Pop"));
+        System.out.println(s.getAddCount());
+    }
+}

src/main/java/by/morka/effective/java/classesandinterfaces/documentinginheritance/Sub.java

@@ -0,0 +1,23 @@
+package by.morka.effective.java.classesandinterfaces.documentinginheritance;
+
+import java.time.Instant;
+
+// Demonstration of what can go wrong when you override a method  called from constructor (Page 96)
+public final class Sub extends Super {
+    // Blank final, set by constructor
+    private final Instant instant;
+
+    Sub() {
+        instant = Instant.now();
+    }
+
+    // Overriding method invoked by superclass constructor
+    @Override public void overrideMe() {
+        System.out.println(instant);
+    }
+
+    public static void main(String[] args) {
+        Sub sub = new Sub();
+        sub.overrideMe();
+    }
+}

src/main/java/by/morka/effective/java/classesandinterfaces/documentinginheritance/Super.java

@@ -0,0 +1,12 @@
+package by.morka.effective.java.classesandinterfaces.documentinginheritance;
+
+// Class whose constructor invokes an overridable method. NEVER DO THIS! (Page 95)
+public class Super {
+    // Broken - constructor invokes an overridable method
+    public Super() {
+        overrideMe();
+    }
+
+    public void overrideMe() {
+    }
+}

src/main/java/by/morka/effective/java/classesandinterfaces/immutableclass/AnotherComplex.java

@@ -0,0 +1,90 @@
+package by.morka.effective.java.classesandinterfaces.immutableclass;
+
+import java.math.BigInteger;
+
+/*
+It is final actually because it has no public constructors
+Moreover its static factory can return subclasses (PACKAGE PRIVATE ONES, which is great, the client won't know)
+ */
+public class AnotherComplex {
+    /*
+        1. Biginteger is not final, thus can be extended, which is dangerous
+        2. If your safety depends on Biginteger received from not trustable client, use such algo
+     */
+    public static BigInteger safeInstance(BigInteger bigInteger) {
+        if (bigInteger.getClass() == BigInteger.class) {
+            // safe, real biginteger
+            return bigInteger;
+        }
+        // subclass, we need protected copy
+        return new BigInteger(bigInteger.toByteArray());
+    }
+
+    private final double re;
+    private final double im;
+
+    public static final AnotherComplex ZERO = new AnotherComplex(0, 0);
+    public static final AnotherComplex ONE = new AnotherComplex(1, 0);
+    public static final AnotherComplex I = new AnotherComplex(0, 1);
+
+    // Private
+    private AnotherComplex(double re, double im) {
+        this.re = re;
+        this.im = im;
+    }
+
+    public double realPart() {
+        return re;
+    }
+
+    public double imaginaryPart() {
+        return im;
+    }
+
+    public AnotherComplex plus(AnotherComplex c) {
+        return new AnotherComplex(re + c.re, im + c.im);
+    }
+
+    // Static factory, used in conjunction with private constructor
+    // Caching, etc. to minimize instantiation
+    public static AnotherComplex valueOf(double re, double im) {
+        return new AnotherComplex(re, im);
+    }
+
+    public AnotherComplex minus(AnotherComplex c) {
+        return new AnotherComplex(re - c.re, im - c.im);
+    }
+
+    public AnotherComplex times(AnotherComplex c) {
+        return new AnotherComplex(re * c.re - im * c.im,
+                re * c.im + im * c.re);
+    }
+
+    public AnotherComplex dividedBy(AnotherComplex c) {
+        double tmp = c.re * c.re + c.im * c.im;
+        return new AnotherComplex((re * c.re + im * c.im) / tmp,
+                (im * c.re - re * c.im) / tmp);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this)
+            return true;
+        if (!(o instanceof AnotherComplex))
+            return false;
+        AnotherComplex c = (AnotherComplex) o;
+
+        return Double.compare(c.re, re) == 0
+                && Double.compare(c.im, im) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        return 31 * Double.hashCode(re) + Double.hashCode(im);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + re + " + " + im + "i)";
+    }
+}

src/main/java/by/morka/effective/java/classesandinterfaces/immutableclass/Complex.java

@@ -0,0 +1,71 @@
+package by.morka.effective.java.classesandinterfaces.immutableclass;
+
+public final class Complex {
+    private final double re;
+    private final double im;
+
+    // Expose frequently used instances to minimize instantiation
+    public static final Complex ZERO = new Complex(0, 0);
+    public static final Complex ONE = new Complex(1, 0);
+    public static final Complex I = new Complex(0, 1);
+
+    public Complex(double re, double im) {
+        this.re = re;
+        this.im = im;
+    }
+
+    public double realPart() {
+        return re;
+    }
+
+    public double imaginaryPart() {
+        return im;
+    }
+
+    public Complex plus(Complex c) {
+        return new Complex(re + c.re, im + c.im);
+    }
+
+    // Static factory, used in conjunction with private constructor
+    // Caching, etc. to minimize instantiation
+    public static Complex valueOf(double re, double im) {
+        return new Complex(re, im);
+    }
+
+    public Complex minus(Complex c) {
+        return new Complex(re - c.re, im - c.im);
+    }
+
+    public Complex times(Complex c) {
+        return new Complex(re * c.re - im * c.im,
+                re * c.im + im * c.re);
+    }
+
+    public Complex dividedBy(Complex c) {
+        double tmp = c.re * c.re + c.im * c.im;
+        return new Complex((re * c.re + im * c.im) / tmp,
+                (im * c.re - re * c.im) / tmp);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this)
+            return true;
+        if (!(o instanceof Complex))
+            return false;
+        Complex c = (Complex) o;
+
+        return Double.compare(c.re, re) == 0
+                && Double.compare(c.im, im) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        return 31 * Double.hashCode(re) + Double.hashCode(im);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + re + " + " + im + "i)";
+    }
+}

src/main/java/by/morka/effective/java/classesandinterfaces/interfacesoverabstractclasses/AbstractMapEntry.java

@@ -0,0 +1,51 @@
+package by.morka.effective.java.classesandinterfaces.interfacesoverabstractclasses;
+
+import java.util.Map;
+import java.util.Objects;
+
+/*
+ Skeletal implementation class is nice application for abstract classes
+ 1. define skeleton operations
+ 2. build functionality on skeleton operations
+ 3. inherit it and make work easier
+ P.S at the same time you can implement interface
+ */
+public abstract class AbstractMapEntry<K, V> implements Map.Entry<K, V> {
+
+    // Entries in a modifiable map must override this method
+    @Override
+    public V setValue(V value) {
+        throw new UnsupportedOperationException();
+    }
+
+    /*
+     Implements the general contract of Map.Entry.equals
+          We are not allowed to define default object methods impls in interfaces, so we do it here
+     */
+    @Override
+    public boolean equals(Object o) {
+        if (o == this)
+            return true;
+        if (!(o instanceof Map.Entry))
+            return false;
+        Map.Entry<?, ?> e = (Map.Entry) o;
+        return Objects.equals(e.getKey(), getKey())
+                && Objects.equals(e.getValue(), getValue());
+    }
+
+
+    /*
+     Implements the general contract of Map.Entry.hashCode
+     We are not allowed to define default object methods impls in interfaces, so we do it here
+     */
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(getKey())
+                ^ Objects.hashCode(getValue());
+    }
+
+    @Override
+    public String toString() {
+        return getKey() + "=" + getValue();
+    }
+}