Object Oriented Programming

OOP allows you to easily decompose a problem into sub groups
of related parts. All OOP languages have 3 things in common:

• They
  have objects
• They
  are polymorphism
• And
  they have inheritance

 

 Let’s look at Objects

 An object is a
logical entity containing data and the code that manipulate that data. Within
an object some of the code or data may be private to the object and
inaccessible by anything outside the object. In this way, an object provides a
significant level of protection against accidental modification or incorrect
use. This is referred to as encapsulation.

 

 

Let’s look at
polymorphism:

 

OOP languages support polymorphism which allows one name to
be used for several related but slightly different purposes. The purpose of
polymorphism is to let one name be used to specify the general class of action.
Depending on what type of data it is dealing with a specific instance of the
general case is executed. Example of polymorphism: http://java.sun.com/developer/onlineTraining/Programming/BasicJava2/collec.html

 

 

 

 

Let’s talk about
inheritance: 

 

Inheritance is the process by which an object can acquire
the properties of another object. This is important because t support the
concept of classification. Example, a “Red Delicious Apple” is part of a class
which is part of a fruit class, which is under the larger class of food.  So without the use of classification, each
object would have to define all of its characters explicitly. Using this
classification, and object need only define qualities that makes it unique
within this class.

 

It is the inheritance mechanism that makes it possible for
one object to be a specific instance of a more general class.

 

While we declare classes inheriting
other classes an object should never directly manipulate the internal data of
another object. Therefore, all
communication should be via message sending, that is through method calls.  The data in an object are usually called its
“instance variables” or “fields”, and the functions and procedures are called
its methods.

 

A specific object that is an instance of a class will have
specific values for its fields that define its current state.

 

 

 

Important: A simple
rule of thumb in identifying class is to look for nouns in the problem
analysis. Methods on the other hand correspond to verbs (actions)

Anything that is a
noun in a programming will be transform into a class and every action will
appear as a method. First we have to declare our date type our type is
class a call you can not touch or work with and object is a declaration of that
class and that is what we call an instance of that class. I will create an
object of class, so you must declare a class and then call it an object.

 

<>
A programming example:

class
EmployeeTest {

 

public
static void main(String[] args) {

 

//Declaring
an object called number007 of class type Employee

//Employee.
Notice the use of new

 

Employee
number007 = new Employee(”James Bond”, 100000);

number007.raiseSalary(5);

number007.print();

 

}// end
of main

 

}//end of
EmployeeTest

 

 

//Here is
the actual definition of the class type Employee.

 

class
Employee {

 

 

// The
date (fields) declaration section.

 

private
String name;

private
double salary;

 

//The
counstructor definition. The special method is called

//the
time when the object is instantiated.

 

 public Employee(String n, double s){

 

name =n;
//initializing name to passed parameter n.

salary=s;
//initializing name to passed parameter s.

}

 

//Declaring
the method print() that will printout the values:

 public void print() {

 System.out.println(name+”\t”+salary);

 

}//End of
method print()

 

//Declaring
another method called raisedSalary() that will

//Take as
input the percentage of the raise. It doesn’t return

//any
value. It only modifies the salary variable.

 

public
void raiseSalary(double byPercent) {

 

salary*=1
+ byPercent/100;

 

 

 

}//end of
method raiseSalary()

 

}//end of
class Employee declaration.

 

Note: It is possible to use the public keyboard with
your instance variables but it would be a very bad idea. Having public data
fields would allow any part of the program to read & modify the instance
variables. That completely ruins encapsulation! So keep them private.

 

The constructor:

 

Let’s look at the first method listed in the Employee class:

 

public Employee(String
n, double s){

name =n;
//initializing name to passed parameter n.

salary=s;
//initializing name to passed parameter s.

}

 

This is an example of constructor method that is used to
initialize objects of a class giving the instance variable the initial state
you want them to have.

 

Example: When you create an instance (object) of the
Employee class with code like this:

 Employeenumber007 = new
Employee(”James Bond”, 100000);

 

    The you have set
the instance fields foe the instance objects they are now related to
(number007) as follows”:

 

name=”James Bond” and

salary = 100000

 

  Notice: the new keyword is always used together
with a constructor to create the object. This forces you to set the initial
state of your object. In Java, you cannot creates  an instance of a class without initializing
it the instance variables (In Past OOP program this used to create runtime
error)

 

 

Please keep the following in mind:

 

1-     A
constructor has the same name as the class

2-     A
constructor may take one or more ( or even none) parameter

3-     A
constructor is always called with the new
keyword

4-     A
constructor has no return value

5-     You
cannot apply a constructor to an existing objects to reset the instance to
“field”values

 

The constructor is used in one situation when you create
that lass and it is for every object that you create/ You need another object
internally control called new.

 

In java you create
the variable are created in memory. But you don’t have to worry about cleaning
up the ram. In java it cleans what it put in.

 

Let us look at this example what if we had more then one
employee??

We need an array of objects!!☺

 

class
EmployeeArray{

public
static void main(String[] args) {

//Cretaing
an array of objects

Employee[]statff
= new Employee[3]

//New
Instantiating the element in the array , one by one.

Staf[0] =
new Employee(“Harry Smith”,35000);

Staf[1] =
new Employee(“Sandy Bell”,75000);

Staf[3] =
new Employee(“Wendy Well”,54000);

 

int  i

for(i=0;i<i++){

 staff[i].raiseSalary(5) //To call a method of
an object we provide the object name “.”the method name .

staff[i].print();

 

}//end of
look

}/end of
main

}//end of
class

 

// Now we
define the class Employee

Class
Employee{

public
Employee(String n, double s)

name =n;

salary=x;

// the
print () method :

public
void print (){

System.out.println(name+”|t”+salary);

 

}

//the
raiseSalary() method:

public
void raiseSalary (double byPercent) {

Salary*=1+
ByPercent/100;

}

//You
canneither place the data fields of the class either at the beginning or at the end of the class definition

 

private
String name;

private
double salary;

}//end of
class definition.

 

More Example:

 

Let us take a look at this Java program that calculates the
Miles per Gallons a car spends:

import
java.io.*;// including the input-output library

class
MilesPerGallon{

public
static void main(String []args) {

 //The following is used to input data from the
keyboard:

BufferedReader
userIn = new BufferedReader(new InputStreamReader(System.in));

// you
don’t have to memorize the above

String
line;

int
startMiles, endMiles;

double
gallons;

try{

System.out.println(”Enter
first reading”);

line =
userIn.readLine();// get the input

startMiles
= Integer.parseInt(line); //Parse input into integer value.

 

System.out.println(”Enter
second reading”);

line =
userIn.readLine();// get the input

endMiles
= Integer.parseInt( line );

 

System.out.println(”Enter
Gallons:”);

line =
userIn.readLine();

gallons =
Double.parseDouble(line);

 

//Declaring
an object called my car of class type Car

Car mycar
= new Car (startMiles,endMiles,gallons);

 

 

System.out.println(”Miles
per gallon=”+mycar.calculateMPG());

}//end of
main

catch
(Exception e) {

}//end of
class

}

}

 

class
Car{

//
instance variables

private
int sm; // starting odometer reading

private
int em; //ending odometer reading

 

private
double gallons; //gallons of gas used

 

//The
constructors

 

Car(int
first, int last, double gals){

sm =
first;

em =
last;

gallons =
gals;

}

//Methods
declared:

 

public
double calculateMPG( ){

return(
em - sm)/gallons;

}//end
class declaration

}

 

Try this program with following value:

 

200 -  450 -  2  =
125

 

Here is another example:

 

/*Constructor
Overloading:

Let us
take a look a this java program that will deal with constructor overloading.

Constructor
methods are not suppose to display anything but the println in this example

is placed
there to prove that depending on the number of arguments in this case a certain

constructor
is called by the compiler

*/

 

class
Point3D   {

private
double x ;

private double y;

private double z;

 

Point3D(double
ax){

   System.out.println (”We are in the
first counstructor”);

   x =ax;

   y = 1;

   z = 1;

}

 

Point3D(double ax, double ay){

   System.out.println (”We are
in the second counstructor”);

   x =ax;

   y = ay;

   z = 1;

}

 

Point3D(double ax, double ay, double az){

   System.out.println (”We are
in the third counstructor”);

   x =ax;

   y = ay;

   z = az;

}

 

double get_x(){

      return x;

}

 

double
get_y(){

      return y;

}

 

double
get_z(){

      return z;

}

}//end of
class Point3D definition (declaration).

 

class
Point3DOverloadConstructors {

       public static void main(String input[]) {

             //Declaring an object called p1 through
calling the counstructor

             //that takes 1 parameter.

 

             
Point3D p1 = new Point3D(1.1);

 

             
//Printing  the values of objects
variables

             
System.out.println(”p1:x=”+p1.get_x());

             
System.out.println(”p1:y=”+p1.get_y());

             
System.out.println(”p1:z=”+p1.get_z());

 

 

            //Declaring an object called p2
through calling the counstructor

             //that takes 2 parameter.

 

             Point3D p2 = new Point3D(1.1,3.4);

                          //Printing 
the values of objects variables

                          System.out.println(”p2:x=”+p2.get_x());

                         
System.out.println(”p2:y=”+p2.get_y());

                     
System.out.println(”p2:z=”+p2.get_z());

 

             
//Declaring an object called p3 through calling the counstructor

             
           //that takes 3 parameter.

 

             
           Point3D p3 = new Point3D(1.1,3.4,-2.8);

             
                        //Printing 
the values of objects variables

             
                        System.out.println(”p3:x=”+p3.get_x());

             
                        System.out.println(”p3:y=”+p3.get_y());

                             
System.out.println(”p3:z=”+p3.get_z());

 

                             
  }//end of main

                          }//end of class

 

Other references: http://java.sun.com/developer/onlineTraining/Programming/BasicJava2/oo.html#what

More on arrays

An array is a structure that holds multiple values of the same type. The length of an array is established when the array is created (at runtime). After creation, an array is a fixed-length structure.

An array element is one of the values within an array and is accessed by its position within the array.  

In other word when a number of data items are chunked together into a unit, the result is a data structure. Data structures can have very complex structure, but in many applications, the appropriate data structure consists simply of a sequence of data items. Data structures of this simple variety can be either arrays or records. The term “record” is not used in Java. Like a record, an array is a sequence of items. However, where items in a record are referred to by name, the items in an array are numbered, and individual items are referred to by their position number. Furthermore, all the items in an array must be of the same type.  Again the definition of an array is: a numbered sequence of items, which are all of the same type. The number of items in an array is called the length of the array. The position number of an item in an array is called the index of that item. The type of the individual items in an array is called the base type of the array. The base type of an array can be any Java type, that is, one of the primitive types, or a class name, or an interface name. If the base type of an array is int, it is referred to as an “array of ints.” An array with base type String is referred to as an “array of Strings.” However, an array is not, properly speaking, a list of integers or strings or other values. It is better thought of as a list of variables of type int, or of type String, or of some other type. As always, there is some potential for confusion between the two uses of a variable: as a name for a memory location and as a name for the value stored in that memory location. Each position in an array acts as a variable. Each position can hold a value of a specified type (the base type of the array). The value can be changed at any time. Values are stored in an array. The array is the container, not the values.  <>

The items in an array — really, the individual variables that make up the array — are more often referred to as the elements of the array. In Java, the elements in an array are always numbered starting from zero. That is, the index of the first element in the array is zero. If the length of the array is N, then the index of the last element in the array is N-1. Once an array has been created, its length cannot be changed.  <>

Java arrays are objects. This has several consequences. Arrays are created using a form of the new operator. No variable can ever hold an array; a variable can only refer to an array. Any variable that can refer to an array can also hold the value null, meaning that it doesn't at the moment refer to anything. Like any object, an array belongs to a class, which like all classes is a subclass of the class Object. The elements of the array are, essentially, instance variables in the array object, except that they are referred to by number rather than by name.

Suppose that A is a variable that refers to an array. Then the item at index k in A is referred to as A[k]. The first item is A[0], the second is A[1], and so forth. “A[k]” is really a variable, and it can be used just like any other variable. You can assign values to it, you can use it in expressions, and you can pass it as a parameter to subroutines. All of this will be discussed in more detail below. For now, just keep in mind the syntax

Creating and Using Arrays

Here's a simple program, called ArrayDemo, that creates the array, puts some values in it, and displays the values.

 

public class ArrayDemo {

    public static void main(String[] args) {

        int[] anArray;         // declare an array of integers

        anArray = new int[10]; // create an array of integers

        // assign a value to each array element and print 

        for (int i = 0; i < anArray.length; i++) {

            anArray[i] = i;

            System.out.print(anArray[i] + ” “);

        }

        System.out.println();

    }

}

Declaring a Variable to Refer to an Array

This line of code from the sample program declares an array variable:

int[] anArray;          // declare an array of integers

Like declarations for variables of other types, an array declaration has two components: the array's type and the array's name. An array's type is written type[], where type is the data type of the elements contained within the array, and [] indicates that this is an array. Remember that all of the elements within an array are of the same type. The sample program uses int[], so the array called anArray will be used to hold integer data. Here are declarations for arrays that hold other types of data:

float[] anArrayOfFloats;

boolean[] anArrayOfBooleans;

Object[] anArrayOfObjects;

String[] anArrayOfStrings;

As with declarations for variables of other types, the declaration for an array variable does not allocate any memory to contain the array elements. The sample program must assign a value to anArray before the name refers to an array.

Creating an Array

You create an array explicitly using Java's new operator. The next statement in the sample program allocates an array with enough memory for ten integer elements and assigns the array to the variable anArray declared earlier.

anArray = new int[10];  // create an array of integers

In general, when creating an array, you use the new operator, plus the data type of the array elements, plus the number of elements desired enclosed within square brackets ('[' and ']').

new elementType[arraySize]

If the new statement were omitted from the sample program, the compiler would print an error like the following one and compilation would fail.

ArrayDemo.java:4: Variable anArray may not have been initialized.

Accessing an Array Element

Now that some memory has been allocated for the array, the program assign values to the array elements:

for (int i = 0; i < anArray.length; i++) {

    anArray[i] = i;

    System.out.print(anArray[i] + ” “);

}

This part of the code shows that to reference an array element, either to assign a value to it, or to access the value, you append square brackets to the array name. The value between the square brackets indicates (either with a variable or some other expression) the index of the element to access. Note that in Java, array indices begin at 0 and end at the array length minus 1.

Getting the Size of an Array

To get the size of an array, you write

arrayname.length

Be careful: Programmers new to the Java programming language are tempted to follow length with an empty set of parenthesis. This doesn't work because length is not a method. length is a property provided by the Java platform for all arrays.

The for loop in our sample program iterates over each element of anArray, assigning values to its elements. The for loop uses anArray.length to determine when to terminate the loop.

Array Initializers

The Java programming language provides a shortcut syntax for creating and initializing an array. Here's an example of this syntax:

boolean[] answers = { true, false, true, true, false };

The length of the array is determined by the number of values provided between { and }.

 Source: http://www.faqs.org/docs/javap/c8/s1.html

Arrays

Arrays are a collection of objects or data types that are stored in cells. All elements of the array are of the same data type. The celles are numbered with the first elements  in the array alaways number as 0.

Elements of the array are referenced by
Arrayname[index]

If the size of the array is N, the index will be from 0 till N-1, with index referencing the first element and index N-1 referencing tha last elements.

*Important Notice: Make sure that you do not go outside the range (0-> N-1) of the array.
It will cause an error.

Homework

/* Course : Java 1
Instructor: Prof. Pascal SAID
Date: Nov. 12, 2004
*/

/*Write a Java program that will printout the following:

******
******
******
******
******
******

PseudoCode
————————————

For each time x is less then or equal to 6 printout a line like this ******
Then go to the next line.

*/
    class test1 {
    public static void main(String[] args) {

    for (int x = 1; x <=6; x++)
    {

    System.out.print(”******”);
    System.out.println(”");

    }
            } //end of main() function
    } //end of Printout1 class.

What is Java?

Java has 2 things:  A programming language and a platform.

 

Java is a high-level programming language that is all the following:

 

Simple	Secure
Object-Oriented	Dynamic
Distributed	Architecture-neutral
Interpreted	High-Performance
Robust	Multi-threaded
Portable

 

For those of you who would like to have an internet companion book, please follow this links:

 

http://java.sun.com/docs/books/tutorial/getStarted/index.html

 

You write your java program using lets say TextPad and you must save it with the .java extension.You then have to compile file1.java through TextPad

(short cut is <Ctrl> +1). The compiler generate a .class file i.e. file1.class

Basiscally with the compiler, you translate a Java program into an intermediate languages called Java bytecode: the platform-independent codes interpreted by the java interpreter.

With an interpreter, each java bytecode instruction is passed and run on the computer. Compilation takes place once interpretation occurs each time the program is executed</u>.

 

The java platform has 2 components:

 

The first one the java virtual machine (VM) is the base for the java platform and is ported onto various hardware-base platform

The second one is the java application programming Interface (Java API) vs. (Window API for example) It is a large collection of READY MADE software components that provides many useful capabilities such as GUI (graphical ser interface) widget. The Java API is grouped or organized into libraries (packages) of related components.

 

Java Program
Java API	The Java Platform (which is the java API +VM
Java VM
Hardware-based platform

 

Important: the API and the VM insulate the java program from hardware dependencies

 

Java Applet Definition: An applet is a Java program that adhere to certain conventions that allow it to run within a Java enable browser.

 

Let us take a look at our first Java Program using a text editor like TextPad

Create a new file and call it HelloWorldApp.java

 

 

/* The Hello Class implements and application that simply displays the “Hello World!”to the standard

screen output

*/

class HelloWorldApp{

  public static void main(String[] args) {

    System.out.println(”Hello World!”);

  }     //end of main()function

}     //end of HelloWorldApp class.

 

Here if your compilation succeeds, the compiler creates a file name HelloWorldApp.class in the same directory (folder as the java source file (HelloWorldApp.java) this class file contains Java bytecode-platform independent codes interpreted by the Java interpreter.

 

Important the execution entry point of every Java application is in its main() method.

 

 

Object Oriented Concept

 

Many examples of  real world objects (like your office, your desk) these two object share two characteristic:

 

• They all have a state
• They all have behaviors

 

A software object maintains its states in variables and implements its behavior with methods (functions).

 

Definition: An object is a software bundle of variables and related methods.

 

Defining a class:

A class is the basic bundling block of an Object-Oriented language. It describes the sate and the behavior associated with instances of that class. When you instantiate a class, you create an object that has the same state and behavior as other instances of the same class. The state associated with a class or object is stored in member variables. The behavior associated with a class or object is implemented with methods (functions).

Lets take the example of a class that represents a rectangle. The class defines variables for the origin width and height of the rectangle. It might also define a method that calculates the area of the rectangle.

An instance of the rectangle class is an object that contains the information for specific rectangle (specific means an instance), such as the dimensions of the floor of your office. In other words, you can consider a class to be like an Abstract Data Type and the Object is like a variable (in this case and instance) of that class. Therefore, you have to declare and object of data type class in order to work with it. You can assign values to an object not to a class.

 

The main() method:

 

Public static void main(String[] args)

Every Java program must contain a main method declared like the statement above.

 

The main method declaration starts with 3 modifiers:

-public: allow any object to call the main() method

-static: means the main() method is a class method

-void: indicates that the main() method does not return a value.

 

Now the arguments to the main() method:

 

The main() method accepts a single argument, which is an array of elements of type String. This array is the mechanism through which Java Virtual machine passes information to your application. Each string is called a command-line argument.

 

The HelloWorldApp application uses another class System that is part of the Java API. One feature provided by the System class is the standard output stream.

System.out.println(“HelloWorld”); It uses a class variable and an instance method.

Microsoft Settles with Novell

…”Microsoft has agreed to pay Novell $536 million, in return for Novell withdrawing from the European Union's antitrust case against the maker of the Windows family of operating systems. Microsoft also reached a settlement with the Computer & Communications Industry Association.”

ARGH!!!

Three basic keys you must master in computer sciences

Programming
Database Systems
Software Engineering

The software development process:

Feasibility Study: This document must answer the following question: how much? how many employee? what tools? (hardware, software, pricing, licensing..) At the end of this process a partial contract will be sign.
The people handling feasibility study usually travels a lot spend a lot of time in restaurants and ride fancy cars.

 
Requirement Analysis: This document must answer the question WHAT MUST BE DONE not HOW. This is a thick document that is almost lawyer-like, it will give  a clear definition for each elements that are brought in.  This document must be precise clear and complete in the sense that it analyze the requirements but also offers alternatives, when you create such document you must think about every single possibilities: you must focus on FONCTIONAL REQUIREMENT and NON-FONCTIONAL REQUIREMENT (alternatives)
Note that this document must be general in order for you to be able to sell it to other company with similar requirements, by simply making minor modifications you can save time and money. Never say HOW but always focus on WHAT needs to be done.

Design: This document focus on the HOW. How relational design for business retrieves information. Or HOW object oriented (i.e. CAE) is used for virtual reality or 3D applications  but it generally relates to  the database aspect.
The design process implies: the user interface design, the database design the object-oriented design going from a general point of view, to a specific one, to a very detailed one.
Guys who work in that field usually have a nice office the nice view and have to dress-up for the part.

Implementation: This is where the job of the programmer comes in. The programmer must find a solution based on the design proposed.
Those guys generally do not talk to customer and management couldn't careless about their social skills or fashion sense.

Integration & Testing: At this stage, a program may be written that will test if the requirement were met, It is the verification (doing the things right) and the validation (doing the right thing)  step. Basically the requirements must be verifiable.
The guys who work in testing have the worst job, it is tedious and boring.

Training&Delivery:  Basically this is the creation of the manual for the application that was created and the preparation of training classes for eventual users.

Maintenance: At this stage this is where the company starts to make money. Once a contract is written some guarantees are offered for lets say…the first 3 months but any further assistance; for example  enhancement, or adaptive maintenances (platform migration) comes with an hefty price tag.
Basically at this point the client gets robbed.

General notes about the software development process:

The project manager is the one that heads all the steps involve in the software development process. He’s the one with the real headache. Software development  must be done in the above sequence ideally, or in parallel, where you throw down the line some part of the project.
Note that partial delivery is the best approach for a first project.

  Tips from the wise one:

To be a successful CEO you must master all above keys.

You must understand that computer sciences is like a wave on a Californian beach. A peak is reached, it recedes and it all  starts over…There will be time with marvelous job and other times where you would rather not talk about your career. The most important thing is to keep your head  above water when the wave passes and that can be accomplish by keeping up with new technology. If you keep up you will most certainly win.

If while working as a programmer you discover several mistakes in the design process, keep your mouth shut, point out the mistakes only twice a year, otherwise you will upset your superiors and will most certainly be in the penalty box or better yet loose your job.

Learn to work your memory muscle on a daily basis to be a good programmer; at the end of each course when you are home give yourself 15 minutes to review in your head  what you have learn during the classes , go through it in your head step by step. First this will work your memory muscle and secondly it will ensure that 90% of  what was  learn sticks. Note that for every day you will wait 20% of the information learnt will be lost .

 

…Everytime

But this time IT is different.