Slide 2 : 2 / 29 : Object-Oriented Programming

Object-Oriented Programming

A bit of ad : OOP ask a effort in the beginnings ...

Java supports the Object-Oriented Programming (OOP) approach.

OOP focuses on the design of data-types (called objects or classes) rather than algorithms

Why is this distinction important?

Objects are nouns, Algorithms are verbs

If you want to put a windows in a wall, you don't say :

"Let's use a hammer to make a hole in that wall, then let's measure the size of the hole, then lets buy some piece of wood that we will put together, then ...

You say : Let's decide to have a windows in that wall

You know first what you want and then you think of the way you will get it

Which is an easier task?

• identify the actions that apply to a given noun

• identify those objects to which a given action might be applied

• Example : Verb "to buy" / Object "Car"

isn't it easier to list the actions that you can do with a car (to buy, to sell, ...to drive°) than to list all the object you can buy ... and forget lots of them ?

What is easier?

• identifying similar object classes

is a relationship

• specifying general-purpose algorithms

with lots of "if then else" statements

Advantages of OOP

• promotes design abstraction (hiding details)

• promotes code reuse

• consolidates specification and interface ... encapsulation

Slide 3 : 3 / 29 : CG Example

CG Example

Slide 4 : 4 / 29 : Polymorphism

Polymorphism

Polymorphism allows algorithms to be specified in terms of the most general (and/or reasonable) object type

void processShape(Shape s) 	{	s.setColor(Color.red); 	// ... do stuff	s.draw();	}         Circle c = new Circle(x, y, r);         Point2D v1 = new Point2D(x1, y1);Point2D v2 = new Point2D(x2, y2);Point2D v3 = new Point2D(x3, y3);Triangle t = new Triangle(v1, v2, v3);         Point2D c1 = new Point2D(u1, v1);Point2D c2 = new Point2D(u2, v2);Triangle r = new Rectangle(c1, c2);         processShape(c);processShape(t);processShape(r);

Slide 5 : 5 / 29 : Java Specifics : space and curly braces

Java Specifics : space and curly braces

A Java source program is composed of white space, comments, declarations, and statements.

{	White space is a very important part of any Java program    	{		has no effect on the code's meaning		enhances readability and communicates structure		includes : spaces, tabs, and new lines.		typically, tabs or indention set off blocks of code		new-lines separate statements	}} 

There are lots of different"rules and conventions" on using white space and curly braces.

Adopt a consistent style !

Make sure that readers could easily find beginning and end of your blocks

A Java source program is composed of white space, comments, declarations, and statements.
White space is a very important part of any Java program. While it has no effect on the meaning of the code, white space, more than any other factor, contributes to the readability and signals the structure of a code fragment. White space includes, spaces, tabs, and new lines. Typically, tabs or indention is used to set off blocks of code, and new lines are used to separate statements. There are no hard-fast rules how and when to use white space, all I suggest is that you adopt a consistent style.

Slide 6 : 6 / 29 : Comments

Comments

Next to white space, the most important parts of any Java program are its comments.

Inline comments:

	answer = 42; // valid independent of the input

Block comments:

/*... This next bit of code is so obvious that I hesitated      to comment it a first.   For those whom intergalactic culture is limited,  please refer to the textbook :    "the hitch hicker guide for the galaxy" by Douglas Adams.  tip : 42 is the answer for life, the universe and everything*/ 	answer = 42;   

Next to white space, the most important part of any Java program is comments. Keep in mind the syntax of a language is designed for communicating a program's design to a computer. Comments, on the other hand, are the primary mechanism for communicating a program's design to humans. Java has three types of comments.

Slide 7 : 7 / 29 : Special Comments

Special Comments

Java provides a special form of comment for generating automatic documentation, and web pages. It uses a tool called javadoc. Within these special comment blocks several special variables, indicated by a leading @, are recognized.

Documentation comments:

 /** The Universe and Everything * *	@version 0.9999 Date : This must be Thursday *	@author Ford Prefect *	@author Arthur Dent *  @see <A HREF="http://users.milliways.mg-net.de/BSAFH/guide/">the book</A> */ public class theUnivers {	public static String getTheAnswer()	{		return("42");	}		/**	 *  @deprecated Remember a important thing about that question ...	 * "It is said that if both the question and the answer to Life, 	 * the Universe and Everything ever exist in the same dimention 	 * it will dissappear and be replaced by something even more strange 	 * and unexplicable" -Hitch Hicker Guide To The Galaxy	 */	private String getTheQuestion()	{	while(true)		{		sleep(1);		}	}}	

Slide 8 : 8 / 29 : Java Data Types

Java Data Types

Variables in Java must be objects, arrays, or one of the primitive data types

Java has 8 primitive data types
(boolean, byte, short, int, long, double, float, char)

Notes:

• All integer types are signed (and there is no unsigned keyword)

• Unlike C and C++ char variables are 16 rather than 8 bits
  Because Java is Unicode compliant

• Unlike C, Java types have a definitely fixed size
  in C, it used to depend on the compiler

• Primitive data types are passed to method by value
  the actual value of a primitive type can only be modified by the methods of the declaring or derived object

boolean likeeScience = true;	/*	boolean likewise have values {true, false}		they can never be mixed up with integer or other type	 */byte teeth = 32;		// bytes go from -128 to 127if (!likeeScience) teeth = teeth - 1;float pi = 3.141592f; 	// you need the "f" hereshort classes = 0xbad;	// hexadecimal   

Slide 9 : 9 / 29 : Java Arrays

Java Arrays

Java arrays fall between a primitive data type and an object

Properties of Java arrays:

• can contain objects, primitive types, or other arrays

• contents are accessed via zero-based positive integers enclosed within the brackets, [, and ]

• declaration, creation and, value initialisation of arrays are distinct operations

• created with the new operator

• uninitialised arrays have a value of null

• have a single instance variable called 'length'

• checks at run time, that all accesses are between 0 and length - 1

• passed to methods by reference

byte buffer[];		// array declaration (buffer = null)buffer = new byte[1024];	// array creation (contents initialised to zeros)int table[] = new int[10];	// declaration and creation combined   int sqrs[] = {0, 1, 4, 9, 16, 25, 36, 49, 64, 81 }; // with an initializerbuffer[5] = sqrs[sqrs.length-1]; // array references   int triangle[][] = new int[3][];	// 2D Arrays do not have to be matrixtriangle[0] = new int[3];triangle[1] = new int[2];triangle[2] = new int[1]; 

Slide 10 : 10 / 29 : Java Objects

Java Objects

Objects are containers around aggregates of primitive types, arrays, and other objects

• Properties of Classes

• All Java code is contained within objects
  Excepted comments, import and package statements.

• Objects are passed to methods by reference

• Definition, declaration, and creation of objects are distinct

• Instances of objects are created with new and have a value of null

• Objects have four forms: the class, the abstract class, the inner class, and the interface

class Circle						// object definition{	static double pi = 3.141592;	// class variable	double radius;					// instance variable	public Circle(double r)			// constructor method	{	radius = r;	}	public double circumference()	{	return 2*pi*radius; }	public double area()	{	return pi*radius*radius; }	public static getPi()	{	return pi;	}	// class method}   Circle c;				// object declarationc = new Circle(4.0);	// object creationdouble a = c.area();	// object method call

Slide 11 : 11 / 29 : Java Statements

Java Statements

Statements are all that remains!

• Individual statements are terminated by semicolons

• Blocks of statements are grouped using braces, {, and }

• Simplest statement is the expression.

An expression is a string of variables and constants separated by operators.
Java allows the following set of operators within statements:

. [] ()++ -- ! ~ instanceof* / %+ -<< >> >>>< > <= >=== !=&^|&&||?:= *= /= %= += -= <<= >>= >>>= &= ^= |=

The final component of a Java program is its statements. Individual statements are terminated by semicolons. Groups of statements and declarations enclosed within braces, { and }, are called block statements and they act like an individual statement. Block statements do not require a terminating semicolon. The simplest type of statement is the expression.

An expression is a string of variables and constants separated by operators. A common type of expression is the assignment where a variable is given the value of the expression to the left of an equal sign. If one of the operator-assignment forms is used, the variable is given the value of expression to the left of the equals sign combined with it previous value of the variable as determined by the operator to the left of the equals sign. For more specific details on operators and the types of arguments that they allow see the textbooks.

Slide 12 : 12 / 29 : Control Statements

Control Statements

The second type of statement is the control statement.

The following list illustrates some of the control statements available in Java:

Really classical structure, especially easy to understand for english speaking programmer.
NB : BoolleanExpression are Boolean Expressions)
Break, continue, Label ...

Loop : be sure to get out of it

if (BooleanExpression) Statement   if (BooleanExpression) Statement else Statement   while (BooleanExpression) Statement   do Statement while (BooleanExpression)   for (Expression; BooleanExpression; Expression) Statement   break <Label>   continue <Label>   Label: Statement   switch (IntegerExpression){	case IntegerValue:		Statements	default:		Statements}return Expression

In these examples reserved keywords are shown in bold.

Slide 13 : 13 / 29 : Others Java Subjects

Others Java Subjects

• Constructors and the "new" operator

new create a new object from a class. It allocates memory and call the adequate constructor method of the class to initialise field values.

• Class variables and method distinctions
  (this, super, abstract, final, static, instance, and class variables)

Let the students talk ...
This : the object instance of a class (constructors)
super : the parent class

final : method can't be overwritten, class can not be subclassed
static : a class thing. No object instance is needed.

• Packages (package and import)

This week exercise

• Class protection (public, private, protected)

public : accessible anywhere
private : member accessible only within the class that defines it
protected : member accessible only within package and within subclasses.

• Exception handling

A way to deal with things that should not happen (better than the if then else)
Each time there is an input from outside of the program

• Interfaces and abstract classes

abstract : a method implementation is missing somewhere

We now know enough to write a simple example.

Slide 14 : 14 / 29 : What you will need...

What you will need...

A text Editor

Mac

BBEdit, ProjectBuilder, TextEdit, jedit ...

Unix

vi, emacs, Xemacs

Windows

TextEdit, Xemacs, TexPad

Java Documentation API :

Java Compiler : javac

Java Virtual machine : java

Java comments extractor : javadoc

Java archive tool : jar

and sometime an aplet viewer

and an account in the lab ?

Slide 15 : 15 / 29 : A First Example

A First Example

Source :

/** Simple Java 2D Example * *	@version 0.9  12/07/2001 *	@author Pascal Vuylsteker */ import javax.swing.*; public class HelloWordSimple{	public static void main(String[] args)	{	HelloWordFrame frame = new HelloWordFrame();		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		frame.show();	}}class HelloWordFrame extends JFrame {	public HelloWordFrame()	{	setTitle("Hello World !! ");		setSize(300,200);				HelloPanel panel = new HelloPanel();		Container contentPane = getContentPane();		contentPane.add(panel);	}}class HelloPanel extends JPanel{	public void paintComponent(Graphics g)	{	super.paintComponent(g);		g.drawString("Hello again...", 20, 20);	}} 

With some ...and notes about

Slide 16 : 16 / 29 : A First Example with comments

A First Example with comments

Source :

All Java source code files should end with a .java extension. When a Java program is compiled one or more .class files are generated. The number of .class files generated by a compile depends on how many objects are defined in the source file.

Let's test it first

/** Simple Java 2D Example * *	@version 0.9  12/07/2001 *	@author Pascal Vuylsteker */ // to tell to the compiler where to look for class definition// class that are not in the default package nor in java.langimport javax.swing.*;// that was missing...import java.awt.*;//Since all Java code must be contained within an object, // an object called HelloWordSimple is defined in this file.// "There should be only one"... public class per filepublic class HelloWordSimple{	//	in order to run a program, the public class should contain //  a main method which is static	public static void main(String[] args)	{	HelloWordFrame frame = new HelloWordFrame();		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);		frame.show();	}}// You don't even need to know any of the details of how a class works, //  beyond the interfaces to methods, in order to modify the original code. This //  is a simple example of the power of object-oriented programming. class HelloWordFrame extends JFrame {	public HelloWordFrame()	{	setTitle("Hello World !! ");		setSize(300,200);				HelloPanel panel = new HelloPanel();		Container contentPane = getContentPane();		contentPane.add(panel);	}}// JPanel has to be extented : the main method contain all// the work.class HelloPanel extends JPanel{	public void paintComponent(Graphics g)	{	super.paintComponent(g);		g.drawString("Hello again...", 20, 20);	}} 

NB : what is wrong with ?

It is not object oriented programming...

See the

Slide 17 : 17 / 29 : JFrame

JFrame

JFrame class is a Swing extension of the AWT Frame class (Swing adds a J).

It is one of the few ``non-painted'' graphics components.

Frames are examples of containers and we will study ways of inserting graphics objects into them.

Swing lives in javax.swing.*.

The 'x' stands for 'extension'.

setSize

By default JFrame has 0x0 pixels! You need to define your own frame class which extends it and which is bigger. Use the setSize() method to increase its size.
Units of size are pixels.

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

defines what happens when you close the frame

In other programs you would want to change this so that the program did not exit whenever the user closed a window. By default a frame is ``hidden'' when a user closes it but the program does not terminate.

show

Frames start their life invisible! You must call show to display them.
Note that the main program exits after the show call.
This just terminates the main thread.
Graphics is in a separate thread.

What else to do ?

Many of the useful JFrame methods are inherited from other classes further up the hierarchy

javax.swing
Class JFrame

  |  +--        |        +--              |              +--                    |                    +--                          |                          +--javax.swing.JFrame

Frame class

• dispose
  which closes the window down and reclaims any system resources.
• setIconImage
  which lets you read in your own image for a window icon.
• setTitle
• setResizable
  which takes a boolean argument to specify whether or not the user is able to resize the window.

Component and Window classes
(particularly methods to resize and position the frame):

• setLocation(x,y)

This method can move the frame around. Note that y measures the number of pixels down from the top left corner of the screen. Also note that both arguments are integers.

• setBounds(x, y, width, height)
  This allows you to define the position and size in one command.

Note that the coordinates in JFrame methods are with respect to the whole screen. In other swing classes they are usually with respect to a specific container.

How to get Screen Dimension ?

It is possible to get the dimensions of the screen you are using by creating an object of class Toolkit and calling its getScreenSize() method. This returns the width and height as fields in a dimension object. The pattern is

        Toolkit kit = Toolkit.getDefaultToolkit();        Dimension screenSize = kit.getScreenSize();        int screenHeight = screenSize.height;        int screenWidth = screenSize.width;

Slide 18 : 18 / 29 : JPanel

JPanel

Why not on JFrame ?

Added to the JFrame content Pane

Although it is possible to draw directly onto a JFrame this is considered to be bad programming practice. The thing most swing programmers do is to add components to the content pane which is part of the JFrame. (See fig 7-7.) The thing to do is to call the getContentPane() method of your JFrame to create a Container object and then to add Componentto this.

        Container contentPane = getContentPane();        HelloPanel panel = new HelloPanel();        contentPane.add(panel);

A panel that extend JPanel :

• surfaces onto which you can draw

• containers into which you can insert other interface components (sliders, radio buttons ...)

Why do you extend JPanel? Because the basic panel is very boring. You need to override its paintComponent method so that the system will draw interesting objects.

A paintComponent method to override

• paintComponent is automatically called by the operating system ``when it is needed''. You never call it yourself.
• It takes a single argument of type Graphics which remembers the current settings of your graphics such as font and colour. It also has methods to draw patterns, images and text.

• The following method

          g.drawString("Hello World!", MESSAGE_X, MESSAGE_Y);

  will draw a string at the specified position.

• You also need to paint the panel itself and fill it with a background colour

          super.paintComponent(g);

Slide 19 : 19 / 29 : Java2D Overview

Java2D Overview

• Draw lines of any thickness

• Fill shapes with gradients and textures

• Move, rotate, scale, and shear text and graphics

• Composite overlapping text and graphics

For example, you could use the Java 2D API to display complex charts and graphs that use various line and fill styles to distinguish sets of data, like those shown in the following figure.

• storage and manipulation of image data

The Java 2D API also enables you to store and to manipulate image data--for example, you can easily perform image-filter operations, such as blur and sharpen, as shown in the following figure.

Slide 20 : 20 / 29 : Overview of the Java 2D API

The Java 2D API introduced in JDK 1.2 provides enhanced two-dimensional graphics, text, and imaging capabilities for Java programs through extensions to the Abstract Windowing Toolkit (AWT). This comprehensive rendering package supports line art, text, and images in a flexible, full-featured framework for developing richer user interfaces, sophisticated drawing programs and image editors.

The Java 2D API provides

• A uniform rendering model for display devices and printers

• A wide range of geometric primitives, such as curves, rectangles, and ellipses and a mechanism for rendering virtually any geometric shape

• Mechanisms for performing hit detection on shapes, text, and images

• A compositing model that provides control over how overlapping objects are rendered

• Enhanced color support that facilitates color management

• Support for printing complex documents

These topics are discussed in the following sections:

Slide 21 : 21 / 29 : Java 2D Rendering

Java 2D Rendering

The basic rendering mechanism is the same as in previous versions of the JDK--the drawing system controls when and how programs can draw. When a component needs to be displayed, its paint or update method is automatically invoked with an appropriate Graphics context.

The Java 2D API introduces , a new type of Graphics object. Graphics2D extends the class to provide access to the enhanced graphics and rendering features of the Java 2D API.

To use Java 2D API features, you cast the Graphics object passed into a component's rendering method to a Graphics2D object.

public void Paint (Graphics g) {    Graphics2D g2 = (Graphics2D) g;    ...}

Slide 22 : 22 / 29 : Java 2D Rendering Context

Graphics2D Rendering Context

The collection of state attributes associated with a Graphics2D object is referred to as the Graphics2D rendering context. To display text, shapes, or images, you set up the Graphics2D rendering context and then call one of the Graphics2D rendering methods, such as draw or fill. As the following figure shows, the Graphics2D rendering context contains several attributes.

To set an attribute in the Graphics2D rendering context, you use the set Attribute methods

	The pen style : setStroke that is applied to the outline of a shape. This stroke attribute enables you to draw lines with any point size and dashing pattern and to apply end-cap and join decorations to a line.
	The fill style : setPaint that is applied to a shape's interior. This paint attribute enables you to fill shapes with solid colors, gradients, and patterns.
	The compositing style : setComposite that is used when rendered objects overlap existing objects.
	The transform : setTransform that is applied during rendering to convert the rendered object from user space to device-space coordinates. Optional translation, rotation, scaling, or shearing transforms can also be applied through this attribute.
	The clip : setClip which restricts rendering to the area within the outline of the Shape used to define the clipping path. Any Shape can be used to define the clip.
	The font : setFont used to convert text strings to glyphs.
	Rendering hints : setRenderingHints that specify preferences in the trade-offs between speed and quality. For example, you can specify whether antialiasing should be used, if it's available.

Slide 23 : 23 / 29 : Rendering Methods

Rendering Methods

Example

When you set an attribute, you pass in the appropriate attribute object. For example, to change the paint attribute to a blue-green gradient fill, you would construct a GradientPaint object and then call setPaint.

gp = new GradientPaint(0f,0f,blue,0f,30f,green);g2.setPaint(gp);

Graphics2D holds references to its attribute objects--they are not cloned. If you alter an attribute object that is part of the Graphics2D context, you need to call the appropriate set method to notify the context. Modifying an attribute object during rendering causes unpredictable behavior.

Graphics2D Rendering Methods

Graphics2D provides the following general rendering methods that can be used to draw any geometry primitive, text, or image:

• draw
  --renders the outline of any geometry primitive, using the stroke and paint attributes.
• fill
--renders any geometry primitive by filling its interior with the color or pattern specified by the paint attribute.
• drawString
--renders any text string. The font attribute is used to convert the string to glyphs, which are then filled with the color or pattern specified by the paint attribute.
• drawImage
--renders the specified image.

In addition, Graphics2D supports the Graphics rendering methods for particular shapes, such as drawOval and fillRect.

Slide 24 : 24 / 29 : Coordinate Systems

Coordinate Systems

The Java 2D system maintains two coordinate spaces.

• User space
  is the space in which graphics primitives are specified.

• Device space
  is the coordinate system of an output device, such as a screen, window, or a printer.

User space is a device-independent logical coordinate system : the coordinate space that your program uses.
All geometries passed into Java 2D rendering routines are specified in user-space coordinates.

Default transformation

When the default transformation from user space to device space is used, the origin of user space is the upper-left corner of the component's drawing area. The x coordinate increases to the right, and the y coordinate increases downward, as shown in the following figure.

Device space is a device-dependent coordinate system that varies according to the target rendering device. Although the coordinate system for a window or the screen might be very different from that of a printer, these differences are invisible to Java programs. The necessary conversions between user space and device space are performed automatically during rendering.

Slide 25 : 25 / 29 : Shapes

Shapes

The classes in the java.awt.geom package define common graphics primitives, such as points, lines, curves, arcs, rectangles, and ellipses.