java i lecture_3


Chapter 3

Introduction to Java Applets


• There is no main method in a Java Applet.

• A Java Applet can only run in a browser.

• An Applet is run only when an HTML page requests that it be executed.

• In place of a browser, we use a utility called the

appletviewerThis is a “minimal browser”—it ignores all other HTML commands except the one used to run an Applet.

Applets Execute in a Browser


appletviewer syntax.

• To execute an Applet, do the following:Compile your Java Applet using javac, as usual.

C:\ javac Hello.java

Create an HTML file and name it: Example.html


<HTML><APPLET CODE=“Hello.class” WIDTH=300 HEIGHT=40></APPLET></HTML>

To run the Applet, you type the following:

C:\ appletviewer Example.html

These parameters refer to the width and height (in pixels) of the box your Appletwill get when it is executed on a web page.

w


Writing A “String” (A Sentence) using an Applet

• Because an Applet gets help from a browser, it contains much less code.

• The most obvious omission is the main method.

A Simple Applet


• Every Java Applet must commence by importing the class JApplet.

• This class does all the heavy lifting for us.

A Simple Applet// A First Appletimport javax.swing.JApplet; import java.awt.Graphics;



• We are also importing class Graphics from the awt (Abstract Windowing Tools) package so that we can draw the String on the Applet.


• All code in an Applet sits in the wrapper of a class.

• Likewise, the class name starts with a Capital

• The public keyword enables the browser to create an instance of this class—what we have to do by ourselves in an Application.


public class WelcomeApplet extends JApplet{

}


• Take special note of the “extends” keyword. • extends means that our WelcomeApplet is

building on top of another class, JApplet !• We’re taking everything it has, and adding to it !



}

This is Inheritance—a very special principle—and there are special terms to describe the relationship.

Superclass (base class) JApplet

Subclass (derived class) WelcomeApplet

w


• Now we have added a method called paint.• Notice its Access Modifier is public, so this method can be called by any object outside of this class.• The return value is void.



public void paint( Graphics g ){

}}


• Apparently, the paint method of JApplet expects to be passed an object of type Graphics.• We are instantiating (creating) a Graphics class object called g right there, inside the parenthesis of paint.



public void paint( Graphics g ){ }

}

Don’t get nervous. When you created an integer variable ( int x; char m; ) you were doing

the same thing, “Creating a instance of a type.”“ Graphics g ” is creating an example or

instance of Graphics class and naming that instance g.

w


• Finally, with this statement, we use the Graphics class object g, and call the method drawString that all Graphics class objects have.• drawString expects a String, plus two coordinates that say where to place the bottom-left corner of the text.



public void paint( Graphics g ){ g.drawString( “Welcome to Java!”, 25, 25 );}

}


• Class JApplet already has a method called paint. Class JApplet’s paint method is empty. It does nothing. • Although we did inherit the do-nothing method paint from JApplet, ours will do something.• We are overriding the method paint that we inherited.



public void paint( Graphics g ){ g.drawString( “Welcome to Java!”, 25, 25 );}

}


Overriding a method

• This process is central to inheritance.

• Although we received a perfectly good method from the Superclass, we decided to create our own version of it—with the exact same name.

• Since we used the same name, our version of the method takes over or overrides the method.

• We haven’t affected the original copy of the method—it still exists—we just improved upon it in our own special Subclass.



• You might have to resize the Applet. You set the dimensions of this box in your Example.html file.

• Note: When you resize the Applet, you trigger the paint method to fire.



• In an Application, the method main is guaranteed to be called by the operating system.

• In an Applet, which has no main method, three other methods are guaranteed to be called by the operating system:

init()

start()

paint()

( In that order )

More About Applets


• Since we did not override init()and start(),the default versions of these methods were executed.

• What did they do? Nothing!

• Only paint() did something because we overrode it and made it do something useful.

• Finally, anytime you resize an Applet (meaning drag the bottom right corner to make it bigger or smaller), then the method paint() is automatically called again.

More About Applets

init() start() paint()


• Attributes and Behaviors: All Objects have them.

• An Object in the real world has:

Attributes--its qualities, and itsBehaviors--what it does.

Thinking About Objects

Object: A balloon Attributes:Color: redDiameter: 2 inches Behaviors: RisesInflatesDeflatesPops


• Java is based on the unit of a class.A class is an object, it encapsulates the attributes and behaviors into one self-contained unit.

• The attributes (internal data variables) and behaviors (methods that have an effect on those internal data variables) are combined into a unit called an object.

Java encapsulates data (attributes) and methods (behavior)

into a unit called an Object.




• Some objects are Similar—Java Takes Advantage of the SimilaritiesA bicycle inner tube is a specific type of balloon.

It has a color and a width.It inflates, deflates and pops.

I cannot change the diameter of the balloon without using the method of inflating it.

Alone, I can’t change the diameter attribute of the inner tube. I have to use the method of inflating or deflating the inner tube to change its diameter attribute.

We say the width attribute is hidden. I can’t change it without using the method.


Thinking About Objects• An Employee is an Object

A Generic Employee has attributes:

name

address

phone_number

social_security_number

A Generic Employee has a method:

calculate_pay



An Hourly Employee is a specific kind of Employee.

It has the same Attributes as the Generic Employee, plus other Attributes:

hourly_pay_rate

overtime_hours

An Hourly Employee has the same method:

calculate_pay

but the calculation is different.

It uses hourly_pay_rate and overtime_hours.



A Salaried Employee is specific kind of Employee.

It has all the same Attributes as the Generic Employee, plus another Attribute:

salary

A Salaried Employee has the same method:

calculate_pay


It uses salary.



A Commission Employee is specific kind of Employee.

It has all the same Attributes as the Generic Employee, plus other Attributes:

base_pay

commission_rate

A Commission Employee has the same method:

calculate_pay


It uses base_pay and commission_rate.



A Piecework Employee is specific kind of Employee.

It has all the same Attributes as the Generic Employee, plus another Attribute:

pay_per_piece

A Piecework Employee has the same method:

calculate_pay


It uses pay_per_piece.


Thinking About Objects Inheritance

•The Hourly Employee, Salaried Employee, Commission Employee and Piecework Employee all...

Inherit the Attributes and Behaviors of the Generic Employee.

They elaborate on the stuff they inherited.

Any Superclass methods that are appropriate are NOT overridden.

Although they inherit from Generic Employee, the base is not changed.


• The Graphics class that drew the String on our previous Applet has many methods at our disposal.

• To the list of API classes we must know, we must now add Graphics and JApplet.

Draw A Line


• This will put lines above and below the sentence.

• The 4 arguments are the beginning and end points of the line.

Draw A Line// Display Text and Linesimport javax.swing.JApplet;import java.awt.Graphics;

public class WelcomeLines extends JApplet{


g.drawLine( 15, 10, 210, 10 );g.drawLine( 15, 30, 210, 30 );g.drawString( “Welcome to Java!”, 25,25);

}}


• This is the output.

Draw A Line


• This will produce the same result as we achieved with the Addition Application, only this time as an Applet.

• The goal is to add two floating-point numbers.

Applet Example: Addition


// Add two floating point numbersimport javax.swing.*;import java.awt.Graphics;

public class AdditionApplet extends JApplet{

double sum; // instance variable

public void init(){

}


}}

w

Notice, this variable sum is outside of any method.

sum is an instance variable.Numeric instance variables are automatically initialized to zero,

char instance variables areautomatically initialized to spaces

and boolean are automaticallyinitialized to false.

This asterisk allows you to import all the classes in a package.

( But only the classes at thisdirectory, not any sub-directories. )

Also, from that wildcard package, the compiler will

only bring in those classes thatyou actually used in the program.

Two Kinds of Java Variables:Instance variables:

• Declared outside of any method

• Automatically initialized

• Visible in all methods of the class

Local variables:• Declared inside a method

• Not automatically initialized—a syntax error if you

try to use them with out first putting a value in.

• Vanish after the method returns to whatever called it.





public void init(){

String firstNumber, secondNumber; // local variablesdouble num1, num2; // local variables

}


}}





public void init(){

String firstNumber, secondNumber;double num1, num2;

firstNumber = JOptionPane.showInputDialog(“First Num” );secondNumber = JOptionPane.showInputDialog(“Second Num” );num1 = Double.parseDouble( firstNumber );num2 = Double.parseDouble( secondNumber );

sum = num1 + num2;}


}}

Since num1 and num2 are doubles, we use the “Type Wrapper” class that can

convert a String into a double.( There are Type Wrapper classes for all

the primitive data types. )w





public void init(){

String firstNumber, secondNumber;double num1, num2;

firstNumber = JOptionPane.showInputDialog(“First Num” );secondNumber = JOptionPane.showInputDialog(“Second Num” );num1 = Double.parseDouble( firstNumber );num2 = Double.parseDouble( secondNumber );

sum = num1 + num2;}


g.drawRect( 15, 10, 270, 20 );g.drawString( “The Sum is ” + sum, 25, 25 );

}} • In drawRect, the parameters are the coordinates

for the top left-hand corner, the width and the height.


Applet Example: Addition Output


Another Word on Variables• Earlier, we discussed the so-called

primitive variables.

The are so named, because they are not objects.

For short, these are called just variables.

int num1; double sum;


Another Word on Variables

• There is another group—reference variables. These are objects.

String firstNumber;

String secondNumber;

The identifiers for these reference variables only contain references—that is, the address

where

this reference variable can be found in memory.


num100000000 00000000 00000000 00000132

• int num1 = 132; [Integers always take 4 bytes.]A primitive can only store one piece of data.

7045607 {This is the actual place in memory where the String Object stores everything it needs to

accomplish its task as a String Object. Inevitably, it would be a lot more than a simple primitive...

firstNumber00000000 00000000 07045607

A Reference is a

pointer !

• String firstNumber = JOptionPane.showMessageDialog

firstNumber is a reference (pointer) to the real Object.

An object can store many kinds of data.

java i lecture_3

Technology