1. 1 1

2. 1 2 Chapter 3 Introduction to Java Applets

3. 1 3 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

4. 1 4 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 Applets Execute in a Browser 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 Applet will get when it is executed on a web page. w

5. 1 5 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

6. 1 6 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 import javax.swing.JApplet; import java.awt.Graphics;

7. 1 7 A Simple Applet // A First Applet import 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.

8. 1 8 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 // A First Applet import javax.swing.JApplet; import java.awt.Graphics; public class WelcomeApplet extends JApplet { }

9. 1 9 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 ! A Simple Applet // A First Applet import javax.swing.JApplet; import java.awt.Graphics; public class WelcomeApplet extends JApplet { } 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

10. 1 10 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 // A First Applet import javax.swing.JApplet; import java.awt.Graphics; public class WelcomeApplet extends JApplet { public void paint( Graphics g ) { }

11. 1 11 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. A Simple Applet // A First Applet import javax.swing.JApplet; import java.awt.Graphics; public class WelcomeApplet extends JApplet { 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

12. 1 12 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 import javax.swing.JApplet; import java.awt.Graphics; public class WelcomeApplet extends JApplet { public void paint( Graphics g ) { g.drawString( “Welcome to Java!”, 25, 25 ); }

13. 1 13 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. A Simple Applet // A First Applet import javax.swing.JApplet; import java.awt.Graphics; public class WelcomeApplet extends JApplet { public void paint( Graphics g ) { g.drawString( “Welcome to Java!”, 25, 25 ); }

14. 1 14 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. Applets Execute in a Browser

15. 1 15 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. Applets Execute in a Browser

16. 1 16 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

17. 1 17 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()

18. 1 18 Attributes and Behaviors: All Objects have them. An Object in the real world has: Attributes--its qualities, and its Behaviors--what it does. Thinking About Objects Object: A balloon Attributes: Color: red Diameter: 2 inches Behaviors: Rises Inflates Deflates Pops

19. 1 19 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. Thinking About Objects

20. 1 20 Thinking About Objects 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.

21. 1 21 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

22. 1 22 Thinking About Objects An Employee is an Object 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.

23. 1 23 Thinking About Objects An Employee is an Object 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 but the calculation is different. It uses salary.

24. 1 24 Thinking About Objects An Employee is an Object 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 but the calculation is different. It uses base_pay and commission_rate.

25. 1 25 Thinking About Objects An Employee is an Object 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 but the calculation is different. It uses pay_per_piece.

26. 1 26 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.

27. 1 27 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

28. 1 28 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 Lines import javax.swing.JApplet; import java.awt.Graphics; public class WelcomeLines extends JApplet { public void paint( Graphics g ) { g.drawLine( 15, 10, 210, 10 ); g.drawLine( 15, 30, 210, 30 ); g.drawString( “Welcome to Java!”, 25,25); }

29. 1 29 This is the output. Draw A Line

30. 1 30 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

31. 1 31 // Add two floating point numbers import javax.swing.*; import java.awt.Graphics; public class AdditionApplet extends JApplet { double sum; // instance variable public void init() { } public void paint( Graphics g ) { } 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 are automatically initialized to spaces and boolean are automatically initialized to false. This asterisk allows you to import all the classes in a package. ( But only the classes at this directory, not any sub-directories. ) Also, from that wildcard package, the compiler will only bring in those classes that you 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.

32. 1 32 // Add two floating point numbers import javax.swing.*; import java.awt.Graphics; public class AdditionApplet extends JApplet { double sum; // instance variable public void init() { String firstNumber, secondNumber; // local variables double num1, num2; // local variables } public void paint( Graphics g ) { }

33. 1 33 // Add two floating point numbers import javax.swing.*; import java.awt.Graphics; public class AdditionApplet extends JApplet { double sum; // instance variable 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( Graphics g ) { } 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

34. 1 34 // Add two floating point numbers import javax.swing.*; import java.awt.Graphics; public class AdditionApplet extends JApplet { double sum; // instance variable 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( Graphics g ) { 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.

35. 1 35 Applet Example: AdditionOutput

36. 1 36 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;

37. 1 37 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.

38. 1 38 num1 00000000 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... firstNumber 00000000 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.