1 / 64

Java I

Java I. Chapter 6 Methods: Part II. Math Class Methods. • Found in java.lang.Math • Automatically imported. • sqrt() is a “static” method. Math . sqrt( 900.0 ). 30.0 = Math . sqrt( 900.0 ). Type double. Math Class Methods. • Work from the Inside Out

groleau
Download Presentation

Java I

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Java I

  2. Chapter 6 Methods: Part II

  3. Math Class Methods • Found in java.lang.Math • Automatically imported. • sqrt() is a “static” method. Math.sqrt( 900.0 ) 30.0 = Math.sqrt( 900.0 ) Type double

  4. Math Class Methods • Work from the Inside Out • First Math.sqrt() is performed. System.out.println( Math.sqrt( 900.0 ) ); System.out.println( 30.0 ); • The return value of Math.sqrt is the argument for the println method.

  5. Math Class Methods • You can never make an instance of the Math object—because it was declared final. • For the sake of Contrast: Container c; c.add(“Calling A Method”); Making an instance of the Container class. This instance is called “c”. “c” is the “reference” to this object. Now, this instance will call its method add()

  6. Math Class Methods • You can’t create a Math instance. Math m; No !

  7. Math Class Methods • All the methods in the Math class are declared static--which means they belong to the class. • When we declare a method static, it means we don’t need to instantiate the class to call the method.

  8. Math Class Methods • Review all the ways to call a method: A Method Name All by itself, such as d = square( x ); • We don’t refer to the object where this method originates.

  9. Math Class Methods • Review all the ways to call a method: A Reference to an object we have instantiated followed by the dot . operator and the method name: MyClass w w.myMethod()

  10. Math Class Methods • Review all the ways to call a method: A class name followed by a method: Integer.parseInt() This is only used for static methods that belong to the class.

  11. More About Methods • Recall the all variables declared inside a method are local variables. • Local variables must be initialized. • They live only while the method is being executed. • Local variables vanish after the method is done.

  12. More About Methods • In this example, all three variables are local. The variables x and y declared as parameters in the method signature, and the variable sum declared in the body of the method. public double sum( double x, double y) { double sum = 0; sum = x + y; return sum; }

  13. Methods: Duration of Identifiers • The duration of an identifier is the lifetime of the identifier. • Identifiers declared locally in a method are called local variable. (They are also known as automatic variable). • Automatic (local) variables exist only while the block they are declared in executes. • Static variables exist from the time the class that defines them is loaded into memory until the program terminates.

  14. Methods: Scope Rules • The scope for an identifier is the portion of the program in which the identifier can be referenced. • The scopes for an identifier are: • class • block • method

  15. Method Overloading • Method overloading allows a method name to be re-used. • To overload a method--or to create another version of a method that already exists--the argument lists for the methods must differ in: • number of arguments • type of arguments • order of arguments • The return type of the method is NOT considered.

  16. Event Delegation Model

  17. Event Delegation Model • Unlike many other languages--such as Visual Basic--when the Java programmer wishes to program responses to an event--such as the enter key being pressed, the event must be entirely programmed.

  18. Event Delegation Model • Consider this analogy to the event model: > Fred decides he wants a bodyguard. > Somebody punches Fred--that’s a problem. > Vinnie--the bodyguard--notices Fred was punched. > Vinnie reacts to the problem.

  19. Event Delegation Model • The same thing with specifics attached: > A Button decides it wants an ActionListener. > A Button is pressed--an event happens: > The ActionListener notices the Button was pressed. > The Listener reacts to the event.

  20. Event Delegation Model • Fully described in Java Terms > A Button adds an ActionListener. > A Button is pressed--an event happens: > The method actionPerformed is executed, receiving an ActionEvent object. > The Listener reacts to the event.

  21. Event Delegation Model Event Sources transmit ActionEvent objects to Event Listener(s).

  22. Event Delegation Model: Summarized • An event source is an object that can register listener*objects and send those listenersevent objects. • In practice, the event source can send out event objects to all registered listeners when that event occurs. • The listener object(s) will then use the details in the event object to decide how to react to the event. * A “Listener Object” [an instance of a class] implements a special interface called a “listener interface.”

  23. Event Delegation Model • When you ask the listener object to pay attention to your event source, that is called registering the listener object with the source object. • You do that with the following lines of code: eventSourceObject.addEventListener( eventListenerObject );

  24. Event Delegation Model MyPanel panel = new MyPanel(); JButton button = new JButton( “Clear” ); button.addActionListener( panel ); • Now, the panel object is notified whenever an “action event” occurs in the button. • When you click on a button, the panel object hears about it.

  25. Event Delegation Model MyPanelpanel = new MyPanel(); JButton button = new JButton( “Clear” ); button.addActionListener( panel ); • Code like this requires that the class the panel comes from to implement the appropriate interface. • In this case, class MyPanel must implement the ActionListenerinterface.

  26. Event Delegation Model MyPanelpanel = new MyPanel(); JButton button = new JButton( “Clear” ); button.addActionListener( panel ); • To implement the ActionListenerinterface, the listener class must have a method called actionPerformed( ActionEvente ) that receives an ActionEvent object as a parameter.

  27. Event Delegation Model public class MyPanel extends JPanel implement ActionListener { public void actionPerformed( ActionEvent e ) { // appropriate code to react to event // goes here. } } • Whenever the user clicks thebutton, theJButtonobject creates anActionEventobject and callspanel.actionPerformed, passing that event object.

  28. Event Delegation Model: Which Button Was Clicked? • A closer look at the object that is passed, the ActionEvent object: • The method getSource() will tell us which object created and sent the ActionEvent object.

  29. Event Delegation Model: Which Button Was Clicked? • Responding to a button: We start with a panel and some buttons on it. • A listener object ( namely, the panel itself ) registers itself with the buttons so that it can listen to them. public void actionPerformed( ActionEvente ) { if ( e.getSource() == button ) ... }

  30. Every event handler requires 3 bits of code: 1. Code that says the class implements a listener interface: public class MyClass implements ActionListener 2.Code that registers a listener on one or more components. someComponent.addActionListener( MyClass ); 3.Code that implements the methods in the listener interface. public void actionPerformed(ActionEvent e) { ...//code that reacts to the action... }

  31. Event Delegation Model: Another Example • In code, this is how you react to an event: JButton roll = new JButton( “Roll Dice” ); roll.addActionListener( this ); // call method play when button is pressed. Public void actionPerformed( ActionEvente ) { do something } • When the JButton roll is clicked, the method actionPerformed receives an ActionEvent object that tells it the details of the event.

  32. import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Craps extends JApplet implements ActionListener { final int WON = 0, LOST = 1, CONTINUE = 2; boolean firstRoll = true; int sumOfDice = 0; int myPoint = 0; int gameStatus = CONTINUE; // GUI components. JLabel die1Label, die2Label, sumLabel, pointLabel; JTextField firstDie, secondDie, sum, point; JButton roll;

  33. import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Craps extends JApplet implements ActionListener { final int WON = 0, LOST = 1, CONTINUE = 2; boolean firstRoll = true; int sumOfDice = 0; int myPoint = 0; int gameStatus = CONTINUE; // GUI components. JLabel die1Label, die2Label, sumLabel, pointLabel; JTextField firstDie, secondDie, sum, point; JButton roll; First, to respond to events, we must import the event class API: java.awt.event.*;

  34. import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Craps extends JApplet implementsActionListener { final int WON = 0, LOST = 1, CONTINUE = 2; boolean firstRoll = true; int sumOfDice = 0; int myPoint = 0; int gameStatus = CONTINUE; // GUI components. JLabel die1Label, die2Label, sumLabel, pointLabel; JTextField firstDie, secondDie, sum, point; JButton roll;

  35. import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Craps extends JApplet implementsActionListener { final int WON = 0, LOST = 1, CONTINUE = 2; boolean firstRoll = true; int sumOfDice = 0; int myPoint = 0; int gameStatus = CONTINUE; // GUI components. JLabel die1Label, die2Label, sumLabel, pointLabel; JTextField firstDie, secondDie, sum, point; JButton roll; This is the first time we have seen a class that “implements” another class. This is called an interface. You see, although we are directly inheriting from the class JApplet, we are getting some functions through the interface from the class ActionListener. We will learn more about interfaces later.

  36. import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Craps extends JApplet implements ActionListener { final int WON = 0, LOST = 1, CONTINUE = 2; boolean firstRoll = true; int sumOfDice = 0; int myPoint = 0; int gameStatus = CONTINUE; // GUI components. JLabel die1Label, die2Label, sumLabel, pointLabel; JTextField firstDie, secondDie, sum, point; JButton roll;

  37. import java.awt.*; import java.awt.event.*; import javax.swing.*; public class Craps extends JApplet implements ActionListener { final int WON = 0, LOST = 1, CONTINUE = 2; boolean firstRoll = true; int sumOfDice = 0; int myPoint = 0; int gameStatus = CONTINUE; // GUI components. JLabel die1Label, die2Label, sumLabel, pointLabel; JTextField firstDie, secondDie, sum, point; JButton roll; Here are 3 different kinds of GUI “components.” Remember, a component is something we place on the content pane.

  38. // Setup graphical user interface components public void init() { Containerc = getContentPane(); c.setLayout(new FlowLayout() ); die1Label = new JLabel( "Die 1" ); c.add( die1Label ); firstDie = new JTextField( 10 ); firstDie.setEditable( true ); c.add( firstDie ); roll = new JButton( "Roll Dice" ); roll.addActionListener( this ); c.add( roll ); } // end of method init()

  39. // Setup graphical user interface components public void init() { Containerc = getContentPane(); c.setLayout(new FlowLayout() ); die1Label = new JLabel( "Die 1" ); c.add( die1Label ); firstDie = new JTextField( 10 ); firstDie.setEditable( true ); c.add( firstDie ); roll = new JButton( "Roll Dice" ); roll.addActionListener( this ); c.add( roll ); } // end of method init() c is a Container object that came from the Content Pane. Here, we are setting the Layout, or how the objects get stacked on the page. There are many different choices for layouts. We will discuss them later.

  40. // Setup graphical user interface components public void init() { Container c = getContentPane(); c.setLayout(new FlowLayout() ); die1Label = new JLabel( "Die 1" ); c.add( die1Label ); firstDie = new JTextField( 10 ); firstDie.setEditable( true ); c.add( firstDie ); roll = new JButton( "Roll Dice" ); roll.addActionListener( this ); c.add( roll ); } // end of method init()

  41. Earlier, we declared these JLabels and now we’re defining them. Then, we see how the Containerc is using its method “add” to add the JLabels object die1Label to its content pane. // Setup graphical user interface components public void init() { Container c = getContentPane(); c.setLayout(new FlowLayout() ); die1Label = new JLabel( "Die 1" ); c.add( die1Label ); firstDie = new JTextField( 10 ); firstDie.setEditable( true ); c.add( firstDie ); roll = new JButton( "Roll Dice" ); roll.addActionListener( this ); c.add( roll ); } // end of method init()

  42. // Setup graphical user interface components public void init() { Container c = getContentPane(); c.setLayout(new FlowLayout() ); die1Label = new JLabel( "Die 1" ); c.add( die1Label ); firstDie = new JTextField( 10 ); firstDie.setEditable( true ); c.add( firstDie ); roll = new JButton( "Roll Dice" ); roll.addActionListener( this ); c.add( roll ); } // end of method init()

  43. Below, you see how we have defined a new JButton called “roll”. Then, we register an Action Listener on the button roll. We want our same JApplet--the one we are inside of now--to listen to for the events. To say that, we use the “this” reference below. It means “this” JApplet will listen for events that happen to the JButton “roll”. This is called “registering an Action Listener”. // Setup graphical user interface components public void init() { Container c = getContentPane(); c.setLayout(new FlowLayout() ); die1Label = new JLabel( "Die 1" ); c.add( die1Label ); firstDie = new JTextField( 10 ); firstDie.setEditable( true ); c.add( firstDie ); roll = new JButton( "Roll Dice" ); roll.addActionListener( this ); c.add( roll ); } // end of method init()

  44. • So, when an event happens to our button--because of the ActionListener--the following method is performed. It receives an ActionEvent object. • In our example, this method just calls another method, play() // call method play when button is pressed. public void actionPerformed( ActionEvente ) { play(); }

  45. // process one roll of the dice. public void play() { if( firstRoll ) { sumOfDice = rollDice(); switch( sumOfDice ) { case 7: case 11: gameStatus = WON; point.setText( "" ); break; case 2: case 3: case 12: gameStatus = LOST; point.setText( "" ); break; } // end of switch } //end of true if block else { sumOfDice = rollDice(); if( sumOfDice == myPoint ) gameStatus = WON; else This method decides what to do when the event happens.

  46. Interfaces • When we said our program: implements ActionListener it was implementing a thing called an interface. If you want to implement the interface ActionListener, it means that you must define a method called: public void actionPerformed( ActionEvent e ) in your class. (More about Interfaces later…)

  47. Layout Managers • Recall that you use the getContentPane() method as a starting point when you want to place components on a GUI. • After that, how are your GUI components organized on the window? • The Layout Manager controls how this happens. A Layout Manager determines the position and size of every GUI component attached to a Container.

  48. Layout Managers • Flow Layout is the most basic. It places the objects one after another, top to bottom, left to right, on the Container.

  49. Layout Managers • This is the same Applet as on the previous slide. It has only be resized to a different shape.

  50. Recursion • For any programming problem, there are usually two alternative ways to solve it: --iteration and --recursion • Iteration means repeating the same thing a certain number of times until the solution is achieved. • Recursion means having a method call itself. Or rather, it’s better to think that it calls another copy of itself.

More Related