Polymorphism Sometimes it is necessary to “see” an object of a certain class as being (also) of another: Polymorphism An object can be seen as being of the finally defined class or any one of the superclasses in the object hierarchy up to the Object class This makes that different class of objects may be considered from the same class But classes can extend only one other class. Sometimes it is necessary that classes which are extensions of different other classes look like the same class This can be achieved by interfaces

Inheritance Object GraphicObject RectangleObject CircleObject GraphicTest.java

The Drawing Methods drawLine(x1,y1,x2,y2) drawRect(x,y,w,h) fillRect(x,y,w,h) drawOval(x,y,w,h) fillOval(x,y,w,h) w x,y h w x,y h

The Drawing Methods drawPolygon(x[],y[],n) fillPolygon(x[],y[],n) setColor(color.colorname) colorname = black, blue, cyan, darkGray, gray, orange, white, red, pink, yellow setColor(new color(red,green,blue)) x[1],y[1] x[4],y[4] x[2],y[2] n = 5 x[3],y[3]

Drawing Strings and Changing the letters font drawString(str, x,y) We can change the standard Font by creating a new one Font afont = new font(“Arial”,font.Bold,20) c.setFont(afont); x This is the string y These Methods are the same used for painting over any window object of Java (Frame, Jframe, Panel, etc)

Interfaces Vektor Clock VisualVektor VisualClock VisualVektor INTERFACE: GraphicObjectInterface GraphicTestInterface.java

Reflection Reflection is the ability to “explore” an unknown class For example: Which are the variables of a class ? Which are the methods of a class ? Which are the declared methods ? Which are the declared variables ? What do I get if I perform a certain method of the class ?

The Most Important Methods Field [ ] getFields() Field [ ] getDeclaredFields() Method [ ] getMethods() Method [ ] getDeclaredMethods() Constructor [ ] getConstructors() Constructor[ ] getDeclaredConstructors() These are performed over an object of the class Class

How do I get a Class Object ? Class c = Classname.class; Console.class String.class etc.. Class c = object.getClass(); Console cs = new Console(); Class c = cs.getClass(); Class c = Class.forName(String); Class c = Class.forName(“Console”); ReflectionTest ReflectionTest2 ReflectionTest3

Objects doing things by themselves We will program a clock which updates itself (almost) every second For this, the clock must be of the class thread Every object of the thread class can start an independent execution line (“thread”) which will me executed in parallel to the programs of the main method

Making things in parallel The Thread Main Thread1 Thread2 Thread3

Making things in parallel The Thread A thread is an independent, parallel line of statements execution It consists basically of method (run) written in a special way which can be activated by another method When a method activates a thread it continues executing its own statements while the thread starts executing the statements of the method called run() There are different ways to write threads, we will see the most easy to write

Implementation of Threads One way (perhaps the most clear one) is to define a new class which is an extention of the Thread class and overwrite its run() method. Thread is an existing class This thread class has a run method (originally with no statements) which will be executed in parallel when activated. In order to execute this method a program must create an object of the extended class and apply the start() method to it. The definition of the new Thread class should look like this: public class MyThread extends Thread { And somewhere should appear: public void run() { //instrucction to be executed in parallel } NOTAS

Example public class SimpleThread extends Thread { public SimpleThread(String str) { super(str); } public void run() { for (int i = 0; i < 10; i++) { System.out.println(i + " " + getName()); try { this.sleep((int)(Math.random() * 1000)); } catch (InterruptedException e) {} System.out.println("DONE! " + getName()); The this.sleep(milisegundos) must appear in a try and catch block NOTAS

Use of this new class public class TwoThreadsTest { public static void main (String[] args) { SimpleThread t1,t2; t1 = SimpleThread("Jamaica"); t2 = SimpleThread("Fiji"); t1.start(); t2.start() } The start() triggers the execution of the run method of the thread. There are other methods which can be applied to a thread: suspend(), resume(), stop(). These are however deprecated because their use can easily lead to deadlocks NOTAS

The clock has a thread to advance the current time ActiveClock Two threads

Sometimes you cannot program the server as an extension of a thread For example, if the server has to implement a graphical interface it should be declared as an extension of a Frame, if it is programmed as an Applet it must extend the Applet class The we can use the interface Runnable, which means the Server will also be seen as a Runnable class and has to implement the run method run(). To initiate a parallel execution of the run method a Thread object must be created. In the creation a pointer to the server object (this) should be passed as parameter. With this, the Thread object will have access to the run method. The run method implemented in the server class will be executed by performing start() on the new created Thread object. NOTAS

Example with interface Runnable See and execute the program NoSincron.java Note that the Threads created in this way will have access to all resources of the server. De la otra forma es más bien una opción, (pasar un puntero al servidor cuando se crea un objeto thread) De cualquier forma, será frecuente el compartir recursos y por lo tanto la admistración de ellos es importante NOTAS

Critical regions and semaphores in Java Java provides basically two methods for controlling concurrent access to resources You can declare a whole method as a critical region (ver sincron1) You can use the semaphore of any object (ver sincron2) NOTAS