Java I Lecture 3.pps

Java I--Copyright © 2000 Tom Hunter
Chapter 3
Introduction to Java Applets

Applets Execute in a Browser
• 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
appletviewer
This is a “minimal browser”—it ignores all other HTML
commands except the one used to run an Applet.

Applets Execute in a Browser w
appletviewer syntax.
These parameters refer to the width
• To execute an Applet, do the following:
and height
Compile (in Java
your pixels) of theusing
Applet box javac,
your Applet
as usual.
will get when it is executed on a web page.
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
A Simple Applet
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
// A First Applet
import javax.swing.JApplet;
import java.awt.Graphics;
• Every Java Applet must commence by importing the

class JApplet.
• This class does all the heavy lifting for us.
A Simple Applet
// A First Applet
• We are also importing class Graphics from the awt

(Abstract Windowing Tools) package so that we can draw
the String on the Applet.

A Simple Applet
// A First Applet
public class WelcomeApplet extends JApplet

{
• 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.
A Simple Applet w
// A First Applet

{
This is Inheritance—a very special principle—and
there are special terms to describe the relationship.
}
Superclass (base class) JApplet
• Take special
Subclass note ofclass)
(derived the “extends” keyword.
WelcomeApplet
• extends means that our WelcomeApplet is
building on top of another class, JApplet !
• We’re taking everything it has, and adding to it !
A Simple Applet
// A First Applet

{
public void paint( Graphics g )
{
}
}
• 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.
A Simple Applet w
// A First Applet

{
{
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 ofthe
• Apparently, Graphics
paintclass and of
method naming thatexpects
JApplet to g.
instance be
passed an object of type Graphics.
• We are instantiating (creating) a Graphics class object
called g right there, inside the parenthesis of paint.
A Simple Applet
// A First Applet

{
{
g.drawString( “Welcome to Java!”, 25, 25 );
}
}
• 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.
A Simple Applet
// A First Applet

{
{
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.
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.

More About Applets
• 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
init() start() paint()
• 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.
Thinking About Objects
• Attributes and Behaviors: All Objects have them.
• An Object in the real world has:
Object:
Attributes--its qualities, and its A balloon
Behaviors--what it does. Attributes:
Color: red
Diameter: 2 inch
Behaviors:
Rises
Inflates
Deflates
Pops
• 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 Similarities
A 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.
• 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.
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.
another Attribute:
pay_per_piece
A Piecework Employee has the same method:
calculate_pay
It uses pay_per_piece.

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.

Draw A Line
• 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
// Display Text and Lines
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 will put lines above and below the sentence.

• The 4 arguments are the beginning and end points of the
line.
Draw A Line
• This is the output.

Applet Example: Addition
• 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.

// Add two floating point numbers
Two Kinds of Java Variables:
import javax.swing.*;
Instance
public classvariables:
AdditionApplet extends JApplet
{
• Declared outside
double sum; of any
// instance method
variable
•{ Automatically initialized
public void init()
This asterisk allows you to
• Visible in all methods of the class
import all the classes in a package.
Local variables: Notice,
( But only thisthe classessum
variable is
at this
• Declared inside a method outside
directory, of any
not any method.
sub-directories. )
sum
Also,is from
an instance
that variable.
wildcard
•} Not automatically initialized—a syntax error if you
Numeric
package, instance variables
the compiler willare
try to
public void use Graphics
paint( them with
g ) out first
automatically putting a
initialized value
only bring in those classes that to in.
zero,
{
• Vanish after the method returns
youchar toused
whatever
instance
actually in thecalled
variables are it.
program.
}
} automatically initialized to spaces
and boolean are automatically
w initialized Java
toI--Copyright
false.© 2000 Tom Hunter
public class AdditionApplet extends JApplet

{
double sum; // instance variable
public void init()

{
String firstNumber, secondNumber; // local variables
double 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;

}
public void paint(Since

Graphics
num1g )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
w the primitive data types. )

{
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.

• int num1 = 132; [Integers always take 4 bytes.]
A primitive can only store one piece of data.
num1
00000000 00000000 00000000 00000132
A Reference
firstNumber is a
00000000 00000000 07045607
pointer !
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...
• 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.pps

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Java I Lecture 3.pps

Diunggah oleh

Hak Cipta:

Format Tersedia

Java I--Copyright © 2000 Tom Hunter

Java I--Copyright © 2000 Tom Hunter

Java I--Copyright © 2000 Tom Hunter

To run the Applet, you type the following:

Java I--Copyright © 2000 Tom Hunter

• Every Java Applet must commence by importing the

• We are also importing class Graphics from the awt

Java I--Copyright © 2000 Tom Hunter

public class WelcomeApplet extends JApplet

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

public class WelcomeApplet extends JApplet

public class WelcomeApplet extends JApplet

• Now we have added a method called paint.

public class WelcomeApplet extends JApplet

public class WelcomeApplet extends JApplet

• Finally, with this statement, we use the Graphics class

public class WelcomeApplet extends JApplet

• Class JApplet already has a method called paint.

Java I--Copyright © 2000 Tom Hunter

• You might have to resize the Applet. You set the

Java I--Copyright © 2000 Tom Hunter

Java I--Copyright © 2000 Tom Hunter

• Since we did not override init()and start(),

• What did they do? Nothing!

• Only paint() did something because we overrode it

• Finally, anytime you resize an Applet (meaning drag the

Java encapsulates data (attributes) and

A Generic Employee has attributes:

Java I--Copyright © 2000 Tom Hunter

It has the same Attributes as the Generic Employee,

Java I--Copyright © 2000 Tom Hunter

A Salaried Employee has the same method:

Java I--Copyright © 2000 Tom Hunter

Java I--Copyright © 2000 Tom Hunter

Java I--Copyright © 2000 Tom Hunter

Java I--Copyright © 2000 Tom Hunter

public class WelcomeLines extends JApplet

• This will put lines above and below the sentence.

• This is the output.

Java I--Copyright © 2000 Tom Hunter

• This will produce the same result as we achieved with

Java I--Copyright © 2000 Tom Hunter

public class AdditionApplet extends JApplet

public void init()

public void paint( Graphics g )

Java I--Copyright © 2000 Tom Hunter

public class AdditionApplet extends JApplet

public void init()

firstNumber = JOptionPane.showInputDialog(“First Num” );

sum = num1 + num2;

public void paint(Since

public class AdditionApplet extends JApplet

public void init()

firstNumber = JOptionPane.showInputDialog(“First Num” );

sum = num1 + num2;

public void paint( Graphics g )

Java I--Copyright © 2000 Tom Hunter

The are so named, because they are not objects.

For short, these are called just variables.

int num1; double sum;

Java I--Copyright © 2000 Tom Hunter

The identifiers for these reference variables only contain

this reference variable can be found in memory.