Frameworks and Java

Object Oriented Frameworks

What is a framework

• A reusable design for solutions to problems in some particular problem domain

• A reusable "semi-complete" application that can be specialized to produce custom applications.

• Provides both a set of classes as well as a "pre-defined orchestration of objects"

• Support reuse of both design and code

• Often follows the Hollywood analogy - "Don't call us, we'll call you"

• Inversion of control

• A framework is not a design pattern (though they often exhibit patterns).

Document-centric user interfaces

Common facilities

• An application can have a set of documents open

• Save, save as, load, etc.

• Cut/copy/paste

• Undo/redo

• ...

Java Overview

public class HelloWorld {
  public static void main(String args[])
  {
	 System.out.println("Hello World");
  }
}

All objects are created with new:

SomeObject obj = new SomeObject();

obj.SomeMethod();

Classes

[ClassModifiers] class className 
	[extends superClass]
	[implements interfaces] {
	...
}

Where modifiers can be:

abstract -  Not actually implemented

final - No subclasses allowed

public  - Exports this class outside of package.
	One per file.
	 File must be named ClassName.java

private - Can only be used inside of file.

Methods and data members:

	public - 
	protected - 
	private - 
	final - cannot be redefined in derived class
	static 
	synchronized - calls go through a monitor
	native - stub that calls native implementation



So what would this do for us:

final class SomeClass {
	private SomeClass() {}

	public static DoSomething() {}
	public static DoSomethingElse() {}

}

Packages

In ObjArray.java:
package Collection;

public class ObjArray {
...

In ObjList.java:
package Collection;
public class ObjList {
...


Now when   we use this:
import Collection.*;

Interfaces

Java Threads

class Runnable {
      public:
      virtual  void  Tick(){}
};

class Command : public Runnable {
      void Tick(){
	   DoSomething();
      }
};


class Window : public Runnable {
      void Tick(){
	   Refresh();
      }
};


void EventLoop(){
     while(1){
          for runnable in  Runnables
	  	 runnable->Tick();
     }
}

List buffer;

class Producer : public Runnable {
      void Tick(){
	   buffer.Insert(some_data);
      }
};


class Consumer : public Runnable {
      void Tick(){
	   buffer.Remove();
      }
};

Java Threads

class Buffer  extends List {
synchronized public Object*  RemoveData ()
{
return ...
}
synchronized public Object*  InsertData ()
{
insert ...
}
public synchronized bool HasData(){
return ...
}
}


class Producer implements Runnable {
      public Thread myThread;
      Buffer myBuffer
      public Producer(Buffer b){
	     myThread = new Thread(this);
	     myBuffer = b;
     }
     void Run(){
	   while(true){
	   	   b.InsertData(GenerateData());	   
	   }
      }
}

class Consumer implements Runnable {
      public Thread myThread;
      Buffer myBuffer
      public Consumer(Buffer b){
	     myThread = new Thread(this);
	     myBuffer = b;
     }
      void Run(){
	   if(b.HasData(...)){
		b.RemoveData();
	   }		
      }
}



class App {
      static  public main(){
	      Buffer b = new Buffer();
	      Producer p1 = new Producer(b);
	      Consumer c1 = new Consumer(b);
	      c1.myThread.start();
	      p1.myThread.start();
     } 
}





or multiple producers and consumers:
class App {
      static  public main(){
	      Buffer b = new Buffer();
	      Producer p1 = new Producer(b);
	      Producer p2 = new Producer(b);
	      Producer p3 = new Producer(b);
	      Consumer c1 = new Consumer(b);
	      Consumer c2 = new Consumer(b);
	      Consumer c3 = new Consumer(b);
	      c1.myThread.start();
	      p1.myThread.start();
	      c2.myThread.start();
	      p2.myThread.start();
	      c3.myThread.start();
	      p3.myThread.start();
      }