Download pdf - Java first Session

Transcript
Page 1: Java first Session

Java Programming Language Session 1 

1. Programming concepts and algorithms

a. What is programming: it is the process of writing, testing, debugging/troubleshooting, and maintaining the source code/commands/instructions of computer programs. This source code is written in a programming language e.g. visual basic, C, C++, Pascal, Java.

b. What is a programming language: A vocabulary and set of grammatical rules for instructing a computer to perform specific tasks. The term programming language usually refers to high-level languages, such as BASIC, C, C++, COBOL, FORTRAN, Ada, and Pascal. Each language has a unique set of keywords (words that it understands) and a special syntax for organizing program instructions.

High-level programming languages, while simple compared to human languages, are more complex than the languages the computer actually understands, called machine languages. Each different type of CPU has its own unique machine language.

Lying between machine languages and high-level languages are languages called assembly languages. Assembly languages are similar to machine languages, but they are much easier to program

Page 2: Java first Session

in because they allow a programmer to substitute names for numbers. Machine languages consist of numbers only.

Lying above high-level languages are languages called fourth-generation languages (usually abbreviated 4GL). 4GLs are far removed from machine languages and represent the class of computer languages closest to human languages.

Regardless of what language you use, you eventually need to convert your program into machine language so that the computer can understand it. There are two ways to do this:

• compile the program (explained later)

• interpret the program (explained later)

c. Kinds of programming Languages:

• Imperative— “telling the machine what to do”

• Declarative— “telling the machine what to achieve”

d. What is object oriented programming: a method of

implementation in which programs are organized as cooperative collection of objects, each of which represents an instance of a class, and whose classes are all members of a hierarchy of classes

Page 3: Java first Session

united via inheritance relationships. These objects communicate and interact together E.g. books (science fiction/ adventure/ horror), customer (individual/ retailer), product (CD/ DVD/ HD) . Advantage: easy to create similar objects without having to rewrite the overlapping code, just modify

Four major concepts of OOP

• Abstraction: denotes the essential characteristics of an object that distinguish it from all other kinds of objects. This is in variables e.g. name, ID and methods (functions or procedures) used to do a certain operation or calculation. You can add to or modify them. • Encapsulation: Encapsulation hides information from unwanted outside access by attaching that information to only methods that need access to it. This binds data and operations tightly together and separates them from external access that may corrupt them intentionally or unintentionally.

Page 4: Java first Session

Encapsulation is achieved by declaring variables as Private in a class- this gives access to data to only member functions of the class. • Inheritance: Inheritance is the process by which one object acquires the properties of another object • Polymorphism: Polymorphism is a term that describes a situation where one name of method may refer to different methods of different implementations. java determines the proper methods to call at the program’s run time e.g.

Class Book {

String title; String publisher; float price; setBook(String title) {} setBook(String title, String publisher) {} setBook(String title, String publisher,float price){}

}

e. What are algorithms: a sequence of language independent steps which may be followed to solve a problem

2. Java technology

a. What is java:

• Simple powerful language

• Similar to C++ (both object oriented supporting classes instantiated from objects / similar variable types e.g int, float / case sensitive)

• Originated at Sun Microsystems, Inc. in 1991. It was conceived by James Gosling

• Developed to provide a platform-independent programming language on any system where a Java™ Virtual Machine is available e.g. Windows 9x/ME/NT/2000/XP etc., MacOS, OS/2, Solaris, LINUX, UNIX and PDAs (Pocket PCs).

Page 5: Java first Session

b. Applications of java : • Web based applications – ecommerce (Java applets - small standalone applications e.g. text editor, calculator - can run in a Web browser for many platforms, including Windows, Unix, Mac OS and Linux using a Java Virtual Machine). The client sends an HTTP request to the web server. A web server that implements Java Servlet and JavaServer Pages technology converts the request into an HTTPServletRequest object. This object is delivered to a web component (There are two types of web components: Java Servlets and JavaServer Pages (JSP ) pages. Servlets are Java programming language classes that dynamically process requests and construct responses), which can interact with JavaBeans components or a database to generate dynamic content. The web component can then generate an HTTPServletResponse or it can pass the request to another web component. Eventually a web component generates a HTTPServletResponse object. The web server converts this object to an HTTP response and returns it to the client).

Page 6: Java first Session

• Financial applications (stocks / payroll / banks), • Gaming applications (racing cars etc.),

• Embedded systems (desktop systems provide a wide spectrum of technologies to serve a broad range of application needs, while embedded devices are fitted with just enough software to handle a specific application.- Microcontroller-Based Temperature Monitoring and Control / Navigation system using a GPS receiver / Communications systems for protocol conversion and VoIP / energy meter reading / air conditioner remote control, audio player remote control, typing speed indicator, database application, electronic voting.

• Distributed enterprise applications

Page 7: Java first Session

• Mobile applications (cinema repertoire - browsing currently displayed movies with reviews, descriptions, photos. Repertoire is updated at user’s request. Electronic Brochure of Products/Services- providing users with information about your services or products).

• Image processors: helps developers manipulate image pixels using Java 2D API. Processing an image is simply a matter of calculating a new color for each pixel. A platform-independent application to view, edit and print images on any system where a Java™ Virtual Machine is available

Page 8: Java first Session

• Desktop applications e.g. MagicDraw UML, ArgoUML

Page 9: Java first Session

c. Java versions

• JAVA 1.0 - 1995

• JAVA 2 – 2006 (J2EE(enterprise), J2ME(micro), J2SE(standard))

d. Features & Advantages of java

• Portable - Platform Independent: Unlike many other programming languages when Java is compiled, it is not compiled into platform specific machine, rather into platform independent byte code. This byte code is distributed over the web and interpreted by virtual Machine (JVM) on whichever platform it is being run. When compiled, the code will run in a similar fashion on any platform. A programmer should be able to write a program one time, compile it one time, and then be able to execute it anywhere. As SUN slogans:”Write once, run anywhere”

• Simple: easy to learn

• Reusable: can use code (classes, objects & methods) all over again don’t have to rewrite it

• Distributed: With extensive set of routines to handle TCP/IP protocols like HTTP and FTP java can open and access the objects across net via URLs

• Robust: Automatic garbage collection is another great feature of Java with which it prevents inadvertent corruption of memory by freeing the memory if the object is no longer needed.Also the concept of Exception Handling allows java to detect errors during runtime and prevent the program from crashing suddenly.

• Secure: Java was designed to allow secure execution of code across network. To make Java secure many of the features of C and C++ were eliminated. Java does not use Pointers - Java programs cannot access arbitrary unprotected addresses in memory.

• High Performance: fast compilation

• Dynamic : interacts with databases & enterprise information systems EIS

Page 10: Java first Session

• Multi-Threaded: One of the powerful aspects of the Java language is that it allows multiple threads of execution to run concurrently within the same program independently and continuously e.g. Multiple Java applets can run on the browser at the same time sharing the CPU time

e. Why use it rather than C/C++

• Platform independent

• Easier – not complex to learn 3. Java code

a. Classes & Objects

• Classes are a blueprints, templates or prototypes from which objects are created. An object is an instance of a class. So 2 dogs but one has long tail the other has short but they both have tails

• Objects are often used to model the real-world objects that you find in everyday life

• Objects have state (attributes/characteristics) and behavior. Dogs have state (name, color, breed, hungry) and behavior (barking, fetching, wagging tail)

• Objects interact with each other by sending messages E.g. invoice & receipt e.g. lego objects form larger objects together

b. Methods • An object stores its state in fields (variables in some programming languages) and exposes its behavior and interaction with the outer world through methods (functions in some programming languages).

• Hiding internal state and requiring all interaction to be performed through an object's methods is known as data encapsulation (e.g. when assembling a pc, each object- card, processor etc.- is a self contained unit, and all you are interested in is how the units interact with each other not how each one works alone)

Page 11: Java first Session

c. How to write Java: • Enter the program source code in a data file using an editor e.g. JCreator / IBM Websphere etc.

• Transform the source program into machine language or Java Bytecode using a compiler

• Return to the editor to correct any errors (or bugs) and start the cycle again

• Bytecode files, which are very compact, are easily transported through a distributed system like the Internet.

• The compiled Java code (resulting byte code) will be executed at run time

Java programs can be written and executed in two ways:

• Stand-alone application (A Java Swing (interface) Application) • Applet which runs on a web browser (Example: Internet Explorer)

4. Compiler and interpreter

Page 12: Java first Session

a. What is a compiler & JVM

• In Java, the compiler is called a class compiler. A class compiler compiles high-level Java code into a set of assembly-like instructions known as Java bytecodes. The bytecodes are the machine language of Java's "virtual machine." The virtual machine idea is central to Java's platform independence. A virtual machine can be any platform-hardware or software-that is capable of understanding and executing Java bytecodes. There are currently three such platforms: Java Virtual Machines, Just-in-Time Compilers, and Java Processors.

• The Java Virtual Machine (VM) is a piece of software implemented on top of hardware and operating system that translates Java bytecodes to the processor's native opcodes as they are executed. There are many implementations of the Java VM available, but all of them support the same set of bytecodes defined in the Java Virtual Machine Specification. Versions of the Java VM are available for many common hardware platforms.

• Interpreted languages are portable, but slow. Just-in-Time (JIT) compilers were invented to speed the execution of Java programs by speeding up the language translation process. A JIT compiler is a drop-in replacement for the Java VM. The only difference is that it keeps a copy of all previously translated code for potential reuse. That way, the same section of code never has to be reinterpreted. Only new bytecodes that have not been previously executed need to be translated. A typical program with loops and repeated function calls should execute about 10 times faster under a JIT compiler. That makes the speed of programs written in Java comparable to those written in C++.

• To speed the execution of Java bytecodes even further, Sun Microsystems has announced a line of Java processors. These are hardware realizations of the Java virtual machine. In other words, each Java processor is a microprocessor with a set of opcodes that are identical to the Java bytecode standard. To eliminate the need for native methods, these chips will have a set of extended bytecodes for accessing memory directly. It is reasonable to expect that these so-called JavaChips will execute Java bytecodes as quickly as any

Page 13: Java first Session

processor can execute its own assembly language. However, since the programs themselves will be written in the high-level Java, it is more realistic to expect performance comparable to C.

b. What is an interpreter : An interpreter translates high-level instructions into an intermediate form, which it then executes. In contrast, a compiler translates high-level instructions directly into machine language. Compiled programs generally run faster than interpreted programs. The advantage of an interpreter, however, is that it does not need to go through the compilation stage during which machine instructions are generated. This process can be time-consuming if the program is long. The interpreter, on the other hand, can immediately execute high-level programs. For this reason, interpreters are sometimes used during the development of a program, when a programmer wants to add small sections at a time and test them quickly. The disadvantage is that interpreted programs run much slower than compiled programs. As much as 5-10 times slower as every line of code has to be re-read, then re-processed

c. JDK (Java Development Kit) A free software development package from Sun Microsystems that implements the basic set of tools needed to write, test and debug Java applications and applets and java compiler to run them. The JDK contains documentation, examples, installation instructions, class libraries and packages, and tools. To run java applications you must install it. After using an editor like JCreator to type your code, you must save your source code with a .java extension. The name of the file must be the name of the public class contained in the file.

d. Java API: API stands for “Application Programming Interface”. The command line arguments used for a program are an API. It is the set of methods or objects which a programmer can manipulate. It is The interface (calling conventions) by which an application program accesses operating system and other services

e. J2EETM Architecture- The Java™ 2 Platform, Enterprise Edition (J2EE) provides a standard for developing multitier, enterprise services

Page 14: Java first Session

Database Server

Page 15: Java first Session

• Client tier: In the client tier, Web components, such as Servlets and JavaServer Pages (JSPs), or standalone Java applications provide a dynamic interface to the middle tier.

• Middle tier: In the server tier, or middle tier, enterprise beans and Web Services encapsulate reusable, distributable business logic for the application. These server-tier components are contained on a J2EE Application Server, which provides the platform for these components to perform actions and store data.

• Enterprise data tier: In the data tier, the enterprise's data is stored and persisted, typically in a relational database.

J2EE applications are comprised of components, containers, and services. Components are application-level components.

It consists of the following technologies

• Java Database Connectivity (JDBC) : The JDBC API allows the java programs to access the database

• Java Naming and Directory Interface (JNDI) : allows the java applications to access enterprise naming and directory services

• Enterprise Java Beans (EJB) : a component architecture for developing and deployment of component-based distributed applications. EJB components contain server-side business logic for enterprise applications.

• Web components, such as Servlets and JSPs, provide dynamic responses to requests from a Web page.

• Java Server Pages (JSP) : Java Server Pages allows the developers to embed the java code into html pages. It is a mean by which dynamic content can be generated using the static HTML pages and the data from the database.

• Java Servlets: Java Servlets are server side components that provides a powerful mechanism for developing serverside applications.

Page 16: Java first Session

Java Programming Language Session 2 

Use Case Models “Architectural” view of the system viewed by its end-users and the services they use.

Key elements in the Use Case model are “actors” and “use cases” and “other systems” to which it’s connected.

A use-case is a service, or unit of functionality in the system. Use cases are often used as an aid to “requirements specification”. It is relatively easy to discuss the correctness of a use-case model with a non-technical person (e.g., your client),

Example (View Points /Services)

The viewpoints become “actors”

• Human being • External computer systems.

The services become “use-cases”

Page 17: Java first Session
Page 18: Java first Session

Case Study A retail business wishes to automate some of its sales procedures. Preliminary interviews reveal that there are number of staff roles in the Sales department:

A salesperson can place orders on behalf of customers and check the status of these orders.

A technical salesperson has the same duties, but additionally is able to provide customers with detailed technical advice (which we would not expect an ordinary salesperson to be able to do).

A sales supervisor is a salesperson, with the additional responsibility of creating new customer accounts and checking their credit-worthiness.

A despatcher is responsible for collecting the goods ordered from the warehouse, and packing them for despatch to the customer.

To assist in this operation the computer system should be able to produce a list of unpacked orders, and delete the orders from the list that the despatcher has packed.

All staff are able to find general details of the products stocked, including stock levels and locations in the warehouse.

A re-ordering clerk is responsible for finding out which products are out of stock in the warehouse, and placing orders for these products from the manufacturers.

The system should be able to advise the re-order clerk of which products are `priority' products.

A stock clerk is responsible for placing items that arrive from manufacturers in their correct places in the warehouse. To do this the clerk needs to be able to find the correct warehouse location for each product from the computer system.

Currently the same person in the business plays the roles of stock clerks and re-order clerk.

Page 19: Java first Session

Types of Classes

Concrete Classes: Classes like 'Book' and 'Member' are physical or concrete classes They correspond to REAL things in the physical world

Conceptual classes: The classes 'Loan' and 'Return date' are different 'types' of classes. They do not correspond to real, physical entities at all.

Attributes (Variables)

Attributes are the PROPERTIES of a class; on the whole they are things that can be measured or observed.

When a new object is created, an area of the computer's memory is allocated to store the object.

Attributes are defined by variables : locations in memory in which values can be stored

Variables have a name, type, value

A variable must be declared before you can use a variable. After declaration, values can be assigned to it

Types of Variables

instance variables: (Non-Static Fields) used to define attributes or the state for a particular object INSTANTIATED from a class.

Each instance (object) can have different values for a variable but always the same type. (Even if all the attributes of two objects are identical, this does not make the objects identical).

Instance variables may be set when an object is created and stay constant throughout the life of the object, or they may be able to change at will as the program runs.

class variables: (Static Fields) this tells the compiler that there is exactly one copy of this variable in existence. They apply to all that class's instances (and to the class itself) rather than having different values for each object.

Class variables' values are stored in the class itself. local variables: are declared and used only inside a method definition or a block.

Once the method (or block) finishes executing, the variable definition and its value cease to exist.

Data Types of Variables

Each variable declaration must have a type, which defines what values that variable can hold. The variable type can be one of three things:

One of eight primitive data types They handle integers, floating-point numbers, characters, and boolean values

(true or false).

Page 20: Java first Session

They're called primitive because they're built into the system and are not actual objects, which makes them more efficient to use :

Integer (4): Type

Size

Range

byte 8 bits —128 to 127

short 16 bits —32,768 to 32,767

int 32 bits —2,147,483,648 to 2,147,483,647

long 64 bits —9223372036854775808 to 9223372036854775807 Floating-point decimals (2):

float (32 bits precision) double (64 bits precision)

Individual characters : char

Boolean type can have one of two values, true or false: boolean

The name of a class or interface : variables in Java can also be declared to hold an instance of a particular class

e.g. String text = "hello"; (as opposed to : “char x = text[1];”) Font basicFont; OvalShape myOval;

An array (explained later)

Declaring variables

Variable declarations consist of a type and a variable name They are most commonly declared at the beginning of the definition before they are used, e.g.

public static void main (String args[]) { int myAge; String myName; boolean isTired;}

You can string together variable names with the same type e.g. int x, y, z;

You can also give each variable an initial value when you declare it: int a = 4, b = 5, c = 6;

Local variables must be given values before they can be used (your Java program will not compile if you try to use an unassigned local variable).

Instance and class variable definitions do not have this restriction (their initial value depends on the type of the variable: null for instances of classes, 0 for numeric variables, '0' for characters, and false for booleans).

Page 21: Java first Session

Assigning Values to Variables

Once a variable has been declared, you can assign a value to that variable by using the assignment operator =:

size = 14; tooMuchCaffiene = true; name= “noha”

Variable/Method Names

choose names that are meaningful - represent the characteristic of the variable or what the method does

Variable names in Java can start with a letter, an underscore (_), or a dollar sign ($).

They cannot start with a number Do not use reserved java words e.g. “class”, “public” etc. Symbols, such as %, *, @, and so on, are often reserved for operators in Java so avoid them

Names in java are case sensitive If it’s a complex name the first word is lowercase, but all following words have an initial uppercase letter e.g.

Button theButton; long reallyBigNumber; boolean currentWeatherStateOfPlanetXShortVersion;

Comments

Java has three kinds of comments /* and */ surround multiline comments , e.g.

/* I don't know how I wrote this next part; I was working really late one night and it just sort of appeared. */

Double-slashes (//) can be used for a single line of comment comments beginning with /** and ending with */ are used to generate API documentation from the code. (API) is an interface implemented by a software program to enable interaction with other software, much in the same way that a user interface facilitates interaction between humans and computers.

String Literals

String literals consist of a series of characters inside double quotes. The most used is ‘\n’ which means new line e.g. "A string with a \n new line" Methods (operations)

Operations say what a class does.

Page 22: Java first Session

Methods are operations/functions defined inside classes that operate on instances (objects) of those classes. Java does not have functions (methods) defined outside classes (as C++ does)

Message Passing: All of a class's operations are accessible to other classes (Public

Operations) Classes can communicate by invoking EACH OTHERS’ operations.

Method Declaration

Method definition syntax: return value type method-name ( parameter1, parameter2, …, parametern){ declarations and statements }

A method definition consists of a method header and a method body. A method header states the method name and the type of the return value. The header may also specify variables called formal parameters which receive incoming arguments. These formal parameters are used in them method body to perform the computations.

The method body consists of a sequence of declarations and statements enclosed in braces{}

The method main “public static void main (String args[])” has void as type of return value which means that it does not return a value, method name is main, this method returns a parameter of an array of Strings with any name. static means that the method belongs to the class in which it resides

Methods that do not return a value must have the reserve word void. Static methods operate on a class as a whole (not on specific instances of the class).

Keyword public means that it can be accessed from outside the class.

Creating Java Applications A Java application consists of one of more classes and can be as large or as small as you want it to be.

The jumping-off class for your program needs one thing: a main() method When you run your compiled Java class (using the Java interpreter), the main() method is the first thing that gets called.

Page 23: Java first Session

Examples

UML (Universal Modeling Language) is used to model classes class Customer { // variables <variable1> <variable2> <variable...> // methods <method1> <method2> } e.g. class Book

{ // variables

Page 24: Java first Session

String title; int numPages; String shelfMark; int daysLate;

// methods for getting the Title, Num of Pages, Shelf mark String getTitle() { // method implementation } int getNumPages() { // method implementation } String getShelfMark() { // method implementation}

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

1. This program has two main parts: a. All the program is enclosed in a class definition—here, a class called HelloWorld.

b. The body of the program (here, just the one line) is contained in a method (function) called main(). In Java applications, as in a C or C++ program, main() is the first method (function) that is run when the program is executed

2. Parentheses are used for the beginning and end of any class or method 3. Semicolons end each statement in a method 4. If a statement returns a value , it is called an expression e.g. when you add two

numbers together or test to see whether one value is equal to another 5. A statement is called a block if complex lines surrounded by parentheses e.g. loop,

array, if condition 6. Once you finish typing the program, save the file. Most of the time, Java source files

are named the same name as the class they define, with an extension of .java. This file should therefore be called HelloWorld.java.

7. Now, let's compile the source file using the Java compiler. In Sun's JDK, the Java compiler is called javac. The compiler should compile the file without any errors. If you get errors, go back and make sure that you've typed the program exactly as it appears

8. When the program compiles without errors, you end up with a file called HelloWorld.class, in the same directory as your source file. This is your Java bytecode file. You can then run that bytecode file using the Java interpreter. In the JDK, the Java interpreter is called simply java

9. If your program was typed and compiled correctly, you should get the string "Hello World!" printed to your screen as a response

10. You can make another class and instantiate this one from inside it i.e. make an instance of it which executes: If a class is the general (generic) representation of an object, an instance is its concrete representation = an object

a. e.g. you might create a class for the user interface element called a button. The Button class defines the features of a button (its label, its size, its appearance) and

Page 25: Java first Session

how it behaves (does it need a single click or a double click to activate it, does it change color when it's clicked, what does it do when it's activated?). Once you define the Button class, you can then easily create instances of that button—that is, button objects—that all take on the basic features of the button as defined by the class, but may have different appearances and behavior based on what you want that particular button to do. By creating a Button class, you don't have to keep rewriting the code for each individual button you want to use in your program, and you can reuse the Button class, by creating instances (objects) of it from inside other classes, to create different kinds of buttons as you need them .

Page 26: Java first Session

Second Java Application

class Motorcycle { String make; String color; boolean engineState;

public static void main (String args[]) {

Motorcycle m = new Motorcycle(); m.make = "Yamaha RZ350"; m.color = "yellow"; System.out.println("Calling showAtts..."); m.showAtts(); System.out.println("————"); System.out.println("Starting engine..."); m.startEngine(); System.out.println("————"); System.out.println("Calling showAtts..."); m.showAtts(); System.out.println("————"); System.out.println("Starting engine..."); m.startEngine(); }

void startEngine() {

if (engineState == true) System.out.println("The engine is already on."); else { engineState = true; System.out.println("The engine is now on."); } }

void showAtts() { System.out.println("This motorcycle is a " + color + " " + make); if (engineState == true) System.out.println("The engine is on."); else System.out.println("The engine is off."); }

}

Page 27: Java first Session

Answer: Calling showAtts... This motorcycle is a yellow Yamaha RZ350 The engine is off. ———— Starting engine... The engine is now on. ———— Calling showAtts... This motorcycle is a yellow Yamaha RZ350 The engine is on. ———— Starting engine... The engine is already on.

The first line declares the main() method Motorcycle m = new Motorcycle(), creates a new instance of the Motorcycle class and stores a reference to it in the variable m

P.S. you don't operate directly on classes in Java programs; instead, you create objects from those classes and then call methods in those objects. Thus when Java executes the main() method, the class that holds it is not automatically instantiated when your program runs. You have to instantiate it in the main() method yourself

Then set the instance variables for this motorcycle object Println – creates a new line for writing Then call the showAtts() method / startEngine() method All lines are shown in the console of the Application Developer The startEngine method tests to see whether the engine is already running (in the line engineState == true) and, if it is, merely prints a message to that effect. If the engine isn't already running, it changes the state of the engine to true and then prints a message.

== means check that both arguments are equal = means make the second argument equal to the first

Accessing and Setting Class and Instance Variables To get to the value of an instance variable, you use dot notation With dot notation, an instance or class variable name has two parts: the object on the left side of the dot, and the variable on the right side of the dot

e.g. m.color / m.startEngine() Calling Methods

Calling a method in objects is similar to referring to its instance variables: method calls also use dot notation

The object whose method you're calling is on the left side of the dot; the name of the method and its arguments is on the right side of the dot: e.g. myObject.methodOne(arg1, arg2, arg3);

all methods must have parentheses after them, even if that method takes no arguments:

e.g. myObject.methodNoArgs();

Page 28: Java first Session

Third Java Example: Calling methods in String class

class TestString { public static void main(String args[]) { String str = "Now is the winter of our discontent"; System.out.println("The string is: " + str); System.out.println("Length of this string: " + str.length()); System.out.println("The character at position 5: " + str.charAt(5)); System.out.println("The substring from 11 to 17: " + str.substring(11, 17)); System.out.println("The index of the character d: " + str.indexOf('d')); System.out.print("The index of the beginning of the "); System.out.println("substring \"winter\":" + str.indexOf("winter")); System.out.println("The string in upper case: " + str.toUpperCase()); } }

Answer:

The string is: Now is the winter of our discontent Length of this string: 35 The character at position 5: s The substring from positions 11 to 17: winter The index of the character d: 25 The index of the beginning of the substring "winter": 11 The string in upper case: NOW IS THE WINTER OF OUR DISCONTENT

N.B. All spaces are , and the counting starts at position “0”

Page 29: Java first Session

Fourth Java Example: The TestPoint Class.

import java.awt.Point; class TestPoint { public static void main(String args[]) { Point thePoint = new Point(10,10); System.out.println("X is " + thePoint.x); System.out.println("Y is " + thePoint.y); System.out.println("Setting X to 5."); thePoint.x = 5; System.out.println("Setting Y to 15."); thePoint.y = 15; System.out.println("X is " + thePoint.x); System.out.println("Y is " + thePoint.y); } } Answer: X is 10 Y is 10 Setting X to 5. Setting Y to 15. X is 5 Y is 15

Page 30: Java first Session

SmartSoft ITWorx IBM Link Orascom

Page 31: Java first Session

Java Programming Language Session 3/4

Scope of variables

Instance Variables (Non-Static Fields): objects store their individual states in

"non-static fields", that is, fields declared without the static keyword. Non-static

fields have values that are unique to each instance of a class (to each object); the currentSpeed of one bicycle is independent from the currentSpeed of another.

Class Variables (Static Fields): A class variable is any field declared with the static modifier; this tells the compiler that there is exactly one copy of this variable

in existence; regardless of how many times the class has been instantiated. A field defining the number of gears for a bicycle could be marked as static since the same

number of gears will apply to all instances, e.g. static int numGears = 6 (static

field). Additionally, the keyword final could be added to indicate that the number of

gears will never change.

Local Variables: a method stores its temporary state in local variables, e.g. int

count = 0;). Local variables are only visible to the methods in which they are declared; they are not accessible from the rest of the class.

N.B. String objects are immutable, which means that once created, their values cannot be changed e.g. String s = "this is a string";

They are instantiated from the java.lang.String class

Arrays

An array is a container object that holds a fixed number of values of a single type. The length of an array is established when the array is created. After creation, its length is

fixed.

An array of ten elements

Each item in an array is called an element, and each element is accessed by its numerical

index. Numbering begins with 0. The 9th element, for example, would therefore be accessed at index 8.

Page 32: Java first Session

Declaring a Variable to Refer to an Array

Like declarations for variables, an array declaration has two components: the array's type and the array's name.

An array's type is written as type[], where type is the data type of the

contained elements; the square brackets are special symbols indicating that this variable holds an

array. The size of the array is not part of its type (which is why the brackets are

empty). The declaration does not actually create an array — it simply tells the

compiler that this variable will hold an array of the specified type.

e.g. byte[] anArrayOfBytes;

boolean[] anArrayOfBooleans; String[] anArrayOfStrings;

You can also place the square brackets after the array's name: float anArrayOfFloats[]; // this form is discouraged

Creating, Initializing, and Accessing an Array

1. One way to create an array is with the new operator.

Int[] anArray = new int[10];

It allocates an array with enough memory for 10 integer elements and assigns the array

to the anArray variable. If this statement were missing, the compiler would print an error, and compilation would

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

To assign values to each element of the array:

anArray[0] = 100;

Each array element is accessed by its numerical index: System.out.println("Element 1 at index 0: " + anArray[0]);

2. The shortcut syntax can be used to create and initialize an array: int[] anArray = {100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};

Here the length of the array is determined by the number of values provided between {

and }.

Example

The following program, ArrayDemo, creates an array of integers, puts some values in it,

and prints each value to standard output.

Page 33: Java first Session

class ArrayDemo { public static void main(String[] args) {

int[] anArray; // declares an array of integers anArray = new int[3]; // allocates memory for 3 integers anArray[0] = 100; // initialize first element anArray[1] = 200; // initialize second element anArray[2] = 300; // etc. System.out.println("Element at index 0: " + anArray[0]); System.out.println("Element at index 1: " + anArray[1]); System.out.println("Element at index 2: " + anArray[2]); } }

Answer: Element at index 0: 100

Element at index 1: 200 Element at index 2: 300

It’s easier to use one of the looping constructs (for, while, and do-while) to iterate through each element of the array, rather than write each line individually as shown

above, as will be shown later.

Multi Dimensional Arrays

You can also declare an array of arrays (also known as a multidimensional array) by

using two or more sets of square brackets, such as String[][] names. Each element, therefore, must be accessed by a corresponding number of index values.

In the Java programming language, a multidimensional array is simply an array whose components are themselves arrays. A consequence of this is that the rows are allowed to

vary in length, as shown in the following MultiDimArrayDemo program:

class MultiDimArrayDemo { public static void main(String[] args) { String[][] names = {{"Mr. ", "Mrs. ", "Ms. "}, {"Smith", "Jones"}}; System.out.println(names[0][0] + names[1][0]); System.out.println(names[0][2] + names[1][1]); System.out.println(names.length); }

}

Page 34: Java first Session

Answer:

Mr. Smith Ms. Jones

To determine the size of any array use the built-in length property:

System.out.println(anArray.length);

N.B.

- length of single array gives number of elements - length of multi dimensional array gives number of single arrays

- string.length() array.length

Copying Arrays

The System class has an arraycopy method that you can use to efficiently copy data from one array into another:

public static void arraycopy (Object src, int srcPos,

Object dest, int destPos,

int length) The two Object arguments specify the array to copy from and the array to copy to. The

three int arguments specify the starting position in the source array, the starting position in the destination array, and the number of array elements to copy.

The following program, ArrayCopyDemo, declares an array of char elements, spelling the word "decaffeinated". It uses arraycopy to copy a subsequence of array components into

a second array:

class ArrayCopyDemo { public static void main(String[] args) { char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e', 'i', 'n', 'a', 't', 'e', 'd' }; char[] copyTo = new char[7];

System.arraycopy(copyFrom, 2, copyTo, 0, 7); System.out.println(new String(copyTo)); } }

Answer:

Caffein.

Page 35: Java first Session

(mention VECTORS)

Page 36: Java first Session

Operators

Operators are special symbols that perform specific operations on one, two, or three operands, and then return a result.

Assignment Operator

The simple assignment operator "="

assigns the value on its right to the operand on its left e.g. int speed = 0;

can also be used on objects to assign object references e.g.

Point originOne = new Point(23, 94);

Arithmetic Operators

+ addition operator (also used for String concatenation) - subtraction operator

* multiplication operator / division operator

% remainder operator: divides one operand by another and returns the remainder as its result

e.g.

class ArithmeticDemo { public static void main (String[] args){ int result = 1 + 2; // result is now 3 result = result - 1; // result is now 2 result = result * 2; // result is now 4 result = result / 2; // result is now 2 result+=8; // result is now 10 result = result % 7; // result is now 3 System.out.println(result); } }

The + operator can also be used for concatenating (joining) two strings together

e.g.

class ConcatDemo { public static void main(String[] args){ String firstString = "This is"; String secondString = " a concatenated string."; String thirdString = firstString+secondString; System.out.println(thirdString); } }

Page 37: Java first Session

You can also combine the arithmetic operators with the assignment operator to

create compound assignments. e.g.

result+=1 is the same as result=result+1

Expression

Meaning

x += y x = x + y

x —= y x = x — y

x *= y x = x * y

x /= y x = x / y

The Unary Operators

+ Unary plus operator; indicates positive value (numbers are positive without this, however)

- Unary minus operator; negates an expression ++ Increment operator; increments a value by 1

-- Decrement operator; decrements a value by 1 ! Logical complement operator; inverts the value of a boolean

e.g.

class UnaryDemo { public static void main(String[] args){ int result = +1; // result is now 1

result--; // result is now 0 result++; // result is now 1 result = -result; // result is now -1 boolean success = false; System.out.println(success); // false System.out.println(!success); // true } } N.B.

result = +1 is different from result+=1

The increment/decrement operators can be applied before (prefix) or after (postfix)

the operand. The code result++; and ++result; will both end in result being

incremented by one. The only difference is that the prefix version (++result) evaluates to the incremented value, whereas the postfix version (result++) evaluates to the original value.

Page 38: Java first Session

class PrePostDemo { public static void main(String[] args){

int i = 3; i++; System.out.println(i); // "4" ++i; System.out.println(i); // "5" System.out.println(i++); // "5" System.out.println(++i); // "7" System.out.println(i); // "7" } } The Equality and Relational Operators

The equality and relational operators determine if one operand is greater than, less than,

equal to, or not equal to another operand.

== equal to

!= not equal to > greater than

>= greater than or equal to < less than

<= less than or equal to e.g.

class ComparisonDemo { public static void main(String[] args){ int value1 = 1; int value2 = 2; if(value1 == value2) System.out.println("value1 == value2"); if(value1 != value2) System.out.println("value1 != value2"); if(value1 > value2) System.out.println("value1 > value2"); if(value1 < value2) System.out.println("value1 < value2");

if(value1 <= value2) System.out.println("value1 <= value2"); } }

Answer:

value1 != value2 value1 < value2

value1 <= value2

Page 39: Java first Session

The Conditional Operators

The && and || operators perform Conditional-AND and Conditional-OR operations on two boolean expressions.

class ConditionalDemo1 { public static void main(String[] args){ int value1 = 1; int value2 = 2;

if((value1 == 1) && (value2 == 2)) System.out.println("value1 is 1 AND value2 is 2");

if((value1 == 1) || (value2 == 1)) System.out.println("value1 is 1 OR value2 is 1");

} }

Another conditional operator is ?. It can be thought of as shorthand for an if-then-else statement. Also known as the ternary operator because it uses three operands

to be read as follows: "If someCondition is true, assign the value of value1 to result. Otherwise,

assign the value of value2 to result."

e.g.

class ConditionalDemo2 {

public static void main(String[] args){ int value1 = 1; int value2 = 2; int result; boolean someCondition = true; result = someCondition ? value1 : value2; System.out.println(result); } }

Page 40: Java first Session

Operator Precedence

Operators with higher precedence are evaluated before operators with relatively lower precedence.

Operators on the same line have equal precedence. When operators of equal precedence appear in the same expression, a rule must govern which is evaluated

first.

See table below

Operator Precedence

Operators Precedence

postfix expr++ expr--

unary ++expr --expr +expr -expr ~ !

multiplicative * / %

additive + -

relational < > <= >= instanceof

equality == !=

logical AND &&

logical OR ||

ternary ? :

assignment = += -= *= /= ^=

Expressions, Statements, and Blocks

Semicolons end each statement in a method e.g.

aValue = 8933.234; // assignment statement aValue++; // increment statement

System.out.println("Hello World!"); // method invocation statement Bicycle myBike = new Bicycle(); // object creation statement

double aValue = 8933.234; //declaration statement

If a statement returns a value , it is called an expression e.g. when you add two

numbers together or test to see whether one value is equal to another

A statement is called a block if complex lines surrounded by parentheses e.g. loop,

array, if condition

N.B. x + y / 100 // ambiguous

x + (y / 100) // unambiguous, recommended

When writing compound expressions, be explicit and indicate with parentheses which operators should be evaluated first. This practice makes

code easier to read and to maintain.

Page 41: Java first Session

N.B. Bitwise Operators

There are variables that represent a 1 bit value only. These do not get assigned a

number or character (which consist of a byte=8 bits not an individual bit). This is used in ―systems programming‖ to represent ―on=1‖ and ―off=0‖.

Operators that deal with bits are less commonly used. For example:

"~"

This inverts a bit pattern; making every "0" a "1" and every "1" a "0". For example, a byte contains 8 bits "00000000" would change its pattern to "11111111".

“|” “&”

The single OR and AND operators work on bits in the following way:

bit 1 bit 2 OR (|) AND (&) XOR (^)

0 0 0 0 0

1 0 1 0 1

0 1 1 0 1

1 1 1 1 0

―|‖ Bitwise OR returns one in all cases except where the corresponding bits of both operands are zero. The resulting bit pattern is the "set" (1 or true) bits of any of the two

operands. This property can be used to "set" or "turn on" a "flag" (bit set to one) in the ―flags‖ variable regardless of whether that flag was set previously or not.

// To set or turn on a flag bit(s) flags = flags | MASK;

―&‖Bitwise AND sets a bit to 1 if and only if both of the corresponding bits in its operands

are 1, and to 0 if the bits differ or both are 0. In other words, a one ANDed with any bit

is that bit and a zero ANDed with any bit is zero. This operator can be used to check the state of a flag in e.g. ―flags‖ variable. When you AND the ―flags‖ variable with the

―MASK‖, all zeroes in the ―MASK‖ will return zero for the corresponding position in ―flags‖ and all ones in the ―MASK‖ will return whatever the corresponding bit is set to in the

―flags‖ variable. // To check the state of a flag bit(s)

if (flags & MASK) == MASK) { // flag is set or turned on

... }

else { //flag is not set or is turned off

N.B. we can’t say:

if (flags & 1) == 1) because 1 here is a character

not a bit

Page 42: Java first Session

...

}

―&‖ can also be used, RARELY, as a logical operator but this single ampersand always evaluates both arguments whereas the double ampersand ―&&‖ will only evaluate the second argument if the first argument is true – thus it’s faster.

Flag refers to one or more bits that are used to store a binary value or code that has an assigned meaning.

One common use of flags is to mark or designate data structures for future processing.

Within microprocessors and other logic devices, flags are commonly used to control or indicate the intermediate or final state or outcome of different operations. Microprocessors typically have, for example, a status register that is composed of such flags, and the flags are used to indicate various post-operation conditions, such as when there has been an arithmetic overflow.

Page 43: Java first Session

The Type Comparison Operator

The instanceof operator compares an object to a specified type. You can use it to test if an object is

an instance of a class, an instance of a subclass, or

an instance of a class that implements a particular interface.

class InstanceofDemo { public static void main(String[] args) { Parent obj1 = new Parent(); Parent obj2 = new Child();

System.out.println("obj1 instanceof Parent: " + (obj1 instanceof Parent)); System.out.println("obj1 instanceof Child: " + (obj1 instanceof Child)); System.out.println("obj1 instanceof MyInterface: " + (obj1 instanceof MyInterface)); System.out.println("obj2 instanceof Parent: " + (obj2 instanceof Parent)); System.out.println("obj2 instanceof Child: " + (obj2 instanceof Child));

System.out.println("obj2 instanceof MyInterface: " + (obj2 instanceof MyInterface)); } } class Parent{} class Child extends Parent implements MyInterface{} interface MyInterface{}

Answer: obj1 instanceof Parent: true

obj1 instanceof Child: false obj1 instanceof MyInterface: false

obj2 instanceof Parent: true obj2 instanceof Child: true

obj2 instanceof MyInterface: true

Page 44: Java first Session

Control Flow Statements

The statements inside source files are generally executed from top to bottom, in the order that they appear. Control flow statements break up the flow of execution by

enabling the program to conditionally execute particular blocks of code using:

decision-making statements (if-then, if-then-else, switch),

looping statements (for, while, do-while),

branching statements (break, continue, return)

IF-THEN-ELSE Statement

It executes a certain section of code only if a particular condition occurs.

E.g.

The Bicycle class could allow the brakes to decrease the bicycle's speed only if the

bicycle is already in motion. If this test evaluates to false (meaning that the

bicycle is not in motion), control jumps to the end of the if-then statement

void applyBrakes(){ if (isMoving) { // the "if" clause: bicycle must be moving currentSpeed--; // the "then" clause: decrease current speed } }

N.B. it is better to include the opening and closing braces for the ―then‖ clause

The if-then-else statement provides a secondary path of execution when an "if"

clause evaluates to false.

E.g.

void applyBrakes(){ if (isMoving) { currentSpeed--; } else { System.err.println("The bicycle has already stopped!");

} }

e.g. The following program, IfElseDemo, assigns a grade based on the value of a test score: an A for a score of 90% or above, a B for a score of 80% or above, and

so on:

Page 45: Java first Session

class IfElseDemo {

public static void main(String[] args) { int testscore = 76; char grade; if (testscore >= 90) { grade = 'A'; } else if (testscore >= 80) { grade = 'B'; } else if (testscore >= 70) { grade = 'C'; } else if (testscore >= 60) { grade = 'D'; } else { grade = 'F'; } System.out.println("Grade = " + grade); } } Answer:

Grade = C

N.B.

The value of testscore can satisfy more than one expression in the compound statement: 76 >= 70 and 76 >= 60. However, once a condition is satisfied, the

appropriate statements are executed (grade = 'C';) and the remaining conditions are not evaluated.

If we don’t use ―else if‖ and only ―if‖ , the program will run all feasible conditions

Page 46: Java first Session

Is the character a digit ?

It is possible to test a character to see if it is a digit by checking if it is within a range of characters within the character set. For example, in JavaScript you can test to see if a

character is a digit this way:

if (chr >= "0" && chr <= "9")…… alert("It is a digit!")

class IfInteger { static int x=5; static String y="not number"; public static void main(String[] args)

{ IfInteger newOne= new IfInteger(); if(x>=0 && x<=9) { System.out.println(x); } else { System.out.println(y); }

} }

The SWITCH Statement

This is similar in function to the IF-THEN.

An if-then-else statement can be used to make decisions based on ranges of values or conditions, whereas a switch statement can make decisions based only on a single

integer or enumerated value

e.g. The following program, SwitchDemo, declares an int named month whose value represents a month out of the year. The program displays the name of the month, based on the value of month, using the switch statement.

Page 47: Java first Session

class SwitchDemo {

public static void main(String[] args) { int month = 8; switch (month) { case 1: System.out.println("January"); break; case 2: System.out.println("February"); break; case 3: System.out.println("March"); break; case 4: System.out.println("April"); break; case 5: System.out.println("May"); break; case 6: System.out.println("June"); break; case 7: System.out.println("July"); break; case 8: System.out.println("August"); break; case 9: System.out.println("September"); break; case 10: System.out.println("October"); break; case 11: System.out.println("November"); break; case 12: System.out.println("December"); break; default: System.out.println("Invalid month.");break; } } }

Answer:

August

N.B. Each break statement terminates the enclosing switch statement. Control flow

continues with the first statement following the switch block. The break statements are necessary because without an explicit break, control will flow sequentially through

subsequent case statements.

The same function could also be implemented with if-then-else statements:

int month = 8;

if (month == 1) { System.out.println("January");

} else if (month == 2) { System.out.println("February");

} . . . // and so on

Page 48: Java first Session

class SwitchDemo2 { public static void main(String[] args) {

int month = 2; int year = 2000; int numDays = 0; switch (month) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: numDays = 31; break; case 4: case 6: case 9: case 11: numDays = 30; break; case 2: if ( ((year % 4 == 0) && !(year % 100 == 0)) || (year % 400 == 0) ) numDays = 29; else numDays = 28; break; default: System.out.println("Invalid month.");

break; } System.out.println("Number of Days = " + numDays); } }

Answer:

Number of Days = 29

Page 49: Java first Session

The WHILE and DO-WHILE Statements The while statement continually executes a block of statements while a particular

condition is true. Its syntax can be expressed as:

while (expression) { statement(s)

} The while statement evaluates expression, which must return a boolean value. If

the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and

executing its block until the expression evaluates to false. e.g.

class WhileDemo

{ public static void main(String[] args) { int count = 1; while (count < 11) { System.out.println("Count is: " + count); count++; } }

}

The difference between do-while and while is that do-while evaluates its

expression at the bottom of the loop instead of the top. Therefore, the statements within the do block are always executed at least once:

do {

statement(s) } while (expression);

e.g.

class DoWhileDemo

{ public static void main(String[] args) { int count = 1; do { System.out.println("Count is: " + count); count++; } while (count < 11); }

}

Page 50: Java first Session

The FOR Statement

The FOR statement is called "for loop" because it repeatedly loops until

a particular condition is satisfied. The general form of the FOR statement is as follows:

for (initialization; termination; increment) {

statement(s) }

The initialization expression initializes the loop; it's executed once, as the loop begins.

When the termination expression evaluates to false, the loop terminates.

The increment expression is invoked after each iteration through the loop; it is

perfectly acceptable for this expression to increment or decrement a value. GO BACK TO “class ArrayCopyDemo” EXERCISE

e.g.

class ForDemo { public static void main(String[] args) { for(int i=1; i<6; i++) { System.out.println("Count is: " + i); } } } Answer: Count is: 1

Count is: 2 Count is: 3

Count is: 4 Count is: 5

the code declares a local variable within the initialization expression. The scope of this variable extends from its declaration to the end of the block governed by the

for statement, so it can be used in the termination and increment expressions as well

The names i, j, and k are often used to control for loops; declaring them within the initialization expression limits their life span and reduces errors

The FOR statement has another form designed for iteration through arrays referred to as the enhanced FOR statement, and makes loops more compact.

e.g. the following array, holds the numbers 1 through 10:

int[] numbers = {1,2,3,4,5,6,7,8,9,10};

Page 51: Java first Session

The following program, EnhancedForDemo, uses the enhanced for to loop through the

array:

class EnhancedForDemo { public static void main(String[] args) { int[] numbers = {1,2,3,4,5,6,7,8,9,10}; for (int item=0; item<numbers.length; item++) System.out.println("Item in array is: " + numbers[item]); } }

In this example, the variable item holds the current value from the numbers array. The output from this program is the same as before:

Count is: 1 Count is: 2

Count is: 3 Count is: 4

Count is: 5 Count is: 6

Count is: 7 Count is: 8

Count is: 9 Count is: 10

This form of the for statement is recommended instead of the general form whenever possible – this way the number of iterations is dynamic.

The BREAK Statement

The break statement has two forms: labeled and unlabeled.

An unlabeled break can be used to terminate a switch, for, while, or do-while

loop. We don’t need to break an “IF” statement because it already contains

choices

e.g. This program searches for the number 12 in an array. The break statement, shown in boldface, terminates the for loop when that value is found. Control flow then transfers

to the print statement at the end of the program.

Page 52: Java first Session

class BreakDemo {

public static void main(String[] args) { int[] arrayOfInts = { 32, 87, 3, 589, 12, 1076, 8, 622, 127 }; int searchfor = 12; int i; boolean foundIt = false;

for (i = 0; i < arrayOfInts.length; i++)

{ if (arrayOfInts[i] == searchfor) { foundIt = true; break; } }

if (foundIt)

{ System.out.println("Found " + searchfor + " at index " + i);

} else { System.out.println(searchfor + " not in the array"); } } }

Answer: Found 12 at index 4

a labeled break terminates an outer statement.

e.g. The following program, BreakWithLabelDemo, is similar to the previous program,

but uses nested for loops to search for a value in a two-dimensional array. When the value is found, a labeled break terminates the outer for loop (labeled "search"):

Page 53: Java first Session

DRAW ALGORITHM:

class BreakWithLabelDemo { public static void main(String[] args) { int[][] arrayOfInts = { { 32, 87, 3, 589 }, { 12, 1076, 2000, 8 } }; int searchfor = 12; int i; int j = 0; boolean foundIt = false;

search: for (i = 0; i < arrayOfInts.length; i++) { for (j = 0; j < arrayOfInts[i].length; j++) { if (arrayOfInts[i][j] == searchfor) { foundIt = true; break search;

} } } if (foundIt) { System.out.println("Found " + searchfor + " at " + i + ", " + j); } else { System.out.println(searchfor + " not in the array");

} } }

Answer:

Found 12 at 1, 0

N.B. It stores values of ―i‖ and ―j‖ just before the break. They are seen by the fnal ―if‖

statement because they were declared outside the ―search‖ block.

Page 54: Java first Session

The CONTINUE Statement

The continue statement skips the current iteration of a for, while , or do-while loop.

The unlabeled continue skips to the end of the innermost loop's body and evaluates the boolean expression that controls the loop.

e.g. The following program, ContinueDemo , steps through a String, counting the occurences of the letter "p". If the current character is not a p, the continue statement

skips the rest of the loop and proceeds to the next character. If it is a "p", the program increments the letter count.

class ContinueDemo { public static void main(String[] args) {

String searchMe = "peter piper picked a peck of pickled peppers"; int max = searchMe.length(); int numPs = 0; for (int i = 0; i < max; i++) { //interested only in p's if (searchMe.charAt(i) != 'p') continue;

//process p's numPs++; } System.out.println("Found " + numPs + " p's in the string."); } } On removing the continue statement and recompiling, the count will be wrong,

saying that it found 35 p's instead of 9

Answer: Found 9 p's in the string

A labeled continue statement skips the current iteration of an outer loop marked

with the given label

e.g. The following program, ContinueWithLabelDemo, uses nested loops to search for a

substring within another string. Two nested loops are required: one to iterate over the substring and one to iterate over the string being searched. The following program,

ContinueWithLabelDemo, uses the labeled form of continue to skip an iteration in the outer loop.

Page 55: Java first Session

public static void main(String[] args) {

String searchMe = "Look for a substring in me"; String substring = "sub"; boolean foundIt = false; int max = searchMe.length() - substring.length(); test: for (int i = 0; i <= max; i++) { int n = substring.length(); int k = 0; while (n-- != 0) {

if (searchMe.charAt(i)!= substring.charAt(k)) { continue test; } i++; k++; } foundIt = true; break test; } System.out.println(foundIt ? "Found it":"Didn't find it"); } } Answer:

Found it

The RETURN Statement The return statement exits from the current method, and control flow returns to where the method was invoked. The return statement has two forms: one that returns a value,

and one that doesn't. To return a value, simply put the value (or an expression that calculates the value) after the return keyword.

return ++count;

Page 56: Java first Session

The data type of the returned value must match the type of the method's declared return

value. When a method is declared void, use the form of return that doesn't return a value.

return;

Page 57: Java first Session

Java Programming Language Session 5

Ex.: Arrange a set of numbers in order

Return Statement

class ReturnClass {

static boolean t = true;

public static void main(String args[]) {

method1(); int z= method2(10,20);

System.out.println(z);

}

static void method1() {

System.out.println("void return."); if(t) return; // return to caller

System.out.println("This won't execute."); }

static int method2(int x, int y)

{ return (x+y); // return to caller

} }

Advanced FOR loop

public class Main

{ public static void main(String[] args)

{ int[] numbers = {1,2,3,4,5,6,7,8,9,10};

/*for each "int" object in "numbers".Here the variable ―i‖ is used to point to the current instance of Employee in the collection. Because of the "for each" wording, the

enhanced-for construct is also referred to as the for-each construct.*/

for (int i : numbers)

{

Page 58: Java first Session

System.out.println("The item is: " + item); }

}}

Vectors import java.util.*;

public class VectorDemo{ public static void main(String[] args){

Vector<Object> vector = new Vector<Object>();

int int1 = 10;

Integer int2 = new Integer(20); String str = "more numbers";

vector.addElement(int1); vector.add(int2);

vector.add(str);

vector.add(2, new Integer(30)); // addElement cannot be used to put object in specific place in vector

System.out.println("the elements of vector: " + vector);

System.out.println("The size of vector are: " + vector.size()); System.out.println("The elements at position 2 is: " +

vector.elementAt(2)); System.out.println("The first element of vector is: " +

vector.firstElement()); System.out.println("The last element of vector is: " +

vector.lastElement()); vector.removeElementAt(2);

}

}

A class hierarchy

Each class has a superclass (above it in the hierarchy), and each class can have one

or more subclass (below it in the hierarchy)

Subclasses inherit all the methods and variables from their superclasses further

up in the hierarchy - subclassing

Each class farther down in the hierarchy adds more information and is more

tailored to a specific purpose

Page 59: Java first Session

At the top of the Java class hierarchy is the class Object; all classes inherit from

this one superclass.

Using subclassing, you only need to define the differences between your class

and its parent

Creating a Class Hierarchy

factor out information common to multiple classes in superclasses, and then

reuse that superclass's information over and over in subclasses e.g.

Single and Multiple Inheritance

Single inheritance means that each Java class can have only one superclass

In C++, classes can have more than one superclass, and they inherit combined

variables and methods from all those classes. This is called multiple inheritance.

Interface

An interface is a collection of method names, without actual definitions

Although a Java class can have only one superclass (due to single inheritance),

that class can also implement any number of interfaces.

By implementing an interface, a class provides method implementations

(definitions) for the method names defined by the interface

Vehicle

Engine powered vehicle

Two wheeled

Motorcycle Scooter

Four wheeled

Car Truck

Person powered vehicle

Bicycle

Page 60: Java first Session

If two different classes implement the same interface, they can both respond to

the same method calls (as defined by that interface), although what each class

actually does in response to those method calls may be very different.

Packages & Importing

Packages in Java are a way of grouping together related classes and interfaces

The class libraries in the Java Developer's Kit are contained in a package called

java

The classes in the java package are guaranteed to be available in any Java

implementation

The java package itself contains other packages for classes that define

o the language itself,

o the input and output classes,

o some basic networking,

o and the window toolkit functions.

By default, Java classes have access to only the classes in java.lang (the base

language package inside the java package). To use classes from any other

package,

o refer to them explicitly by package name e.g.

“ public class HelloAgainApplet extends java.applet.Applet {} “

o import them in source file e.g.

“ import java.awt.Graphics; “

E.g., the Color class, which is contained in the awt package (Abstract Windowing

Toolkit). The awt package is inside the java package: java.awt.Color.

class packages that are part of the Java class library:

java.lang: Classes that apply to the language itself, which includes the Object

class, the String class, and the System class. It also contains the special classes for the primitive types (Integer, Character, Float, and so on).

java.util: Utility classes, such as Date, as well as simple collection classes, such as Vector and Hashtable.

N.B. a general subsequent level of classes can be imported by “*”, but not classes inside a subsequent level of packages e.g.

java.util.* OR java.util.Vector - imports the Vector class

java.util.regex.* OR java.util.regex.Matcher - imports Matcher class

java.io: Input and output classes for writing to and reading from streams (such

as standard input and output) and for handling files.

java.net: Classes for networking support, including Socket and URL (a class to

represent references to documents on the World Wide Web).

Page 61: Java first Session

java.awt: (the Abstract Window Toolkit): Classes to implement a graphical user interface, including classes for Window, Menu, Button, Font, CheckBox, and so

on. This package also includes classes for processing images (in the java.awt.Image package).

java.applet: Classes to implement Java applets, including the Applet class itself,

as well as the AudioClip interface

Defining Classes

to define a normal class

class MyClassName { ...

}

to define subclass of another class, use extends to indicate the superclass

of this class: class MyClassName extends MySuperClassName {

...}

to implement a specific interface, use implements to refer to that interface:

class MyRunnableClassName implements Runnable { ...

}

Casting and Converting Objects and Primitive Types

You may have a value stored somewhere that is the wrong type or you want to

change it for a reason.

Casting is a mechanism of converting the type of an object or primitive

type into another type.

The result of a cast is a new reference or value

casting does not affect the original object or value

There are three forms of casts:

1. Casting between primitive types: int to float

2. Casting between object types: an instance of a class to an instance of another

class

3. Converting primitive types to objects and then extracting primitive values back

out of those objects

Casting Primitive Types

Page 62: Java first Session

Casting between primitive types most commonly occurs with the numeric types;

boolean values cannot be cast to any other primitive type.

if the type you are casting to is "larger" than the type of the value you're

converting e.g. int to long, you may not have to use an explicit cast - no loss of

information occurs (e.g. You can treat a byte or a character as an int, anything

as a double etc.)

To convert a large value to smaller type, you must use an explicit cast, because

converting that value may result in a loss of precision :

(typename) value

typename is the name of the type you're converting to (short, int,

float)

value is an expression that results in the value you want to convert

e.g. int a= (int) (x / y);

e.g. char c = (char)numericValue;

Casting Objects

Instances of classes can also be cast to instances of other classes, with one restriction:

the class of the object you're casting and the class you're casting it to must be related

by inheritance; that is, you can cast an object only to an instance of its class's sub- or

superclass—not to any random class.

(classname) object e.g.

GreenApple a= new GreenApple();

Apple a2;

a2 = (Apple) a;

N.B. Casting an object to an instance of one of that object's superclasses loses the

information the original subclass provided

N.B. In addition to casting objects to classes, you can also cast objects to interfaces—

but only if that object's class or one of its superclasses actually implements that

interface. Casting an object to an interface then enables you to call one of that

interface's methods even if that object's class does not directly implement that

interface.

Changing to and from STRING

int to string: int num = 1; String aString = Integer.toString(num);

String to int: String s = "78"; int aInt = Integer.parseInt(s);

double to string: double num = 1; String aString = Double.toString(num);

Page 63: Java first Session

String to double: String s = "78"; double db = Double.parseDouble(s);

Float to string: float num = 1; String aString = Float.toString(num);

String to float: string s= “1” float f = Float.valueOf(s).floatValue();

Char to String: char c = “a” String.valueOf(c);

String to char: String s= “hi” char c = s.charAt(0);

Constants

A constant variable or constant is a variable whose value never changes (Constants

are useful for defining shared values for all the methods of an object)

To declare a constant:

use the final keyword before the variable declaration

include an initial value for that variable:

e.g. final float pi = 3.141592;

Class Variables (Static Fields): A class variable is any field declared with the static

modifier; this tells the compiler that there is exactly one copy of this variable in

existence; regardless of how many times the class has been instantiated. Additionally,

the keyword final could be added to indicate that it will never change.

e.g. static final int maxObjects = 10;

The THIS Keyword

THIS refers to the current object. It can be used in dot notation to refer to the object's

instance variables, as an argument to a method, as the return value for the current

method etc.

e.g. t = this.x // the x instance variable for this object

this.myMethod(this) // call the mymethod method, defined in

// this class, and pass to it the current object

return this; // return the current object

Although sometimes it can be omitted depending on whether there are no variables

with the same name declared in the local method

e.g.

t = x // the x instance variable for this object myMethod(this) // call the myMethod method, defined in this class

class Student

Page 64: Java first Session

{ String stName;

int stAge; String stAddress;

Method1(String stName, int stAge, String stAddress) {

this.stName = stName; this.stAge = stAge;

this.stAddress = stAddress; }

}

Variable Scope

On referring to a variable within your method definitions, Java checks for its definition:

first in the current block

then in the current method definition (local variable)

then as an instance or class variable in the current class

finally, in each superclass

e.g.

class ScopeTest {

int test = 10; void printTest () {

int test = 20; System.out.println("test = " + test);

} }

Because the local variable hides the instance variable, the println() method will print that test is 20

You can get around this particular problem by using “this.test” to refer to the

instance variable, and just “test” to refer to the local variable

Calling Methods

The object whose method you're calling is on the left side of the dot; the name of

the method and its arguments is on the right side of the dot:

e.g. calling some methods defined in the String class

str.length() / str.charAt(5)

Method Definition

Method definitions have four basic parts:

The name of the method

The type of object or primitive type the method returns

Page 65: Java first Session

A list of parameters

The body of the method

Method signature is a combination of

the name of the method,

the type of object or base type this method returns, and

a list of parameters.

returntype methodname(type1 arg1, type2 arg2, type3 arg3..) {...}

returntype is the type of the of the value this method returns. It can be:

one of the primitive types,

a class name, or

void if the method does not return a value at all.

if this method returns an array object, the array brackets can go either after the return type or after the parameter list

int[] makeRange(int lower, int upper) {...}

If the method has a return type (not declared to return void), somewhere inside

the body of the method you need to return a value. Use the return keyword to do this

Parameter list is a set of variable declarations, separated by commas, inside

parentheses. These parameters become local variables in the body of the method, whose values are the objects or values of primitives passed in when the method is

called

e.g.

class RangeClass { int[] makeRange(int lower, int upper) { int arr[] = new int[ (upper - lower) + 1 ]; // works for any 2 values not just 1 and 10 for (int i = 0; i < arr.length; i++) {

arr[i] = lower++; } return arr; } public static void main(String arg[]) { int theArray[]; RangeClass theRange = new RangeClass();

Page 66: Java first Session

theArray = theRange.makeRange(1, 10); /*it can work without creating the object and just writing name of method, but this is good practice if in different class*/ System.out.print("The array: [ "); for (int i = 0; i < theArray.length; i++) { System.out.print(theArray[i] + " "); } System.out.println("]"); }

}

Answer:

The array: [ 1 2 3 4 5 6 7 8 9 10 ]

The main() method in this class tests the makeRange() method by creating a range

where the lower and upper boundaries of the range are 1 and 10, and then uses a for

loop to print the values of the new array.

Passing Arguments & Arrays to Methods

When you call a method with object parameters, the variables you pass into the body

of the method are passed by reference, which means that whatever you do to those

objects inside the method affects the original objects as well. This includes arrays and

all the objects that arrays contain; when you pass an array into a method and modify

its contents, the original array is affected and changed.

e.g.

The following class includes a method called OneToZero() which does two things:

It counts the number of ones in the array and returns that value. If it finds a one, it substitutes a zero in its place in the array.

the main() method for the PassByReference class tests the onetoZero() method

class PassByReference { public static void main (String arg[]) { int arr[] = { 1, 3, 4, 5, 1, 1, 7 }; PassByReference test = new PassByReference(); System.out.print("Values of the array: [ "); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); }

Page 67: Java first Session

System.out.println("]"); int numOnes = test.onetoZero(arr); System.out.println("Number of Ones = " + numOnes); System.out.print("New values of the array: [ "); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } System.out.println("]"); } int onetoZero(int arg[]) { int count = 0; for (int i = 0; i < arg.length; i++) { if (arg[i] == 1) { count++; arg[i] = 0; } } return count; }

}

Answer:

Values of the array: [ 1 3 4 5 1 1 7 ]

Number of Ones = 3 New values of the array: [ 0 3 4 5 0 0 7 ]

Class Methods

Like class and instance variables, there are class and instance methods

Class methods are available to any instance of the class itself and can be made

available to other classes – these are general utility methods and do not directly

affect an instance of that class

e.g. the Java class libraries include a class called Math containing mathematical

methods:

float root = Math.sqrt(453.0);

System.out.print("The larger of x and y is " + Math.max(x, y));

Page 68: Java first Session

To define class methods, use the “static” keyword in front of the method

definition, just as you would create a class variable. e.g. static int max(int arg1, int arg2) { ... }

Some class methods convert to and from primitive types.

e.g. the “parseInt()” class method in the Integer class takes a string and returns

the value of that string as an integer

int count = Integer.parseInt(x);

e.g. an example to input 2 numbers from the user as strings, then convert them to

numbers, add them and output the result

import javax.swing.JOptionPane;

public class InputNumbers {

public static void main(String[] args) { String x=JOptionPane.showInputDialog(null,"Please enter a

number?","Adding Numbers", JOptionPane.QUESTION_MESSAGE);

String y=JOptionPane.showInputDialog(null,"Please enter another number?","Adding Numbers",

JOptionPane.QUESTION_MESSAGE);

int numberx = Integer.parseInt(x); int numbery = Integer.parseInt(y);

int answer= numberx+numbery;

JOptionPane.showMessageDialog(null, "The total is "+answer, "Answer", JOptionPane.INFORMATION_MESSAGE);

} }

Page 69: Java first Session

Overloading Methods

This is, creating methods with different signatures and definitions but with the same

name.

When you call a method in an object, Java matches up the method name and

the number and type of arguments to choose which method definition to

execute

To do it create several different method definitions in your class, all with the

same name, but with

Different parameter lists (either in number or type of arguments)

NOT different return types of the methods or names of parameters

e.g.

import java.awt.Point;

class MyRect {

int x1 = 0; int y1 = 0;

int x2 = 0; int y2 = 0;

Page 70: Java first Session

MyRect buildRect(int x1, int y1, int x2, int y2)

{ this.x1 = x1;

this.y1 = y1;

this.x2 = x2; this.y2 = y2;

return this; }

MyRect buildRect(Point topLeft, Point bottomRight)

{ x1 = topLeft.x;

y1 = topLeft.y; x2 = bottomRight.x;

y2 = bottomRight.y; return this;

}

MyRect buildRect(Point topLeft, int w, int h) {

x1 = topLeft.x; y1 = topLeft.y;

x2 = (x1 + w); y2 = (y1 + h);

return this; }

void printRect(){

System.out.print("MyRect: <" + x1 + ", " + y1); System.out.println(", " + x2 + ", " + y2 + ">");

} public static void main(String args[]) {

MyRect rect = new MyRect(); System.out.println("Calling buildRect with coordinates 25,25 50,50:");

rect.buildRect(25, 25, 50, 50);

rect.printRect(); System.out.println("—————");

System.out.println("Calling buildRect w/points (10,10), (20,20):"); rect.buildRect(new Point(10,10), new Point(20,20));

rect.printRect(); System.out.println("—————");

System.out.print("Calling buildRect w/1 point (10,10),"); System.out.println(" width (50) and height (50)");

rect.buildRect(new Point(10,10), 50, 50); rect.printRect();

System.out.println("—————"); }

Page 71: Java first Session

}

Answer: Calling buildRect with coordinates 25,25 50,50:

MyRect: <25, 25, 50, 50>

————— Calling buildRect w/points (10,10), (20,20):

MyRect: <10, 10, 20, 20> —————

Calling buildRect w/1 point (10,10), width (50) and height (50) MyRect: <10, 10, 60, 60>

All the buildRect() methods work based on the arguments with which they are called

Page 72: Java first Session

Java Programming Language Session 6

Revision: Class Declaration

class MyClass {

//field, constructor, and method declarations

}

class declarations include these components in order:

1. Modifiers e.g. public, private (explained later) 2. Class name, with the initial letter capitalized by convention.

3. The name of the class's parent -superclass, preceded by the keyword extends. (A class can inherit only one superclass)

4. A comma-separated list of interfaces implemented by the class, preceded by the keyword implements. (A class can implement more than one interface)

5. The class body, surrounded by braces, {} containing: declarations for the fields that provide the state of the class and its objects,

constructors for initializing new objects, methods to implement the behavior of the class and its objects

Access Modifiers (Controlling Access to Members of a Class)

Access modifiers determine whether other classes can use a particular field or invoke a

particular method:

Public: A class declared with the modifier public, is visible to all classes everywhere

inside and outside its package. The public field or method is accessible from all

classes.

No modifier (package private): If a class has no modifier (the default, also

known as package-private), is visible only within its own package

Private: specifies that the member (field / method ) can only be accessed in its

own class. A standard design strategy is to make all fields private and provide public getter

methods for them.

N.B. a class can only use public or package private (no modifier). Private cannot be

used for classes and Interfaces. It also cannot be used for fields and methods within an

interface.

Protected: specifies that the member can only be accessed within its own package

(as with package-private) and, in addition, by a subclass of its class in another

package

Page 73: Java first Session

Access Levels

Modifier

Class(access

to its

members)

Package(classes in the same

package as the class have

access to the member)

Subclass (of the class —

declared outside this package

— have access to the member)

World (all classes

have access to the

member)

public Y Y Y Y

protected Y Y Y N

no modifier Y Y N N

private Y N N N

Private

protected Y N Y N

Tips:

Unless an instance variable is constant, it should be private.

FINAL

When the final modifier is applied to a class, it means that the class cannot be subclassed.

When it is applied to a variable, it means that the variable is constant.

When it is applied to a method, it means that the method cannot be overridden by

subclasses.

N.B. private methods are effectively final, as are all methods declared in a final

class. Marking these latter methods final is legal, but redundant; the compiler already treats them as final.

Constructor Methods

A constructor method is a special kind of method that determines how an object is

initialized when it's created.

Basic Constructors

Constructors look a lot like regular methods, with two basic differences:

Constructors always have the same name as the class.

Constructors don't have a return type.

Why need it?

To use the methods of a class you must create(instantiate) an object/instance of that class first in the main method, then use this object‘s methods e.g. car.getname()

Page 74: Java first Session

All classes have at least one constructor.

If a class does not declare any, the Java compiler automatically provides a no-

argument constructor, called the default constructor. This default constructor calls the class parent's no-argument constructor, or the Object class constructor if the

class has no other parent.

If the parent has no constructor (Object does have one), the compiler will reject the

program.

when you use ―new‖ to create a new instance of a class, Java does three things:

Allocates memory for the object

Calls the class's constructor method

Initializes that object's instance variables, either to their initial values or to a default

(0 for numbers, null for objects, false for booleans, '\0' for characters)

e.g. public Bicycle() { gear = 1;

cadence = 10; speed = 0;

}

Bicycle yourBike = new Bicycle();

‗New‘ invokes the no-argument constructor to create a new Bicycle object called yourBike.

e.g. public Bicycle(int startCadence, int startSpeed, int startGear) {

gear = startGear; cadence = startCadence;

speed = startSpeed; }

Bicycle myBike = new Bicycle(30, 0, 8);

To create a new Bicycle object called myBike, a constructor is called by the new operator.

If the constructor was not there , it sets the variable to „0‟ ,null and false

e.g. a class called Person, with a constructor that initializes its instance variables based

on the arguments to new. The class also includes a method for the object to introduce

itself, and a main() method to test each of these things

class Person {

String name; int age;

Person(String n, int a) { // constructor method name = n;

age = a; }

Page 75: Java first Session

void printPerson() { System.out.print("Hi, my name is " + name);

System.out.println(". I am " + age + " years old."); }

public static void main (String args[]) { Person p = new Person("Laura", 20);

p.printPerson(); System.out.println("————");

p = new Person("Tommy", 3); p.printPerson();

System.out.println("————"); }

} Answer

Hi, my name is Laura. I am 20 years old. ————

Hi, my name is Tommy. I am 3 years old.

If the constructor was not there it would give the following

Hi, my name is null. I am 0 years old. ————

Hi, my name is null. I am 0 years old.

If the constructor was not there then we would have more coding lines to add to give the correct results:

class PersonAdjusted {

String name; int age;

void printPerson() {

System.out.print("Hi, my name is " + name); System.out.println(". I am " + age + " years old.");

}

public static void main (String args[]) { //PersonAdjusted p = new PersonAdjusted("Laura", 20);

PersonAdjusted p = new PersonAdjusted();

p.name="Laura"; p.age=20;

p.printPerson(); System.out.println("————");

//p = new PersonAdjusted("Tommy", 3); p.name="Tommy";

p.age=3; p.printPerson();

System.out.println("————"); }

}

Page 76: Java first Session

STATIC

Using the ―static‖ keyword, the variables and methods become class

variables and methods so we don‘t need to call them by object name e.g.

‗name‘ instead of ‗p.name‘.

Class Example

public class Bicycle {

// the Bicycle class has three fields

public int cadence;

public int gear; public int speed;

// the Bicycle class has one constructor

public Bicycle(int startCadence, int startSpeed, int startGear) { gear = startGear;

cadence = startCadence;

speed = startSpeed; }

// the Bicycle class has four methods public void setCadence(int newValue) {

cadence = newValue; }

public void setGear(int newValue) {

gear = newValue; }

public void applyBrake(int decrement) { speed -= decrement;

} public void speedUp(int increment) {

speed += increment;

} }

Subclass Example

public class MountainBike extends Bicycle {

// the MountainBike subclass has one field public int seatHeight;

// the MountainBike subclass has one constructor

public MountainBike(int startHeight, int startCadence, int startSpeed, int startGear) {

super(startCadence, startSpeed, startGear); seatHeight = startHeight;

}

// the MountainBike subclass has one method public void setHeight(int newValue) {

seatHeight = newValue; }}

Page 77: Java first Session

Constructor Overloading

Like methods, constructors can also take varying numbers and types of parameters,

enabling you to create your object with exactly the properties you want it to have, or for

it to be able to calculate properties from different kinds of input, thus “overloading the

constructor”

e.g. a class , MyRect2, that has all the same functionality of the original class MyRect,

except with overloaded constructor methods instead of the buildRect() method

import java.awt.Point; class MyRect2 {

int x1 = 0; int y1 = 0;

int x2 = 0; int y2 = 0;

MyRect2(int x1, int y1, int x2, int y2) { this.x1 = x1;

this.y1 = y1; this.x2 = x2;

this.y2 = y2; }

MyRect2(Point topLeft, Point

bottomRight) { x1 = topLeft.x;

y1 = topLeft.y; x2 = bottomRight.x;

y2 = bottomRight.y; }

MyRect2(Point topLeft, int w, int h)

{

x1 = topLeft.x; y1 = topLeft.y;

x2 = (x1 + w); y2 = (y1 + h);

}

void printRect() { System.out.print("MyRect: <" + x1 + ", " + y1);

System.out.println(", " + x2 + ", " + y2 + ">"); }

Page 78: Java first Session

public static void main(String args[]) {

System.out.println("Calling MyRect2 with coordinates 25,25 50,50:"); MyRect2 rect = new MyRect2(25, 25, 50,50);

rect.printRect();

System.out.println("—————"); System.out.println("Calling MyRect2 w/points (10,10), (20,20):");

rect= new MyRect2(new Point(10,10), new Point(20,20)); rect.printRect();

System.out.println("—————"); System.out.print("Calling MyRect2 w/1 point (10,10),");

System.out.println(" width (50) and height (50)"); rect = new MyRect2(new Point(10,10), 50, 50);

rect.printRect(); System.out.println("—————");

} }

Same answer as before:

Calling MyRect2 with coordinates

25,25 50,50:

MyRect: <25, 25, 50, 50> —————

Calling MyRect2 w/points (10,10), (20,20):

MyRect: <10, 10, 20, 20> —————

Calling MyRect2 w/1 point (10,10), width (50) and height (50)

MyRect: <10, 10, 60, 60>

Passing Information to a Method or a Constructor

Notice that the return type of the following example is double even though one of the

parameters is an int. If the data types were different , it would be better to use a constructor

public double computePayment(double loanAmt,

double rate, double futureValue,

int numPeriods) { double interest = rate / 100.0;

double partial1 = Math.pow((1 + interest), -numPeriods); double denominator = (1 - partial1) / interest;

double answer = (-loanAmt / denominator) - ((futureValue * partial1) / denominator);

return answer; }

Page 79: Java first Session

Returning a Value from a Method

A method returns to the code that invoked it when it :

completes all the statements in the method,

reaches a ―return statement‖ (if the method has a return type), or

throws an exception (explained later),

whichever occurs first.

You can‘t return a value from a method that is declared void, you will get a

compiler error.

Any method not declared void must contain a return statement with a

corresponding return value, like this: return returnValue;

The data type of the return value must match the method's declared return type;

you can't return an integer value from a method declared to return a boolean.

e.g. return integer:

public int getArea() { return width * height;

}

e.g. return a reference type:

public Bicycle seeWhosFastest(Bicycle myBike, Bicycle yourBike, Environment

env) { Bicycle fastest;

// code to calculate which bike is faster return fastest;

}

Overriding Methods

There may be times when you want an object to respond to the same methods but have

different behavior when that method is called. Overriding a method involves defining a

method in a subclass that has the same signature as a method in a superclass. When that

method is called, the method in the subclass is found and executed instead of the one in

the superclass.

Creating Overriding methods

Create a method in your subclass that has the same signature (name, return type, and

parameter list) as a method defined by one of your class's superclasses, but change the

body arguments

e.g. (2 different classes in 2 different java files)

Page 80: Java first Session

class PrintClass { int x = 0;

int y = 1; void printMe() {

System.out.println("X is " + x + ", Y is " + y);

System.out.println("I am an instance of the class " + this.getClass().getName());

} }

class PrintSubClass extends PrintClass {

int z = 3; public static void main(String args[]) {

PrintSubClass obj = new PrintSubClass(); obj.printMe();

} }

Answer:

X is 0, Y is 1 I am an instance of the class PrintSubClass

In the main() method of PrintSubClass, a PrintSubClass object is created and the

printMe() method is called. Note that PrintSubClass doesn't define this method, so Java looks for it in each of PrintSubClass's superclasses—and finds it, in this case, in PrintClass.

Unfortunately, because printMe() is still defined in PrintClass, it doesn't print the z

instance variable.

A third class PrintSubClass2 is nearly identical to PrintSubClass, but you override the

printMe() method to include the z variable

class PrintSubClass2 extends PrintClass {

int z = 3; void printMe() {

System.out.println("x is " + x + ", y is " + y + ", z is " + z);

System.out.println("I am an instance of the class " + this.getClass().getName());

} public static void main(String args[]) {

PrintSubClass2 obj = new PrintSubClass2(); obj.printMe();

} }

Now, when you instantiate this class and call the printMe() method, the version of

printMe() you defined for this class is called instead of the one in the superclass PrintClass :

Page 81: Java first Session

Answer:

x is 0, y is 1, z is 3

I am an instance of the class PrintSubClass2

Calling the Original Method

Usually, there are two reasons why you want to override a method that a superclass has

already implemented:

To replace the definition of that original method completely (hide it) – done above

To augment the original method with additional behavior - This is particularly useful

where you end up duplicating behavior in both the original method and the method

that overrides it; by being able to call the original method in the body of the overridden method, you can add only what you need – using the word

“super”

e.g. continuing the last example:

Rather than duplicating most of the behavior of the superclass's method in the subclass,

you can rearrange the superclass's method (PrintClass) so that additional behavior can

easily be added:

// from PrintClass void printMe() {

System.out.println("I am an instance of the class" +

this.getClass().getName()); System.out.println("X is " + x);

System.out.println("Y is " + y); }

Then, in the subclass, when you override printMe, you can merely call the original method and then add the extra commands:

// From PrintSubClass2

void printMe() { super.printMe();

System.out.println("Z is " + z); }

Answer:

I am an instance of the class PrintSubClass2

X is 0 Y is 1

Z is 3

Page 82: Java first Session

N.B. about Superclasses and Subclasses

A subclass automatically inherits all methods and variables defined in its superclass.

We only use the command ―super‖ :

To instantiate the constructor of the superclass from the subclass e.g.1 p5

or

To call a method from the superclass instead of the compiler by hierarchy

default calling the one in the subclass e.g.2 p10

Difference between “==” and “.equals”

operator is the equality operator

equals() is for content comparison

**operator checks if both object references refer to the same memory location

eg: if (a==b) means it verifies whether both a and b refer to the same location in

memory.

**equals() if for content comparison.

eg:String a chandra ; String b chandra ;

if ( a.equals(b)) returns true because both contain the same content.

1) If you want to compare two basic types are equal, please use the = =;

2) If you want to compare two object references are equal, please use the = =;

3) If you want to compare two objects logically, please use the equals;

E.g.

1

2

3

4

5

6

String s1 = "STRING ME";

String s2 = "STRING ME";

System.out.println("s1: " + s1);

System.out.println("s2: " + s2);

System.out.println("s1 == s2 is " + (s1 == s2));

This would output: s1: STRING ME

s2: STRING ME

s1 == s2 is true

Page 83: Java first Session

1

2

3

4

5

6

s1 += "2";

s2 += "2";

System.out.println("s1: " + s1);

System.out.println("s2: " + s2);

System.out.println("s1 == s2 is " + (s1 == s2));

The output is now:

s1: STRING ME2

s2: STRING ME2

s1 == s2 is false

Page 84: Java first Session

Java Programming Language Session 7

Previously: constructors / access modifiers / overriding / overloading

Nested Classes

The Java programming language allows you to define a class within another class. Such

a class is called a nested class

e.g.

class OuterClass {

... static class StaticNestedClass {

... }

class InnerClass {

... }

}

Non-static nested classes (inner classes)

have access to other members of the enclosing class, even if they are

declared private

Static nested classes:

do not have access to other members of the enclosing class

a static nested class cannot refer directly to instance variables or methods

defined in its enclosing class — it can use them only through an object

reference (instantiate an object)

A static nested class interacts with the instance members of its outer class

(and other classes) just like any other top-level class. It is behaviorally a

top-level class that has been nested in another top-level class for packaging

convenience

Why Use Nested Classes?

Logical grouping of classes—If a class is useful to only one other class, then it

is logical to embed it in that class and keep the two together.

Increased ENCAPSULATION—Consider two top-level classes, A and B, where B

needs access to members of A that would otherwise be declared private. By hiding

class B within class A, A's members can be declared private and B can access

Page 85: Java first Session

them. In addition, B itself can be hidden (private) from the outside world and only seen by A.

More readable, maintainable code—Nesting small classes within top-level

classes places the code closer to where it is used.

The most common use of inner classes is as event handlers for GUI-based

applications. These classes are usually declared anonymously and as needed for

each component that requires an event handler. The advantage of using an inner class for event handling is that you can avoid large If/else statements to decide

which component is being handled. Each component gets its own event handler, so each event handler knows implicitly the component for which it's working.

Example:

In the following example, we will create an array, fill it with integer values (using a

constructor) and then output only values of even indices of the array in ascending order.

GROUPWORK: create an algorithm & pseudo code for the above

The DataStructure class below consists of:

The DataStructure outer class, which includes methods to add an integer onto the array and print out values of even indices of the array.

The InnerEvenIterator inner class, which is similar to a standard Java iterator

interface. Iterators are used to step through a data structure and typically have methods to test for the last element, retrieve the current element, and move to

the next element.

A main method that instantiates a DataStructure object (ds) and uses it to fill the

arrayOfInts array with integer values (0, 1, 2, 3, etc.), then calls a printEven

method to print out values of even indices of arrayOfInts.

N.B. Iterators and other specific commands are outside scope of this course which is to

understand basic OOP concepts in Java and how to logically create coding.

class DataStructure {

//create an array private final static int SIZE = 15;

private int[] arrayOfInts = new int[SIZE];

private DataStructure() { //fill the array with ascending integer values

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

arrayOfInts[i] = i; }

} private void printEven() {

Page 86: Java first Session

//print out values of even indices of the array InnerEvenIterator iterator = this.new InnerEvenIterator();

while (iterator.hasNext()) { System.out.println(iterator.getNext() + " ");

}

}

public static void main(String s[]) { //fill the array with integer values and print out only values of even

indices DataStructure ds = new DataStructure();

ds.printEven(); }

//inner class implements the Iterator pattern

private class InnerEvenIterator {

//start stepping through the array from the beginning private int next = 0;

private boolean hasNext() { //check if a current element is the last in the array

return (next <= SIZE - 1); }

private int getNext() { //record a value of an even index of the array

int retValue = arrayOfInts[next]; //get the next even element

next += 2; return retValue;

} }

}

Answer: 0 2 4 6 8 10 12 14

Note that the InnerEvenIterator class refers directly to the arrayOfInts instance variable

of the DataStructure object.

N.B.

1. You cannot put the main method in the inner class

2. You can declare the inner class private or protected but not outer classes

(only their members)

Page 87: Java first Session

To separate the above nested classes:

(the underlined words are the changes from the last coding) – instead of ―public‖ we can

use no modifier but not private or protected for methods and variables

public class DataStructure1 {

//create an array public final static int SIZE = 15;

public static int[] arrayOfInts = new int[SIZE];

public DataStructure1() {

//fill the array with ascending integer values for (int i = 0; i < SIZE; i++) {

arrayOfInts[i] = i; }

} public void printEven() {

//print out values of even indices of the array InnerEvenIterator1 iterator = new InnerEvenIterator1();

while (iterator.hasNext()) { System.out.println(iterator.getNext() + " ");

} }

public static void main(String s[]) {

//fill the array with integer values and print out values of even indices DataStructure1 ds = new DataStructure1();

ds.printEven(); }

}

//inner class implements the Iterator pattern public class InnerEvenIterator1 {

//start stepping through the array from the beginning public int next = 0;

public boolean hasNext() {

//check if a current element is the last in the array return (next <= DataStructure1.SIZE - 1);

}

public int getNext() { //record a value of an even index of the array

int retValue = DataStructure1.arrayOfInts[next]; //get the next even element

next += 2; return retValue;

}

}

Page 88: Java first Session

Programming in the Large

Packages

Packages are Java's way of doing large-scale design and organization:

They are used both to categorize and group classes

As the number of classes grows, the likelihood of wanting to reuse the short,

simple name of some class increases. Being able to "hide" a class inside a package

becomes useful.

Creating a Package

e.g.

package myFirstPackage.mySecondPackage; public class MyPublicClass extends ItsSuperclass {

. . . } guidance

The package is a folder that would contain classes. There can be several packages,

and thus folders, inside each other.

First declare the name of the package in a class by using a package statement,

then define the class

By convention, package names tend to begin with a lowercase letter to distinguish

them from class names

Any other classes also declared inside this same package name, are grouped

together

Packages can be organized into a hierarchy analogous to the inheritance hierarchy,

where each "level" usually represents a smaller, more specific grouping of classes

e.g. the java class library: The top level is called ―java‖ the next level e.g.

packages ―io, net, util, and awt‖ an even lower level, e.g. the package ―image‖

next e.g. the ColorModel class which can be referred to anywhere in Java code

as java.awt.image.ColorModel

The first level of the hierarchy specifies the (globally unique) name of the company

or software

The top-level package name reserves, all the uppercase abbreviations used for

top-level domains on the Internet (EDU, COM, GOV, FR, US, and so on). These

reserved names form the first part of all new package names

Page 89: Java first Session

When the compiler generates the

―.class‖ file of a ―.java‖ file, it places it

into this same directory so that the java

interpreter can find it. Both the compiler

and the interpreter expect the hierarchy

When classes are defined without a

package statement, the compiler places

such classes in a default, unnamed

package, and their ―.java‖ and ―.class‖

files can be located in the current directory (or in the directory called classes below

it). On some systems, the Java class library's .class files are now located in an

archive file named classes.zip in the lib directory

Using a Packaged Class

if you refer to the class you created in a package like this:

MyPublicClass ;

the compiler complains—because the class MyPublicClass is not defined in the package java.lang which compiles by default, neither is it a subclass of the

―Object‖ class which classes inherit by default. To solve this problem, Java allows any class name to be prefixed by the name of the package in which it was defined

to form a unique reference to the class:

myFirstPackage.MyPublicClass ;

Page 90: Java first Session

If we want to use a class from a certain package many times, we can "import" the

name of that class into the beginning of the class coding

e.g.

import packagename.ClassName;

ClassName anObject; // and you can use ClassName directly as many times as you like

N.B.

All import statements must appear after any package statement but before

any class definitions

e.g.

package javaapplication1;

import java.util.*;

public class VectorDemo{

You can only import public classes

If we want to use several classes from the same package, this is how to write it at

the beginning of the coding:

import packagename.*;

e.g.

import javax.swing.*;

Programming in the Small

INHERITANCE

As mentioned, Inheritance is the capability of a class to use the properties and

methods of another class while adding its own functionality and overriding its methods.

e.g. an employee records system:

Create a generic employee class with states and actions that are common to

all employees.

Then more specific classes could be defined for salaried, commissioned and

hourly employees.

The generic class is known as the parent (or superclass or base class) and the

specific classes as children (or subclasses or derived classes).

Page 91: Java first Session

The concept of inheritance greatly enhances the ability to reuse code as well as

making design a much simpler and cleaner process

Java uses the extends keyword to set the relationship between a child class and a

parent class

You can reuse the superclass constructor and overridden superclass methods by using the reserved word super. Note that this reference must come first in the

subclass constructor. The reserved word this is used to distinguish between the

object's property and the passed in parameter.

You cannot override final methods, methods in final classes, private

methods or static methods

ABSTRACTION - ABSTRACT Methods and Classes

Often, the superclass will be set up as an abstract class which does not allow objects of

its prototype to be created. In this case only objects of the subclass are used. Thus:

abstract classes can create no instances, but they can contain anything a normal

class can contain

abstract classes are allowed to prefix any of their methods with the modifier

―abstract‖

other classes extend an abstract class

public abstract class MyFirstAbstractClass { int anInstanceVariable;

public abstract int aMethodMyNonAbstractSubclassesMustImplement(); public void doSomething() {

. . . // a normal method }

} public class AConcreteSubClass extends MyFirstAbstractClass {

public int aMethodMyNonAbstractSubclassesMustImplement() { . . . // we *must* implement this method

} }

the abstract class provides the template for the methods, which are implemented

by others later

a class does not have to implement all methods (or even any methods) in an

abstract class).

However all classes that subclass a parent must implement all abstract

methods declared in the parent class or declare them abstract themselves

Abstract methods have no method statements

INTERFACES

Page 92: Java first Session

Interfaces pass on only method descriptions to their children and constants, not method

implementations nor instance variables.

Interfaces are used when programmers want to write their code without any

knowledge of how the other group's code is written e.g. used in GUI for event

handling.

An interface is a reference type, similar to a class:

It can contain only constants, method signatures.

There are no method bodies - all methods are abstract

Interfaces cannot be instantiated

they can only be implemented by classes or extended by other interfaces

Interfaces as APIs

Application Programming Interfaces (APIs) are common in commercial

software products. Typically, a company sells a software package that contains

complex methods that another company wants to use in its own software product.

An example would be a package of digital image processing methods that are sold

to companies making end-user graphics programs. The image processing company

writes its classes to implement an interface, which it makes public to its

customers. The graphics company then invokes the image processing methods

using the signatures and return types defined in the interface. While the image

processing company's API is made public (to its customers), its implementation of

the API is kept as a closely guarded secret—in fact, it may revise the

implementation at a later date as long as it continues to implement the original

interface that its customers have relied on.

Defining an Interface

e.g.

public interface OperateCar extends Interface1, Interface2, Interface3 { // constant declarations, if any

// method signatures

int changeLanes(Direction direction, double startSpeed, double endSpeed);

int signalTurn(Direction direction, boolean signalOn); int getRadarFront(double distanceToCar, double speedOfCar);

int getRadarRear(double distanceToCar, double speedOfCar); ......

// more method signatures }

An interface declaration consists of

Page 93: Java first Session

Modifiers (public indicates that the interface can be used by any class in any

package not just its own package)

the keyword interface,

the interface name,

a comma-separated list of parent interfaces (if any),

the interface body containing constants and method signatures

An interface can extend any number of other interfaces, however a class can be a

subclass and extend only one other class

Method signatures have no braces and are terminated with a semicolon (because

an interface does not provide implementations for the methods declared within it.)

All methods declared in an interface are public, so the public modifier can be

omitted.

All constant values defined in an interface are public, static, and final. Once

again, these modifiers can be omitted.

Implementing an Interface

To declare a class that implements an interface:

Include ―implements‖ in the class declaration

Your class can implement more than one interface, so the implements keyword is

followed by a comma-separated list of the interfaces implemented by the class

the ―implements‖ clause follows the ―extends‖ clause

Implementing an interface means implementing all the methods specified in it

This means you cannot modify an interface later on by e.g. adding methods to it

because these will have to be implemented by its subclasses too.

Using an Interface as a Type

If you define the type of a variable as an interface, any object you assign to it must be an instance of a class that implements the interface.

E.g., here is a method for finding the largest object in a pair of objects, for any objects that are instantiated from a class that implements Relatable:

public Object findLargest(Object object1, Object object2) {

Relatable obj1 = (Relatable)object1; Relatable obj2 = (Relatable)object2;

if ( (obj1).isLargerThan(obj2) > 0) return object1;

else return object2;

}

By casting object1 to a Relatable type, it can invoke the isLargerThan method.

Page 94: Java first Session

e.g. a six class application is used to generate an array of objects, three specific

shapes’ classes implementing the exact names of methods in a general shape class

public interface Shape {

void draw() ;

void erase() ; }

class Circle implements Shape { public void draw() {

System.out.println("Circle object"); }

public void erase() {

System.out.println("Circle erase"); }

}

class Square implements Shape {

public void draw() { System.out.println("Square object");

} public void erase() {

System.out.println("Square erase()");

} }

class Triangle implements Shape { public void draw() {

System.out.println("Triangle object"); }

public void erase() { System.out.println("Triangle erase");

}

}

public class ShapesDemo { private static RandomShapeGenerator gen = new RandomShapeGenerator();

public static void main(String[] args) {

Shape[] s = new Shape[9]; // Fill up the array with shapes:

for (int i = 0; i < s.length; i++) s[i] = gen.next();

// Make polymorphic method calls: for (int i = 0; i < s.length; i++)

s[i].draw();

}

}

Page 95: Java first Session

import java.util.Random; public class RandomShapeGenerator {

private Random rand = new Random();

public Shape next() {

switch (rand.nextInt(3)) { default:

case 0: return new Circle();

case 1: return new Square();

case 2: return new Triangle();

} }

}

N.B. nextInt(int n) Returns a random number, uniformly distributed int value between 0 (inclusive) and

the specified value (exclusive), drawn from this random number generator's sequence.

POLYMORPHISM

As mentioned, Polymorphism refers to “One Object, Many forms”

It is the ability of one object to be treated and used like other objects

It is manifested in several forms:

1. “method overriding” and “method overloading” (multiple methods having

the same name)

o Method Overloading or compile time polymorphism allows having same method name in a class or a subclass, with different argument types

or numbers.

Overloaded methods may all be defined in the same class, or they may be defined in different classes as long as those different

classes share a superclass - subclass relationship. o Method Overriding means creating a new set of method statements for

the same method signature (name, number of parameters and parameter types) within inherited subclasses, in 2 ways:

Replacement occurs when the code of the inherited method is not executed at all, i.e. it is completely superceded by the code in the

overriding method. Refinement augments an inherited method. This is accomplished

by calling, from within the overriding method, a superclass method using the keyword ―super” or explicitly calling an ancestor method

with its fully qualified name (dot notation); thus the inherited code is executed in the context of the subclass code

Since Interfaces cannot be

instantiated, interface class

―SHAPE‖ is not being

instantiated; If the random

number is zero, shape gets

instantiated as a new CIRCLE

object, and so on

Page 96: Java first Session

o N.B. Overriding: java determines the proper methods to call at the

program’s run time Overloading: java determines the proper methods to call at the

program’s compile time

2. ―late/dynamic method binding” o Consider the shapes example above. The decision to fill the shape array

with a certain type does not occur until runtime. This is a special feature of

Java called ―late binding.‖ It is late binding that allows polymorphism to work

3. Interfaces Increase Polymorphism: it stretches the ability of polymorphism over many families of classes

Page 97: Java first Session

Java Programming Language

Session 8

Abstract Classes - continued

� Abstract classes’ importance is in having: • the advantage of being a normal class with normal methods and • the advantage of interfaces of having abstract methods but without having to implement them all

� An abstract class cannot be instantiated � Any class with an abstract method must be declared abstract � A subclass of an abstract class can be instantiated only if it overrides all abstract methods of its superclass and provides an implementation (i.e., a method body) for all of them. Such a class is often called a concrete subclass

� If a subclass of an abstract class does not implement all the abstract methods it inherits, that subclass is itself abstract.

� static, private, and final methods cannot be abstract, since these types of methods cannot be overridden by a subclass. Similarly, a final class cannot contain any

abstract methods.

� A class can be declared abstract even if it does not actually have any abstract methods. Declaring such a class abstract indicates that the implementation is

somehow incomplete and is meant to serve as a superclass for one or more subclasses that will complete the implementation. Such a class cannot be instantiated

� It is only possible to call a concrete method of an abstract class when the method is instantiated through a concrete subclass. The method must also have a public or package visibility modifier that makes it accessible to the calling class.

Case Study 1

Create a package called “abstractApplication” and create five classes inside it to fill an

array with shapes and calculate their areas and parameters:

/*****abstract class containing methods to be inherited by its subclasses

and implemented for different usage in each subclass******/

public abstract class Shapes { public double getRadius(double r) { return r; } // Accessor

public double getWidth(double w) { return w; } // Accessor method

public double getHeight(double h) { return h; } // Another accessor

public abstract double area(); // Abstract methods: note public abstract double circumference(); // semicolon instead of body

/******subclass extending "shapes" thus using normal methods inside it and implementing abstract methods in it******/

class Circles extends Shapes { public static final double PI = 3.14159265358979323846; protected double r; // Instance data

public Circles(double radius) { r = radius; getRadius(r);} // Constructor

public double area() { return PI*r*r; } // Implementations of public double circumference() { return 2*PI*r; } // abstract methods.

Page 98: Java first Session

/******subclass extending "shapes" thus using normal methods inside it and implementing abstract methods in it******/

class Rectangles extends Shapes {

protected double w, h; // Instance data public Rectangles(double w, double h) { // Constructor

this.w = w; this.h = h;

}

public double area() { return w*h; } // Implementations of

public double circumference() { return 2*(w + h); } // abstract methods. }

/******subclass extending "shapes" thus using normal methods inside it and implementing abstract methods in it******/ package abstract_Application;

import java.lang.Math; class Triangles extends Shapes { protected double w, h; // Instance data

public Triangles(double w, double h) { // Constructor this.w = w; this.h = h; }

public double area() { return w*h/2; } // Implementations of abstract methods public double circumference() { double x=((w/2)*(w/2)) + (h*h);

return ((Math.sqrt(x))*2)+w; } }

/******* class of business logic ***********/

import javax.swing.JOptionPane;

public class CalculateTotalArea {

public static void main(String[] args) { String noOfShapesString=JOptionPane.showInputDialog(null,"How many shapes

do you want to calculate the total area and perimeter of?","Adding Areas", JOptionPane.QUESTION_MESSAGE); int noOfShapes=Integer.parseInt(noOfShapesString); // take input of

how many shapes Shapes[] shapeArray = new Shapes[noOfShapes]; // Create an array to

hold shapes

String[] choices = {"circle", "rectangle", "triangle"}; // create an array of options for option dialog box

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

//... Text to put on the buttons of option dialog box int response = JOptionPane.showOptionDialog(

null // Center in window. , "Choose shape "+(i+1) // Message , "Adding Areas" // Title in titlebar

, JOptionPane.YES_NO_OPTION // Option type , JOptionPane.PLAIN_MESSAGE // messageType , null // Icon (none)

, choices // Button text as above. , "None" ); // Default button's label

Page 99: Java first Session

switch (response) {

case 0: // if choice is circle, ask for its radius, add it to array and display its radius String circleRadiusString=JOptionPane.showInputDialog(null,"Please enter shape

"+(i+1)+" circle radius","Adding Areas", JOptionPane.QUESTION_MESSAGE); double circleRadius = Double.parseDouble(circleRadiusString); shapeArray[i] = new Circles(circleRadius); // Fill in the array

System.out.println("the radius of the circle shape "+(i+1)+" is " + shapeArray[i].getRadius(circleRadius)); break;

case 1: // if choice is rectangle, ask for its width,height, add it to array and display its parameters String shapeWidthString=JOptionPane.showInputDialog(null,"Please enter shape

"+(i+1)+" rectangle width","Adding Areas", JOptionPane.QUESTION_MESSAGE); double shapeWidth = Double.parseDouble(shapeWidthString); String shapeHeightString=JOptionPane.showInputDialog(null,"Please enter shape "+(i+1)+" rectangle height","Adding Areas",

JOptionPane.QUESTION_MESSAGE); double shapeHeight = Double.parseDouble(shapeHeightString);

shapeArray[i] = new Rectangles(shapeWidth, shapeHeight); System.out.println("the width of the rectangle shape "+(i+1)+" is " + shapeArray[i].getWidth(shapeWidth));

System.out.println("the height of the rectangle shape "+(i+1)+" is " + shapeArray[i].getHeight(shapeHeight)); break;

case 2: // if choice is triangle, ask for its width,height, add it to array and display its parameters

shapeWidthString=JOptionPane.showInputDialog(null,"Please enter shape

"+(i+1)+" triangle width","Adding Areas", JOptionPane.QUESTION_MESSAGE);

shapeWidth = Double.parseDouble(shapeWidthString); shapeHeightString=JOptionPane.showInputDialog(null,"Please enter shape "+(i+1)+" triangle height","Adding Areas",

JOptionPane.QUESTION_MESSAGE); shapeHeight = Double.parseDouble(shapeHeightString); shapeArray[i] = new Triangles(shapeWidth, shapeHeight);

System.out.println("the width of the triangle shape "+(i+1)+" is " + shapeArray[i].getWidth(shapeWidth)); System.out.println("the height of the triangle shape "+(i+1)+" is " +

shapeArray[i].getHeight(shapeHeight)); break;

}

} double total_area = 0;

double total_circumference=0;

for(int i = 0; i < shapeArray.length; i++) {total_area += shapeArray[i].area();

total_circumference+=shapeArray[i].circumference();

} // Compute the area & circumference of the shapes

int final_area =(int)total_area; int final_circumference=(int)total_circumference; // cast result to integers

JOptionPane.showMessageDialog(null, "total area of shapes is " +final_area+"cm2" //output to messagebox

+ "\ntotal perimeter of shapes is "+final_circumference+"cm");

}}

Page 100: Java first Session
Page 101: Java first Session

Case Study 2: Payroll System Using Polymorphism

Create a payroll program

& Use abstract methods and polymorphism Problem statement

� 4 types of employees, paid weekly 1. Salaried (fixed salary, no matter the hours) 2. Hourly (overtime [>40 hours] pays time and a half) 3. Commission (paid percentage of sales) 4. Base-plus-commission (base salary + percentage of sales)

• Boss wants to raise pay by 10% Superclass Employee (generic)

& Abstract method earnings (returns pay)

• abstract because need to know employee type • Cannot calculate for generic employee

& Other classes extend Employee

& Last class performs the business logic

N.B. note the usage of the question mark colon operator question e.g. : result = someCondition ? value1 : value2;

N.B. � “Constructors” don't create objects. They initialize them. The “new” operator creates objects

� Therefore All classes including abstract classes can have constructors. � Abstract class constructor will be called only when its concrete subclass is instantiated. But you cannot create a new object of an abstract class using the

“new” operator

6 classes :

/***** employee abstract superclass *******/ package payroll;

public abstract class Employee {

private String firstName; private String lastName; private String socialSecurityNumber;

Page 102: Java first Session

// constructor

public Employee( String first, String last, String ssn ) { firstName = first;

lastName = last; socialSecurityNumber = ssn; } // set first name

public void setFirstName( String first ) { firstName = first;

}

// return first name public String getFirstName() {

return firstName; } // set last name public void setLastName( String last )

{ lastName = last; }

// return last name public String getLastName() { return lastName;

} // set social security number

public void setSocialSecurityNumber( String number ) {

socialSecurityNumber = number; // should validate }

// return social security number public String getSocialSecurityNumber() { return socialSecurityNumber; }

// return String representation of Employee object public String toString()

{ return getFirstName() + " " + getLastName() + "\nsocial security number: " + getSocialSecurityNumber();

}

Page 103: Java first Session

// abstract method overridden by subclasses public abstract double earnings();

} // end abstract class Employee

/***** subclass of "salaried employee" *****/ package payroll;

public class SalariedEmployee extends Employee { private double weeklySalary;// used only for Salaried Emploee // constructor public SalariedEmployee( String first, String last, String socialSecurityNumber, double salary )

{ super( first, last, socialSecurityNumber );

setWeeklySalary( salary ); } // set salaried employee's salary public void setWeeklySalary( double salary )

{ // if salary is less than 0 then make weeklySalary =0 otherwise make it equal to salary

weeklySalary = salary< 0.0 ? 0.0 : salary; }

// return salaried employee's salary public double getWeeklySalary()

{ return weeklySalary; } // calculate salaried employee's pay; // override abstract method earnings in Employee

public double earnings() {

return getWeeklySalary(); }

// return String representation of SalariedEmployee object public String toString()

{ return "\nsalaried employee: " + super.toString(); } } // end class SalariedEmployee

Page 104: Java first Session

/***** subclass of "Hourly Employees" *****/

package payroll; public class HourlyEmployee extends Employee {

private double wage; // wage per hour private double hours; // hours worked for week // constructor public HourlyEmployee( String first, String last,

String socialSecurityNumber, double hourlyWage, double hoursWorked ) { super( first, last, socialSecurityNumber );

setWage( hourlyWage ); setHours( hoursWorked );

} // set hourly employee's wage

public void setWage( double wageAmount ) { wage = wageAmount < 0.0 ? 0.0 : wageAmount; }

// return wage public double getWage() {

return wage; } // set hourly employee's hours worked public void setHours( double hoursWorked )

{ hours = ( hoursWorked >= 0.0 && hoursWorked <= 168.0 ) ? hoursWorked : 0.0;

}

// return hours worked public double getHours() {

return hours; } // calculate hourly employee's pay; // override abstract method earnings in Employee

public double earnings() { if ( hours <= 40 ) // no overtime

return getWage() * getHours(); else return 40 * getWage() + ( getHours() - 40 ) * getWage() * 1.5;

}

Page 105: Java first Session

// return String representation of HourlyEmployee object public String toString() {

return "\nhourly employee: " + super.toString(); } } // end class HourlyEmployee

/***** subclass of "Commissioned Employees" *****/ package payroll;

public class CommissionEmployee extends Employee { private double grossSales; // gross weekly sales private double commissionRate; // commission percentage // constructor

public CommissionEmployee( String first, String last, String socialSecurityNumber, double grossWeeklySales, double percent )

{ super( first, last, socialSecurityNumber ); setGrossSales( grossWeeklySales ); setCommissionRate( percent ); }

// set commission employee's rate public void setCommissionRate( double rate )

{ commissionRate = ( rate > 0.0 && rate < 1.0 ) ? rate : 0.0;

} // return commission employee's rate

public double getCommissionRate() { return commissionRate; }

// set commission employee's weekly base salary public void setGrossSales( double sales ) {

grossSales = sales < 0.0 ? 0.0 : sales; }

// return commission employee's gross sales amount public double getGrossSales()

{ return grossSales; }

// calculate commission employee's pay;

// override abstract method earnings in Employee

Page 106: Java first Session

public double earnings()

{ return getCommissionRate() * getGrossSales(); }

// return String representation of CommissionEmployee object public String toString()

{ return "\ncommission employee: " + super.toString(); }

} // end class CommissionEmployee

/***** subclass of "Base Plus Commissioned Employees" *****/ package payroll;

public class BasePlusCommissionEmployee extends CommissionEmployee { private double baseSalary; // base salary per week

// constructor public BasePlusCommissionEmployee( String first, String last, String socialSecurityNumber, double grossSalesAmount, double rate, double baseSalaryAmount )

{ super( first, last, socialSecurityNumber, grossSalesAmount, rate ); setBaseSalary( baseSalaryAmount );

}

// set base-salaried commission employee's base salary public void setBaseSalary( double salary ) {

baseSalary = salary < 0.0 ? 0.0 : salary; } // return base-salaried commission employee's base salary public double getBaseSalary()

{ return baseSalary; }

// calculate base-salaried commission employee's earnings; // override method earnings in CommissionEmployee public double earnings() {

return getBaseSalary() + super.earnings(); }

Page 107: Java first Session

// return String representation of BasePlusCommissionEmployee

public String toString() { return "\nbase-salaried commission employee: " +

super.getFirstName() + " " + super.getLastName() + "\nsocial security number: " + super.getSocialSecurityNumber(); } } // end class BasePlusCommissionEmployee

/***** Business Logic Class *****/ package payroll; import java.text.DecimalFormat;

import javax.swing.JOptionPane;

public class PayrollSystemTest { public static void main( String[] args )

{ DecimalFormat twoDigits = new DecimalFormat( "0.00" ); // create Employee array Employee employees[] = new Employee[ 4 ];

// initialize array with Employees employees[ 0 ] = new SalariedEmployee( "John", "Smith","111-11-1111",

800.00 ); employees[ 1 ] = new CommissionEmployee( "Sue", "Jones","222-22-2222", 10000, .06 ); employees[ 2 ] = new BasePlusCommissionEmployee( "Bob", "Lewis","333-33-3333", 5000, .04, 300 );

employees[ 3 ] = new HourlyEmployee( "Karen", "Price","444-44-4444", 16.75, 40 );

String output = "";

// generically process each element in array employees for ( int i = 0; i < employees.length; i++ ) { output += employees[ i ].toString();

// determine whether element is a BasePlusCommissionEmployee if ( employees[ i ] instanceof BasePlusCommissionEmployee ) { /* operator instanceof checks the type of the object to which its left operand refers and determines whether this type has an is-a relationship with the type

specified as its right operand . */ // downcast Employee reference to BasePlusCommissionEmployee reference

BasePlusCommissionEmployee currentEmployee = ( BasePlusCommissionEmployee ) employees[ i ];

double oldBaseSalary = currentEmployee.getBaseSalary();

Page 108: Java first Session

output += "\nold base salary: $" + oldBaseSalary; currentEmployee.setBaseSalary( 1.10 * oldBaseSalary ); output += "\nnew base salary with 10% increase is: $" +

currentEmployee.getBaseSalary(); } // end if output += "\nearned $" + employees[ i ].earnings() + "\n"; } // end for // get type name of each object in employees array

for ( int j = 0; j < employees.length; j++ ) output += "\nEmployee " + j + " is a " +

employees[ j ].getClass().getName(); JOptionPane.showMessageDialog( null, output ); // display output System.exit( 0 ); } // end main

} // end class

Page 109: Java first Session

Case Study 3 : create several musical instrument classes which inherit from the abstract class “instruments”

// Abstract class and methods abstract class Instrument {

public abstract void play();

public String what() { return "Instrument";

} public abstract void adjust(); }

// subclass package music; class Wind extends Instrument {

public void play() { System.out.println("Wind.play()"); }

public String what() { return "Wind"; } public void adjust() {} }

// subclass package music;

class Percussion extends Instrument { public void play() { System.out.println("Percussion.play()");

} public String what() { return "Percussion"; } public void adjust() {} }

// subclass package music; class Strings extends Instrument {

public void play() { System.out.println("Strings.play()"); }

public String what() { return "Strings"; } public void adjust() {} }

// subclass package music;

class Brass extends Wind { public void play() { System.out.println("Brass.play()");

} public void adjust() { System.out.println("Brass.adjust()");

} }

// subclass package music;

class Woodwind extends Wind { public void play() { System.out.println("Woodwind.play()");

} public String what() { return "Woodwind"; } }

Page 110: Java first Session

Search Functions for Arrays & Dynamic Array

import java.util.*; public class ArraySearchTest { public static void main(String args[])

throws Exception { int array[] = {2, 5, -2, 6, -3, 8, 0, -7, -9, 4};

// Ensure array sorted

Arrays.sort(array); printArray("Sorted array", array);

// Search for element in array int index = Arrays.binarySearch(array, 2); System.out.println("Found 2 @ " + index); // Search for element not in array.....

// A negative return value indicates that the element is not in the list.... // However, the actual return value can be used to determine where that non-existent element should be inserted in the list if that were desired

index = Arrays.binarySearch(array, 1); System.out.println("Didn't find 1 @ " + index); // Insert int newIndex = -index - 1;

array = insertElement(array, 1, newIndex); printArray("With 1 added", array); } private static void printArray(String message, int array[]) { System.out.println(message + ": [length: " + array.length + "]");

// Print out sorted array elements for (int i=0, n=array.length; i<n; i++) {

if (i != 0) System.out.print(", "); System.out.print(array[i]); } System.out.println(); } private static int[] insertElement(int original[], int element, int index) {

int length = original.length; int destination[] = new int[length+1]; System.arraycopy(original, 0, destination, 0, index); destination[index] = element; System.arraycopy(original, index, destination, index+1, length-index);

return destination; }

}

Page 111: Java first Session

Selection Sort for Arrays

This uses the idea of finding the biggest item in the list and moving it to the end. Once the biggest item is in its correct location, you can then apply the same idea to the

remaining items. That is, find the next-biggest item, and move it into the next-to-last space, and so forth. This algorithm is called selection sort

static void selectionSort(int[] A) {

// Sort A into increasing order, using selection sort for (int lastPlace = A.length-1; lastPlace > 0; lastPlace--) { // Find the largest item among A[0], A[1], ..., // A[lastPlace], and move it into position lastPlace // by swapping it with the number that is currently

// in position lastPlace.

int maxLoc = 0; // Location of largest item seen so far. for (int j = 1; j <= lastPlace; j++) {

if (A[j] > A[maxLoc]) { // Since A[j] is bigger than the maximum we've seen // so far, j is the new location of the maximum value

// we've seen so far. maxLoc = j; } }

int temp = A[maxLoc]; // Swap largest item with A[lastPlace]. A[maxLoc] = A[lastPlace]; A[lastPlace] = temp;

} // end of for loop

}

Page 112: Java first Session

Vectors

� Vectors (the java.util.Vector class) are commonly used instead of arrays, because they expand automatically when new data is added to them.

� Vectors can hold only Objects and not primitive types (eg, int). If you want to put a primitive type in a Vector, put it inside an object (eg, define your own class)

� You must import either import java.util.Vector; or import java.util.* � Create a Vector with default initial size

Vector v = new Vector();

� Create a Vector with an initial size

Vector v = new Vector(300);

� To Add elements to the end of a Vector

v.add(s); // adds s to the end of the Vector v v.addElement(new Float(1.9999));

� To get the elements from a Vector (ListIterator)

You can use a for loop to get all the elements from a Vector, but another very

common way to go over all elements in a Vector is to use a ListIterator. The

advantage of an iterator is that it can be used with other data structures, so that if

you later change to using a linked list for example, you won't have to change your

code. Here is an example of using an iterator to print all elements (Strings) in a

vector. The two most useful methods are hasNext(), which returns true if there

are more elements, and next(), which returns the next element.

ListIterator iter = v.listIterator();

while (iter.hasNext()) {

System.out.println((String)iter.next());

}

� Common Vector Methods v is a Vector, i is an int index, o is an Object

Method Description

v.add(o) adds Object o to Vector v

v.add(i, o) Inserts Object o at index i, shifting elements up as

necessary.

v.clear() removes all elements from Vector v

v.contains(o) Returns true if Vector v contains Object o

v.firstElement(i) Returns the first element.

v.get(i) Returns the object at int index i.

v.lastElement(i) Returns the last element.

v.listIterator() Returns a ListIterator that can be used to go over the

Vector. This is a useful alternative to the for loop.

v.remove(i) Removes the element at position i, and shifts all

following elements down.

v.set(i,o) Sets the element at index i to o.

v.size() Returns the number of elements in Vector v.

myVector.insertElementAt(my_object, 5) Insert an element at a certain position

Page 113: Java first Session

Java Programming Language

Session 10

Laying Out Components within a Container

Layout Managers are used to

o Calculate the minimum/preferred/maximum sizes for a container.

o Lay out the container's children (arrange components within a graphical

interface).

There are many standard Layout Managers available:

BorderLayout

The content pane is the main container in all frames, applets, and dialogs. A

BorderLayout places components in up to five areas: top, bottom, left,

right, and center. All extra space is placed in the center area.

/*

* BorderLayoutDemo.java *

*/

import javax.swing.*; import java.awt.BorderLayout;

import java.awt.Container;

import java.awt.Dimension;

public class BorderLayoutDemo {

public static void addComponentsToPane(Container pane) {

JButton button = new JButton("Button 1 (PAGE_START)");

pane.add(button, BorderLayout.NORTH);

Page 114: Java first Session

//Make the center component big, since that's the //typical usage of BorderLayout. button = new JButton("Button 2 (CENTER)");

button.setPreferredSize(new Dimension(200, 100));

pane.add(button, BorderLayout.CENTER); button = new JButton("Button 3 (LINE_START)");

pane.add(button, BorderLayout.WEST);

button = new JButton("Long-Named Button 4 (PAGE_END)");

pane.add(button, BorderLayout.SOUTH);

button = new JButton("5 (LINE_END)");

pane.add(button, BorderLayout.EAST); }

/** * Create the GUI and show it.

*/

private static void createAndShowGUI() {

//Create and set up the window.

JFrame frame = new JFrame("BorderLayoutDemo");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Set up the content pane.

addComponentsToPane(frame.getContentPane());

//Use the content pane's default BorderLayout.

//Display the window.

frame.pack();

frame.setVisible(true);

}

public static void main(String[] args) {

createAndShowGUI();

}

}

BoxLayout

The BoxLayout class puts components in a

single row or column. It respects the

components' requested maximum sizes and

also lets you align components

Page 115: Java first Session

think of it as a version of FlowLayout, but with greater functionality

/* * BoxLayoutDemo.java requires no other files.

*/ import java.awt.Component; import java.awt.Container;

import javax.swing.BoxLayout; import javax.swing.JButton;

import javax.swing.JFrame; public class BoxLayoutDemo {

public static void addComponentsToPane(Container pane) { pane.setLayout(new BoxLayout(pane, BoxLayout.Y_AXIS)); addAButton("Button 1", pane); addAButton("Button 2", pane);

addAButton("Button 3", pane); addAButton("Long-Named Button 4", pane); addAButton("5", pane);

} private static void addAButton(String text, Container container) { JButton button = new JButton(text); button.setAlignmentX(Component.CENTER_ALIGNMENT);

container.add(button); }

/** * Create the GUI and show it.

*/ private static void createAndShowGUI() { //Create and set up the window.

JFrame frame = new JFrame("BoxLayoutDemo"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//Set up the content pane. addComponentsToPane(frame.getContentPane());

//Display the window. frame.pack();

frame.setVisible(true); } public static void main(String[] args) {

//creating and showing this application's GUI. createAndShowGUI(); }

}

Page 116: Java first Session

CardLayout

The CardLayout class lets you implement an area that contains different

components at different times. A CardLayout is often controlled by a combo

box, with the state of the combo box determining which panel (group of

components) the CardLayout displays.

/* * CardLayoutDemo.java

*

*/

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

public class CardLayoutDemo implements ItemListener { JPanel cards; //a panel that uses CardLayout

final static String BUTTONPANEL = "Card with JButtons";

final static String TEXTPANEL = "Card with JTextField";

public void addComponentToPane(Container pane) {

//Put the JComboBox in a JPanel to get a nicer look.

JPanel comboBoxPane = new JPanel(); //use FlowLayout

String comboBoxItems[] = { BUTTONPANEL, TEXTPANEL }; JComboBox cb = new JComboBox(comboBoxItems); cb.setEditable(false);

cb.addItemListener(this);

comboBoxPane.add(cb);

//Create the "cards".

JPanel card1 = new JPanel();

card1.add(new JButton("Button 1")); card1.add(new JButton("Button 2")); card1.add(new JButton("Button 3"));

JPanel card2 = new JPanel();

card2.add(new JTextField("TextField", 20)); //Create the panel that contains the "cards".

cards = new JPanel(new CardLayout());

cards.add(card1, BUTTONPANEL);

Page 117: Java first Session

cards.add(card2, TEXTPANEL); pane.add(comboBoxPane, BorderLayout.NORTH);

pane.add(cards, BorderLayout.CENTER);

} public void itemStateChanged(ItemEvent evt) {

CardLayout cl = (CardLayout)(cards.getLayout()); cl.show(cards, (String)evt.getItem());

}

/**

* Create the GUI and show it.

*/ private static void createAndShowGUI() {

//Create and set up the window. JFrame frame = new JFrame("CardLayoutDemo"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//Create and set up the content pane.

CardLayoutDemo demo = new CardLayoutDemo();

demo.addComponentToPane(frame.getContentPane());

//Display the window. frame.pack();

frame.setVisible(true);

}

public static void main(String[] args) {

createAndShowGUI();

}

}

FlowLayout

FlowLayout is the default layout manager for every JPanel. It simply lays

out components in a single row, starting a new row if its container is not

sufficiently wide. Both panels in CardLayoutDemo, shown previously, use

FlowLayout

Page 118: Java first Session

/*

* * FlowLayoutDemo.java *

*/ import java.awt.*; import java.awt.event.*; import javax.swing.*;

import java.util.*; public class FlowLayoutDemo extends JFrame{

JRadioButton RtoLbutton; JRadioButton LtoRbutton;

FlowLayout experimentLayout = new FlowLayout(); final String RtoL = "Right to left"; final String LtoR = "Left to right";

JButton applyButton = new JButton("Apply component orientation"); public FlowLayoutDemo(String name) { super(name); }

public void addComponentsToPane(final Container pane) { final JPanel compsToExperiment = new JPanel();

compsToExperiment.setLayout(experimentLayout); experimentLayout.setAlignment(FlowLayout.TRAILING); JPanel controls = new JPanel(); controls.setLayout(new FlowLayout());

LtoRbutton = new JRadioButton(LtoR); LtoRbutton.setActionCommand(LtoR); LtoRbutton.setSelected(true);

RtoLbutton = new JRadioButton(RtoL); RtoLbutton.setActionCommand(RtoL);

//Add buttons to the experiment layout compsToExperiment.add(new JButton("Button 1"));

compsToExperiment.add(new JButton("Button 2")); compsToExperiment.add(new JButton("Button 3")); compsToExperiment.add(new JButton("Long-Named Button 4")); compsToExperiment.add(new JButton("5")); //Left to right component orientation is selected by default

compsToExperiment.setComponentOrientation( ComponentOrientation.LEFT_TO_RIGHT);

//Add controls to set up the component orientation in the experiment layout final ButtonGroup group = new ButtonGroup(); group.add(LtoRbutton);

group.add(RtoLbutton);

Page 119: Java first Session

controls.add(LtoRbutton); controls.add(RtoLbutton); controls.add(applyButton);

//Process the Apply component orientation button press applyButton.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){

String command = group.getSelection().getActionCommand(); //Check the selection

if (command.equals("Left to right")) {

compsToExperiment.setComponentOrientation( ComponentOrientation.LEFT_TO_RIGHT);

} else {

compsToExperiment.setComponentOrientation( ComponentOrientation.RIGHT_TO_LEFT);

} //update the experiment layout compsToExperiment.validate();

compsToExperiment.repaint();

}

});

pane.add(compsToExperiment, BorderLayout.CENTER);

pane.add(controls, BorderLayout.SOUTH); ;

}

/**

* Create the GUI and show it.

*/

private static void createAndShowGUI() {

//Create and set up the window.

FlowLayoutDemo frame = new FlowLayoutDemo("FlowLayoutDemo");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Set up the content pane.

frame.addComponentsToPane(frame.getContentPane());

//Display the window.

frame.pack();

frame.setVisible(true); }

public static void main(String[] args) {

createAndShowGUI(); }

}

GridBagLayout

GridBagLayout is a sophisticated, flexible

layout manager. It aligns components by

placing them within a grid of cells,

Page 120: Java first Session

allowing components to span more than one cell. The rows in the grid can

have different heights, and grid columns can have different widths.

GridLayout

GridLayout simply makes a bunch of

components equal in size and

displays them in the requested

number of rows and columns

/*

* GridLayoutDemo.java */

import java.awt.*; import java.awt.event.*;

import javax.swing.*;

public class GridLayoutDemo extends JFrame {

static final String gapList[] = {"0", "10", "15", "20"}; final static int maxGap = 20;

JComboBox horGapComboBox;

JComboBox verGapComboBox;

JButton applyButton = new JButton("Apply gaps");

GridLayout experimentLayout = new GridLayout(3,2);

public GridLayoutDemo(String name) {

super(name); setResizable(false);

}

public void initGaps() { horGapComboBox = new JComboBox(gapList);

verGapComboBox = new JComboBox(gapList); }

public void addComponentsToPane(final Container pane) { initGaps();

final JPanel compsToExperiment = new JPanel(); compsToExperiment.setLayout(experimentLayout);

JPanel controls = new JPanel(); controls.setLayout(new GridLayout(2,3));

//Set up components preferred size

JButton b = new JButton("Just fake button"); Dimension buttonSize = b.getPreferredSize();

compsToExperiment.setPreferredSize(new Dimension((int)(buttonSize.getWidth()

* 2.5)+maxGap,

(int)(buttonSize.getHeight() * 3.5)+maxGap * 2));

Page 121: Java first Session

//Add buttons to experiment with Grid Layout

compsToExperiment.add(new JButton("Button 1")); compsToExperiment.add(new JButton("Button 2")); compsToExperiment.add(new JButton("Button 3"));

compsToExperiment.add(new JButton("Long-Named Button 4")); compsToExperiment.add(new JButton("5")); //Add controls to set up horizontal and vertical gaps controls.add(new Label("Horizontal gap:"));

controls.add(new Label("Vertical gap:")); controls.add(new Label(" ")); controls.add(horGapComboBox);

controls.add(verGapComboBox); controls.add(applyButton);

//Process the Apply gaps button press applyButton.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){ //Get the horizontal gap value String horGap = (String)horGapComboBox.getSelectedItem(); //Get the vertical gap value String verGap = (String)verGapComboBox.getSelectedItem();

//Set up the horizontal gap value experimentLayout.setHgap(Integer.parseInt(horGap)); //Set up the vertical gap value

experimentLayout.setVgap(Integer.parseInt(verGap)); //Set up the layout of the buttons experimentLayout.layoutContainer(compsToExperiment); } });

pane.add(compsToExperiment, BorderLayout.NORTH); pane.add(new JSeparator(), BorderLayout.CENTER); pane.add(controls, BorderLayout.SOUTH);

} /**Create the GUI and show it.

*/ private static void createAndShowGUI() { //Create and set up the window.

GridLayoutDemo frame = new GridLayoutDemo("GridLayoutDemo"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Set up the content pane. frame.addComponentsToPane(frame.getContentPane()); //Display the window.

frame.pack(); frame.setVisible(true); }

public static void main(String[] args) { createAndShowGUI(); }

}

Page 122: Java first Session

Java Programming Language

Session 11

GUI Without Layout Managers – Absolute Positioning

Uses

If a container holds components whose size is not affected by the container's size or by font, look-and-feel, or language changes. Desktop panes, which contain internal frames, are in this category. The size and position of internal frames does not depend directly on the desktop pane's size. The programmer determines the initial size and placement of

internal frames within the desktop pane, and then the user can move or resize the frames. A layout manager is unnecessary in this situation.

Steps

1. Set the container's layout manager to null by calling setLayout(null). 2. Call the Component class's setbounds method for each of the container's children. 3. Call the Component class's repaint method.

/* * AbsoluteLayoutDemo.java */

import java.awt.Container; import java.awt.Insets; import java.awt.Dimension; import javax.swing.JButton;

import javax.swing.JFrame; public class AbsoluteLayoutDemo {

public static void addComponentsToPane(Container pane) { pane.setLayout(null);

JButton b1 = new JButton("one");

JButton b2 = new JButton("two"); JButton b3 = new JButton("three"); pane.add(b1); pane.add(b2);

pane.add(b3); Insets insets = pane.getInsets();

Dimension size = b1.getPreferredSize(); // default size (50,25)

Page 123: Java first Session

size.width=60; size.height=30; b1.setBounds(25 + insets.left, 5 + insets.top,

size.width, size.height);

size = b2.getPreferredSize(); b2.setBounds(55 + insets.left, 40 + insets.top, size.width, size.height);

size = b3.getPreferredSize(); b3.setBounds(150 + insets.left, 15 + insets.top,

size.width + 50, size.height + 20);

}

/**

* Create the GUI and show it. */

private static void createAndShowGUI() { //Create and set up the window.

JFrame frame = new JFrame("AbsoluteLayoutDemo");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//Set up the content pane.

addComponentsToPane(frame.getContentPane());

//Size and display the window.

Insets insets = frame.getInsets();

frame.setSize(300 + insets.left + insets.right,

125 + insets.top + insets.bottom);

frame.setVisible(true);

}

public static void main(String[] args) { //Schedule a job

//creating and showing this application's GUI.

createAndShowGUI();

}

}

Event Listeners

1. Beeper • a button that beeps when you click it

• The Beeper class implements the ActionListener interface, which contains

one method: actionPerformed. Once the Beeper has been registered using

the Button addActionListener method, the Beeper's actionPerformed method

is called every time the button is clicked.

Page 124: Java first Session

/*Beeper.java

*/ import java.awt.*; import javax.swing.JFrame;

import javax.swing.JPanel; import javax.swing.JButton; import javax.swing.JComponent; import java.awt.Toolkit;

import java.awt.BorderLayout; import java.awt.event.ActionListener; import java.awt.event.ActionEvent;

public class Beeper extends JPanel implements ActionListener {

JButton button; public Beeper() {

super(new BorderLayout()); button = new JButton("Click Me"); button.setPreferredSize(new Dimension(200, 80)); add(button, BorderLayout.CENTER); button.addActionListener(this);

} public void actionPerformed(ActionEvent e) {

Toolkit.getDefaultToolkit().beep(); } /** * Create the GUI and show it. */

private static void createAndShowGUI() { //Create and set up the window. JFrame frame = new JFrame("Beeper");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//Create and set up the content pane. JComponent newContentPane = new Beeper(); newContentPane.setOpaque(true); //content panes must be opaque

frame.setContentPane(newContentPane); //Display the window. frame.pack(); frame.setVisible(true);

} public static void main(String[] args) { //Schedule a job

createAndShowGUI(); } }

Page 125: Java first Session

Listeners Supported by Swing Components

You can tell what kinds of events a component can fire by looking at the kinds of event listeners you can register on it. For example, the JComboBox class defines these listener

registration methods:

• addActionListener • addItemListener

• addPopupMenuListener

Thus a combo box supports action, item, and popup menu listeners in addition to the

listener methods it inherits from JComponent

Listeners supported by Swing components fall into two categories:

• Listeners that All Swing Components Support

• Other Listeners that Swing Components Support

Because all Swing components descend from the AWT Component class, you can

register the following listeners on any Swing component:

component listener

Listens for changes in the component's size, position, or visibility.

focus listener

Listens for whether the component gained or lost the keyboard focus.

key listener

Listens for key presses; key events are fired only by the component that has the

current keyboard focus.

mouse listener

Listens for mouse clicks, mouse presses, mouse releases and mouse movement

into or out of the component's drawing area.

mouse-motion listener

Listens for changes in the mouse cursor's position over the component.

mouse-wheel listener

Listens for mouse wheel movement over the component.

Page 126: Java first Session

Action Listeners

Action listeners are probably the easiest — and most common — event handlers to

implement. You implement an action listener to define what should be done when an

user performs certain operation

Examples: When the user clicks a button, chooses a menu item, presses Enter in a text

field. The result is that an actionPerformed message is sent to all action listeners that

are registered on the relevant component.

Steps:

1. Declare an event handler class and specify that the class either implements an ActionListener interface or extends a class that implements an ActionListener

interface. For example:

public class MyClass implements ActionListener {

Register an instance of the event handler class as a listener on one or more components

using the addActionListener method. When the user clicks the onscreen button, the

button fires an action event. This results in the invocation of the action listener's actionPerformed method (the only method in the ActionListener interface). The single

argument to the method is an ActionEvent object that gives information about the event

and its source.

2. . For example:

someComponent.addActionListener(instanceOfMyClass);

3. Include code that implements the methods in listener interface. For example:

public void actionPerformed(ActionEvent e) { ...//code that reacts to the action...

}

E.G.

import java.awt.*;

import java.awt.event.*;

public class AL extends Frame implements

WindowListener,ActionListener { TextField text = new TextField(20);

Button b; private int numClicks = 0;

public static void main(String[] args) { AL myWindow = new AL("My first window"); myWindow.setSize(350,100);

myWindow.setVisible(true); }

public AL(String title) {

super(title);

Page 127: Java first Session

setLayout(new FlowLayout());

addWindowListener(this); b = new Button("Click me"); add(b);

add(text); b.addActionListener(this); } public void actionPerformed(ActionEvent e) {

numClicks++; text.setText("Button Clicked " + numClicks + " times"); }

public void windowClosing(WindowEvent e) { dispose();

System.exit(0); } public void windowOpened(WindowEvent e) {}

public void windowActivated(WindowEvent e) {} public void windowIconified(WindowEvent e) {} public void windowDeiconified(WindowEvent e) {}

public void windowDeactivated(WindowEvent e) {} public void windowClosed(WindowEvent e) {} }

Internal Frame

Event

/*

InternalFrameEventDemo

*/

import java.awt.*;

import java.awt.event.*;

import javax.swing.*; import javax.swing.event.*;

public class

InternalFrameEventDemo extends

JFrame

implements InternalFrameListener,

ActionListener {

JTextArea display; JDesktopPane desktop;

JInternalFrame displayWindow; JInternalFrame listenedToWindow;

static final String SHOW = "show";

static final String CLEAR = "clear";

String newline = "\n"; static final int desktopWidth = 500;

Page 128: Java first Session

static final int desktopHeight = 300;

public InternalFrameEventDemo(String title) { super(title);

//Set up the GUI. desktop = new JDesktopPane(); desktop.putClientProperty("JDesktopPane.dragMode", "outline");

//Because we use pack, it's not enough to call setSize. //We must set the desktop's preferred size. desktop.setPreferredSize(new Dimension(desktopWidth, desktopHeight));

setContentPane(desktop);

createDisplayWindow(); desktop.add(displayWindow); //DON'T FORGET THIS!!! Dimension displaySize = displayWindow.getSize();

displayWindow.setSize(desktopWidth, displaySize.height); } //Create the window that displays event information. protected void createDisplayWindow() {

JButton b1 = new JButton("Show internal frame"); b1.setActionCommand(SHOW); b1.addActionListener(this);

JButton b2 = new JButton("Clear event info"); b2.setActionCommand(CLEAR); b2.addActionListener(this);

display = new JTextArea(3, 30); display.setEditable(false); JScrollPane textScroller = new JScrollPane(display);

//Have to supply a preferred size, or else the scroll //area will try to stay as large as the text area.

textScroller.setPreferredSize(new Dimension(200, 75)); textScroller.setMinimumSize(new Dimension(10, 10));

displayWindow = new JInternalFrame("Event Watcher", true, //resizable false, //not closable false, //not maximizable true); //iconifiable

JPanel contentPane = new JPanel(); contentPane.setBorder(BorderFactory.createEmptyBorder(10,10,10,10)); contentPane.setLayout(new BoxLayout(contentPane,

BoxLayout.X_AXIS)); b1.setAlignmentX(CENTER_ALIGNMENT); contentPane.add(b1);

contentPane.add(Box.createRigidArea(new Dimension(0, 5)));

Page 129: Java first Session

contentPane.add(textScroller);

contentPane.add(Box.createRigidArea(new Dimension(0, 5))); b2.setAlignmentX(CENTER_ALIGNMENT); contentPane.add(b2);

displayWindow.setContentPane(contentPane); displayWindow.pack(); displayWindow.setVisible(true); }

public void internalFrameClosing(InternalFrameEvent e) { displayMessage("Internal frame closing", e); }

public void internalFrameClosed(InternalFrameEvent e) { displayMessage("Internal frame closed", e);

} public void internalFrameOpened(InternalFrameEvent e) { displayMessage("Internal frame opened", e);

} public void internalFrameIconified(InternalFrameEvent e) { displayMessage("Internal frame iconified", e); } public void internalFrameDeiconified(InternalFrameEvent e) {

displayMessage("Internal frame deiconified", e); } public void internalFrameActivated(InternalFrameEvent e) {

displayMessage("Internal frame activated", e); } public void internalFrameDeactivated(InternalFrameEvent e) { displayMessage("Internal frame deactivated", e);

} //Add some text to the text area. void displayMessage(String prefix, InternalFrameEvent e) {

String s = prefix + ": " + e.getSource(); display.append(s + newline);

display.setCaretPosition(display.getDocument().getLength()); } //Handle events on the two buttons.

public void actionPerformed(ActionEvent e) { if (SHOW.equals(e.getActionCommand())) { //They clicked the Show button. //Create the internal frame if necessary.

if (listenedToWindow == null) { listenedToWindow = new JInternalFrame("Event Generator", true, //resizable

true, //closable true, //maximizable true); //iconifiable

Page 130: Java first Session

//We want to reuse the internal frame, so we need to

//make it hide (instead of being disposed of, which is //the default) when the user closes it. listenedToWindow.setDefaultCloseOperation(

WindowConstants.HIDE_ON_CLOSE); //Add an internal frame listener so we can see //what internal frame events it generates. listenedToWindow.addInternalFrameListener(this);

//And we mustn't forget to add it to the desktop pane! desktop.add(listenedToWindow);

//Set its size and location. We'd use pack() to set the size

//if the window contained anything. listenedToWindow.setSize(300, 100); listenedToWindow.setLocation(

desktopWidth/2 - listenedToWindow.getWidth()/2, desktopHeight - listenedToWindow.getHeight()); } //Show the internal frame. listenedToWindow.setVisible(true);

} else { //They clicked the Clear button. display.setText("");

} } /** * Create the GUI and show it. */

private static void createAndShowGUI() { //Make sure we have nice window decorations. JFrame.setDefaultLookAndFeelDecorated(true);

//Create and set up the window.

JFrame frame = new InternalFrameEventDemo( "InternalFrameEventDemo"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//Display the window. frame.pack(); frame.setVisible(true); }

public static void main(String[] args) { //Schedule a job createAndShowGUI();

} }

Page 131: Java first Session

Mouse Listener

Mouse events notify when the user uses the mouse (or similar input device) to interact

with a component. Mouse events occur when the cursor enters or exits a component's

onscreen area and when the user presses or releases one of the mouse buttons.

/* * BlankArea.java is used by: * MouseEventDemo.java. * MouseMotionEventDemo.java */ import javax.swing.*; import java.awt.Dimension; import java.awt.Color; import java.awt.Graphics; public class BlankArea extends JLabel { Dimension minSize = new Dimension(100, 50); public BlankArea(Color color) { setBackground(color); setOpaque(true); setBorder(BorderFactory.createLineBorder(Color.black)); } public Dimension getMinimumSize() { return minSize; } public Dimension getPreferredSize() { return minSize; } }

Page 132: Java first Session

/*

* MouseEventDemo.java

*/

import java.awt.GridLayout;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.event.MouseListener; import java.awt.event.MouseEvent;

import javax.swing.*;

public class MouseEventDemo extends JPanel

implements MouseListener { BlankArea blankArea;

JTextArea textArea;

static final String NEWLINE = System.getProperty("line.separator");

public static void main(String[] args) { /* Use an appropriate Look and Feel */

try { //UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLoo

kAndFeel");

Page 133: Java first Session

//UIManager.setLookAndFeel("com.sun.java.swing.plaf.gtk.GTKLookAndFeel");

UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel"); } catch (UnsupportedLookAndFeelException ex) { ex.printStackTrace(); } catch (IllegalAccessException ex) { ex.printStackTrace();

} catch (InstantiationException ex) { ex.printStackTrace(); } catch (ClassNotFoundException ex) {

ex.printStackTrace(); }

/* Turn off metal's use of bold fonts */ UIManager.put("swing.boldMetal", Boolean.FALSE); //Schedule a job for the event dispatch thread:

//creating and showing this application's GUI. javax.swing.SwingUtilities.invokeLater(new Runnable() { public void run() { createAndShowGUI(); }

}); }

/** * Create the GUI and show it. For thread safety, * this method should be invoked from the * event dispatch thread. */

private static void createAndShowGUI() { //Create and set up the window. JFrame frame = new JFrame("MouseEventDemo");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//Create and set up the content pane. JComponent newContentPane = new MouseEventDemo(); newContentPane.setOpaque(true); //content panes must be opaque

frame.setContentPane(newContentPane); //Display the window. frame.pack(); frame.setVisible(true);

} public MouseEventDemo() {

super(new GridLayout(0,1)); blankArea = new BlankArea(Color.green); add(blankArea);

textArea = new JTextArea();

Page 134: Java first Session

textArea.setEditable(false);

JScrollPane scrollPane = new JScrollPane(textArea); scrollPane.setVerticalScrollBarPolicy( JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);

scrollPane.setPreferredSize(new Dimension(200, 75)); add(scrollPane); //Register for mouse events on blankArea and the panel. blankArea.addMouseListener(this);

addMouseListener(this); setPreferredSize(new Dimension(450, 450)); setBorder(BorderFactory.createEmptyBorder(20,20,20,20));

}

void eventOutput(String eventDescription, MouseEvent e) { textArea.append(eventDescription + " detected on " + e.getComponent().getClass().getName()

+ "." + NEWLINE); textArea.setCaretPosition(textArea.getDocument().getLength()); } public void mousePressed(MouseEvent e) {

eventOutput("Mouse pressed (# of clicks: " + e.getClickCount() + ")", e); }

public void mouseReleased(MouseEvent e) { eventOutput("Mouse released (# of clicks: " + e.getClickCount() + ")", e); }

public void mouseEntered(MouseEvent e) { eventOutput("Mouse entered", e);

}

public void mouseExited(MouseEvent e) { eventOutput("Mouse exited", e); }

public void mouseClicked(MouseEvent e) { eventOutput("Mouse clicked (# of clicks: " + e.getClickCount() + ")", e); }

}

Page 135: Java first Session

 

 

Java Programming Test Assignment 2            Due: Sat 13/2/10 Create a class called Salaries to contain and do the following: 

1. Create 4 single dimensional arrays containing the following information: 

Names  Ages Salaries Addresses Ahmed Moussa  65  5500 Heliopolis,Cairo Hadeer Hassab  23  2000 ElHaram,Giza Ziad Amr  42  4000 Mohandeseen,CairoMaha Allenby  35  3500 Tanta,ElGharbia Mohamed Abdou  75  NasrCity,Cairo 

 2. If the age of the employee is from 40 to 65, add a bonus for him of 2200 

LE, then reduce 10% from this total sum for taxes. Print out the name and final salary of each employee 

3. If the age of the employee is from 20 to 39, add a bonus for him of 1100 LE, then reduce 20% from this total sum for taxes. Print out the name and final salary of each employee 

4. If the age of the employee is not in the above categories, then print out his name and say that he is not an employee 

5. Find out how many people live in Cairo and print it out ( hint: use the comma in your search /  You can also use e.g. array[2].length()). 

N.B. marks will be allocated for  

• suitable names of variables,  

• proper organization of coding and  

• adding comments 

Page 136: Java first Session

file:///D|/java/Assignment2.txt[1/5/2011 8:18:03 PM]

/*Salaries class/*Salaries class */

package salaries;public class Main { public static void main(String[] args) { String[] names={"Ahmed Moussa","Hadeer Hassab","Ziad Amr","Maha Ellenby","Mohammed Abdou"} ;//names array int[]ages={65,23,42,35,75};//ages array double[]salary={5500,2000,4000,3500,0};//salary array String[]adreslocation={"Heliopolis","Elharam","Mohandseen","Tanta","Nasr city"};//location array String[]adrescity={"Cairo","Giza","Cairo","Elgharbia","Cairo"};//citiesarray

//declaring variables int agesi; int empage; String searchfor="Cairo"; System.out.println("******The Answers Of Q2, Q3 And Q4 :******"); for(agesi=0;agesi<ages.length;agesi++) { //any employee abpve 65 doesn't match any category if (ages[agesi]>65) System.out.println("Q4-"+"For "+ names[agesi]+"he is not an employee "); // for employees above or equal 40 salary increase by 2200 having 10 % as taxes else if (ages[agesi]>=40) {salary[agesi]=((salary[agesi]+2200)*0.9); System.out.println("Q2-"+"For "+ names[agesi]+" the new salary is : "+salary[agesi]); } //any employee above 39 doesn't match with having 40 criteria already specified else if(ages[agesi] > 39) System.out.println("Q4-"+"For "+ names[agesi]+"he is not an employee "); // for employees above or equal 20 salary increase by 1100 having 20 % as taxes else if (ages[agesi]>=20) {salary[agesi]=((salary[agesi]+1100)*0.8); System.out.println("Q3-"+"For "+ names[agesi]+" the new salary is : "+salary[agesi]); } }

//end of if statment System.out.println(" ");System.out.println("******The Answer Of Q5 :******");for(agesi=0;agesi<adrescity.length;agesi++){if (adrescity[agesi]=="Cairo") System.out.println("This employees lives in cairo :"+names[agesi]);} }}

Page 137: Java first Session

Java Programming

Test Assignment 3

Create an automated cashier application - for ordering and paying for Chinese food from a standard menu.

The application should contain 5 classes as follows (the following coding procedures can be changed):

1. Create a package called “ChineseFood” to put the classes inside it

2. An abstract superclass called “Items” containing:

a) the general attributes for any food item: name, serial number

b) constructor

c) concrete methods to set & return the name, serial number and food item object

d) abstract method to calculate the price of any chosen food item

3. A subclass called “Food” containing:

a) attribute for number of orders required by customer

b) a single dimensional array containing number of side dishes in each order taken from

customer

c) two single dimensional arrays as follows (acting as a menu) showing price of an order with

different numbers of side dishes

Number of side

dishes

1 2 3 4

Serial number F01 F02 F03 F04

price 15.99LE 20.99LE 25.99LE 30.99LE

d) constructor

e) methods to set and get number of orders required by customer and number of side orders in

each order(hint: this info should be taken from customer in an array), method to calculate

total price of number of orders (by searching in both arrays for number of required side

dishes for each order and their prices), and method to represent the food object item

4. A subclass called “Beverages” containing:

a) attribute for number of drink orders required by customer

b) a single dimensional array containing type of beverage in each order taken from customer

c) two single dimensional arrays as follows (acting as a menu) showing price of each type of

beverage

Type of

beverage

Fizzy (e.g. cola) Juice Water Milkshake

Serial number B01 B02 B03 B04

price 3.99LE 5.99LE 2.99LE 6.99LE

d) constructor

Page 138: Java first Session

e) methods to set and get number of orders required by customer and type of beverage in each

order, method to calculate total price of number of orders (by searching in both arrays for

type of beverage for each order and their prices), and method to represent the beverage

object item

5. A subclass called “Desserts” containing:

a) attribute for number of dessert orders required by customer

b) a single dimensional array containing type of dessert in each order taken from customer

c) two single dimensional arrays as follows (acting as a menu) showing price of each type of

dessert

Type of dessert Apple pie Cake Cookie Ice cream

Serial number D01 D02 D03 D04

price 5.99LE 6.99LE 3.99LE 2.99LE

d) constructor

e) methods to set and get number of orders required by customer and type of dessert in each

order, method to calculate total price of number of orders (by searching in both arrays for

type of beverage for each order and their prices), and method to represent the beverage

object item

6. A class containing the business logic as follows:

a) Give the user a dialog box asking if he wants to order food, beverage or dessert

b) Whichever he chooses, make another dialog box appear asking him how many orders

c) Then make a dialog box appear for each order which allows him to choose the type of

food/beverage/dessert he wants

d) When these are finished give him another dialog box asking if he wants to order any more

items

e) If he says yes go back to point a) again and repeat the whole procedure. If he says no output

a message box containing the name / serial number / type of each order / its price. At the

very end of the message box show the total price of all the orders together obtained from:

f) Create a method to get the total orders’ prices returned from all the other classes and add

them all up

N.B. marks will be allocated for

• suitable names of variables, methods

• proper organization of coding and

• adding comments

Good Luck

Page 139: Java first Session

what does java virtual machine do how to write an interface and abstract class - public or private methods ? why package, import, main method and methods why use constructor why use layouts, give me an example how create an array, what positions exist in it difference between 0 and null difference between = , == and .equals difference between x+(++y) and x+(y++) what is *, /, %, &&, ||, ! can we use % with double what does this mean z= x>y? 1: 10 difference between break; continue; return; and break() continue() return() switch must have default case and break? can you instantiate an object from abstract and interface classes? can you have a constructor in abstract and interface classes? a subclass of an abstract class must define its methods? characteristics of an array input arguments are passed to methods by reference or value meaning of public/private/protected/no access modifier/final/static what are keywords, case sensitive extend and implement how many classes (multiple inheritance) what is overriding, overloading, polymorphism (methods with same name in same class and superclass) idea of IF statement examples of code: arrays / for loops (nested) / while, continue , break / =,==,++, % / types of variables / simple casting / &&, || / unreachable, non logic code