interfaces

Author: viktorvoltz

innerclasses/Example1.java

@@ -0,0 +1,16 @@
+class Outer{
+    Inner outerMethod(){
+        return new Inner();
+    }
+    class Inner{
+        Inner(){
+            System.out.println("inner class");
+        }
+
+    }
+
+    public static void main(String[] args){
+        Outer o = new Outer();
+        Outer.Inner n = o.outerMethod();
+    }
+}

innerclasses/Exercise2.java

@@ -0,0 +1,30 @@
+class Big{
+    private String name;
+    public Big(String name){
+        this.name = name;
+    }
+    public String toString(){
+        return name;
+    }
+}
+
+class Sequence{
+    private Big[] items;
+    private int next;
+    public Sequence(int size){
+        items = new Big[size];
+        add();
+    }
+
+    Big b = new Big("nonso");
+    public void add(){
+        for(next = 0; next < items.length; next++){
+            items[next] = b;
+        }
+    }
+
+    public static void main(String[] args){
+        Sequence sequence = new Sequence(5);
+        System.out.println(sequence.b);
+    }
+}

interfaces/Apply.java

@@ -0,0 +1,45 @@
+import java.util.*;
+
+class Processor {
+    public String name() {
+        return getClass().getSimpleName();
+    }
+
+    Object process(Object input) {
+        return input;
+    }
+}
+
+class Upcase extends Processor {
+    String process(Object input) { // Covariant return
+        return ((String) input).toUpperCase();
+    }
+}
+
+class Downcase extends Processor {
+    String process(Object input) {
+        return ((String) input).toLowerCase();
+    }
+}
+
+class Splitter extends Processor {
+    String process(Object input) {
+        // The split() argument divides a String into pieces:
+        return Arrays.toString(((String) input).split(" "));
+    }
+}
+
+public class Apply {
+    public static void process(Processor p, Object s) {
+        System.out.println("Using Processor " + p.name());
+        System.out.println(p.process(s));
+    }
+
+    public static String s = "Disagreement with beliefs is by definition incorrect";
+
+    public static void main(String[] args) {
+        process(new Upcase(), s);
+        process(new Downcase(), s);
+        process(new Splitter(), s);
+    }
+}

interfaces/Exercise17.java

@@ -0,0 +1,20 @@
+interface Days {
+	int SUNDAY = 1, MONDAY = 2, TUESDAY = 3, WEDNESDAY = 4, 
+		THURSDAY = 5, FRIDAY = 6, SATURDAY = 7; 
+}
+
+class Week implements Days {
+	private static int count = 0;
+	private int id = count++;
+	public Week() { System.out.println("Week() " + id); }
+}
+
+public class Exercise17 {
+	public static void main(String[] args) {
+		// Without any objects, static fields exist:
+		System.out.println("MONDAY = " + Days.MONDAY);
+		Week w1 = new Week();
+		// Error: cannot assign a value to final variable SUNDAY:
+		// w1.SUNDAY = 2;
+	}
+}

interfaces/Exercise18.java

@@ -0,0 +1,82 @@
+interface Cycle{
+    void ride();
+}
+
+interface CycleFactory{
+    Cycle getCycle();
+}
+
+class Unicycle implements Cycle{
+    @Override
+    public void ride(){
+        System.out.println("unicycle ride");
+    }
+
+    public String toString(){
+        String d = "unicycle";
+        return d;
+    }
+}
+
+class UnicycleFactory implements CycleFactory{
+
+    @Override
+    public Cycle getCycle() {
+        return new Unicycle();
+    }
+    
+}
+
+class Bicycle implements Cycle{
+    @Override
+    public void ride(){
+        System.out.println("bicycle ride");
+    }
+
+    public String toString(){
+        String d = "Bicycle";
+        return d;
+    }
+}
+
+class BicycleFactory implements CycleFactory{
+
+    @Override
+    public Cycle getCycle() {
+        return new Bicycle();
+    }
+    
+}
+
+class Tricycle implements Cycle{
+    @Override
+    public void ride(){
+        System.out.println("tricycle ride");
+    }
+
+    public String toString(){
+        String d = "Tricycle";
+        return d;
+    }
+}
+
+class TricycleFactory implements CycleFactory{
+
+    @Override
+    public Cycle getCycle() {
+        return new Tricycle();
+    }
+    
+}
+
+public class Exercise18 {
+    public static void rideCycle(CycleFactory factory) {
+		Cycle c = factory.getCycle();
+		c.ride();
+	}
+	public static void main(String [] args) {
+		rideCycle(new UnicycleFactory());
+		rideCycle(new BicycleFactory());
+		rideCycle(new TricycleFactory());	
+	}
+}

interfaces/Exercise19.java

@@ -0,0 +1,52 @@
+import java.util.*;
+
+interface Games {
+	void play();
+}
+
+interface GamesFactory {
+	Games getGames();
+}
+
+class CoinToss implements Games {
+	Random rand = new Random();
+	public void play() { 
+		System.out.println("Toss Coin: ");
+		switch(rand.nextInt(2)) {
+			case 0 : System.out.println("Heads"); return;
+			case 1 : System.out.println("Tails"); return;
+			default: System.out.println("OnEdge"); return;
+		} 
+	}
+}
+
+class CoinTossFactory implements GamesFactory {
+	public Games getGames() {
+		return new CoinToss();
+	}
+}
+
+class DiceThrow implements Games {
+	Random rand = new Random();
+	public void play() { 
+		System.out.println("Throw Dice: " + (rand.nextInt(6) + 1));		
+	}
+}
+
+class DiceThrowFactory implements GamesFactory {
+	public Games getGames() {
+		return new DiceThrow();
+	}
+}
+
+
+public class Exercise19 {
+	public static void playGame(GamesFactory factory) {
+		Games g = factory.getGames();
+		g.play();
+	}
+	public static void main(String [] args) {
+		playGame(new CoinTossFactory());
+		playGame(new DiceThrowFactory());			
+	}
+}

interfaces/Exercise2.java

@@ -0,0 +1,75 @@
+
+abstract class Noinstance{
+    Noinstance(){
+        System.out.println("abstr constr");
+    }
+    public abstract void meth();
+
+    public abstract void eth();
+
+    public void try4(){
+
+    }
+}
+
+interface Test{
+    int name = 5;
+
+    void func();
+}
+
+interface Test2 extends Test{
+    void destroy();
+}
+
+
+
+class Waveform implements Test{
+    public static String name = "name";
+    public String toString(){
+        String d = "Wave";
+        return d;
+    }
+
+    @Override
+    public void func(){
+        System.out.println("func()");
+    }
+}
+
+class Troy extends Waveform implements Test2{
+
+    @Override
+    public void destroy(){
+        func();
+    }
+}
+
+public class Exercise2 extends Noinstance{
+
+    @Override
+    public void meth() {
+        System.out.println("hello meth");
+        
+    }
+
+    @Override
+    public void eth(){
+        System.out.println("hello eth");
+    }
+
+    static void upcast(Test g){
+        g.func();
+    }
+
+    public static void main(String[] args){
+        Waveform w = new Waveform();
+        Exercise2 ex = new Exercise2();
+        upcast(w);
+        ex.meth();
+        ex.eth();
+        System.out.println(w);
+    }
+    // Error; cant instantiate class
+   // Noinstance none = Noinstance();
+}