1 / 45

Lecture 2

Lecture 2. Calling and Defining Methods in Java. Introduction. Calling and defining methods Declaring and defining a class Instances of a class The this keyword. 1 of 43. Meet samBot (kudos to Sam Squires). samBot is a robot who lives in a 2D grid world

nicholas-schneider
Download Presentation

Lecture 2

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. Lecture 2 Calling and Defining Methods in Java

  2. Introduction • Calling and defining methods • Declaring and defining a class • Instances of a class • The this keyword 1 of 43

  3. Meet samBot (kudos to Sam Squires) • samBotis a robot who lives in a 2D grid world • She knows how to do two things: • move forward any number of steps • turn right 90 degrees 2 of 43

  4. Meet samBot • The TAs created samBotfrom a Robot blueprint they wrote as part of her program • We will learn how to communicate with samBotusing Java 3 of 43

  5. samBot’sWorld • This is samBot’sworld • samBotstarts in the square at (0,0) • She wants to get to the square at (1,1) • Thick black lines are walls that samBotcan’t pass through 0 1 2 3 4 0 1 2 4 of 43

  6. Giving Instructions • Goal: to move samBotfrom her starting position to her destination by giving her a list of instructions • samBotonly knows instructions “move forward n steps” and “turn right” • What instructions to give her? 0 1 2 3 4 0 1 2 5 of 43

  7. Giving Instructions • “Move forward 4 steps.” 0 1 2 3 4 • “Turn right.” 0 • “Move forward 1 step.” 1 • “Turn right.” 2 • “Move forward 3 steps.” Note samBot moves in the direction her outstretched arm is pointing; yes, she can move upside down in this 2D world… 6 of 43

  8. Giving Instructions • Have to give samBotthese instructions in a language she understands • That’s where Java comes in! • In Java, give instructions to an object by sending it messages 0 1 2 3 4 0 1 2 7 of 43

  9. “Calling Methods”: Sending Messages in Java • The messages that samBotknows how to respond to are called methods • “method” is short for “method for responding to a message” • objects cooperate by sending each other messages • Object sending message is caller • Object receiving message is receiver 8 of 43

  10. “Calling Methods”: Sending Messages in Java • samBothas one method for “move forward n steps” and another method for “turn right” • When we send a message to samBotto “move forward” or “turn right” in Java, we are calling a methodon samBot Hey samBot, turn right! The method call (message passed from caller to receiver) The caller The receiver (samBot) 9 of 43

  11. Moving samBotforward • When tell samBot to move forward, need to tell herhow many steps to move • samBot’s “move forward” method is named moveForward • To call this method in Java: • samBot.moveForward(<number of steps>); You substitute for anything in < >! • This means that if want herto move forward 2 steps, say: samBot.moveForward(2); ; ends Java statement 10 of 43

  12. Turning samBotright • samBot’s “turn right” method is called turnRight • To call the turnRight method on samBot: • samBot.turnRight(); • To call methods on samBotin Java, need to address her by name! Every command to samBottakes the form: • samBot.<method name>; 11 of 43

  13. Calling Methods: Important Points • Method calls in Java have parentheses after the method’s name • If the method needs any information, include it between parentheses (e.g. samBot.moveForward(2);) • If no extra information is needed, just leave the parentheses empty (e.g. samBot.turnRight();) • Extra pieces of information passed to a method are called parameters. More on them next lecture 12 of 43

  14. Guiding samBotin Java • Tell samBotto move forward 4 steps → samBot.moveForward(4); • Tell samBotto turn right → samBot.turnRight(); • Tell samBotto move forward 1 step → samBot.moveForward(1); • Tell samBotto turn right → samBot.turnRight(); • Tell samBotto move forward 3 steps → samBot.moveForward(3); 0 1 2 3 4 “pseudocode” Java code 0 1 2 13 of 43

  15. Hand Simulation of This Code samBot.moveForward(4); samBot.turnRight(); samBot.moveForward(1); samBot.turnRight(); samBot.moveForward(3); 0 1 2 3 4 0 1 2 14 of 43

  16. Putting Code Fragment in a Real Program public class RobotMover { /* additional code elided */ public void moveRobot(Robot samBot) { samBot.moveForward(4); samBot.turnRight(); samBot.moveForward(1); samBot.turnRight(); samBot.moveForward(3); } } • Let’s demonstrate this code for real • First, need to put it inside real Java program • Grayed-out code specifies context in which samBotexecutes these instructions • It is part of the stencil code that has been written for you by the TAs • the TAs have also given samBotthe capability to respond to moveForward and turnRight−more on this later 15 of 43

  17. Demo in our Interactive Development Environment, Eclipse 16 of 43

  18. A variation: public class RobotMover { /* additional code elided */ public void moveRobot(Robot samBot) { // Your code goes here! // … // … // … // … // … // … // … // … // … // … // … // … // … } } 0 1 2 3 4 0 1 2 17 of 43

  19. A variation: public class RobotMover { /* additional code elided */ public void moveRobot(Robot samBot) { samBot.turnRight(); samBot.moveForward(2); samBot.turnRight(); samBot.turnRight(); samBot.turnRight(); samBot.moveForward(3); samBot.turnRight(); samBot.turnRight(); samBot.turnRight(); samBot.moveForward(2); samBot.turnRight(); samBot.turnRight(); samBot.turnRight(); samBot.moveForward(2); } } 0 1 2 3 4 0 1 2 18 of 43

  20. A variation: public class RobotMover { /* additional code elided */ public void moveRobot(Robot samBot) { samBot.turnRight(); samBot.moveForward(2); samBot.turnRight(); samBot.turnRight(); samBot.turnRight(); samBot.moveForward(3); samBot.turnRight(); samBot.turnRight(); samBot.turnRight(); samBot.moveForward(2); samBot.turnRight(); samBot.turnRight(); samBot.turnRight(); samBot.moveForward(2); } } • Lots of code for a simple problem... • samBotonly knows how to turn right, so have to call turnRightthree times to make her turn left • If she understood how to “turn left”, would be much simpler! • We can teach samBotto turn left by defining a method called turnLeft • But before we start defining methods, we need to learn a bit about classes. 19 of 43

  21. What is a class? • A class is a blueprint for a certain type of object • An object’s class defines its properties and capabilities (methods) • So far, we’ve been working within the class RobotMover • This is the code for our original problem public class RobotMover{ /* additional code elided */ public void moveRobot(Robot samBot) { samBot.moveForward(4); samBot.turnRight(); samBot.moveForward(1); samBot.turnRight(); samBot.moveForward(3); } } 20 of 43

  22. Declaring and then Defining a Class • As with dictionary entry, first declare term, then provide definition • First line declaresRobotMoverclass • public and class are Java “reserved words” • Breaking it down: • public indicates that anyone can use this class • class indicates to Java that we are about to define a new class • RobotMover is the name that we have chosen for our class public class RobotMover{ /* additional code elided */ public void moveRobot(Robot samBot) { samBot.moveForward(4); samBot.turnRight(); samBot.moveForward(1); samBot.turnRight(); samBot.moveForward(3); } } 21 of 43

  23. Declaring and then Defining a Class declaration of the RobotMover class • Classes take the form: • <visibility> class <name> { • <code that defines class> • } public class RobotMover{ /* additional code elided */ public void moveRobot(Robot samBot) { samBot.moveForward(4); samBot.turnRight(); samBot.moveForward(1); samBot.turnRight(); samBot.moveForward(3); } } declaration • Each class goes in its own file, where name of file matches name of class • RobotMover class is contained in file “RobotMover.java” 22 of 43

  24. Declaring and then Defining a Class public class RobotMover { /* additional code elided */ public void moveRobot(Robot samBot) { samBot.moveForward(4); samBot.turnRight(); samBot.moveForward(1); samBot.turnRight(); samBot.moveForward(3); } } • class definition defines properties and capabilities of class • Class definition (aka “body”) is contained within curly braces that follow class declaration • A class’s capabilities are defined by its methods • A class’s properties are defined by its instance variables - more on this next week definition of the RobotMover class 23 of 43

  25. Classes and Instances • We’ve been saying samBotis a Robot • We’ll now refer to her as an instance of class Robot • This means samBotis a particular Robotbuilt using Robotclass as a blueprint • Everything samBotcan do is spelled out in Robot class • All Robots (all instances of the class Robot) have the exact same capabilities: the methods defined in the Robot class 24 of 43

  26. Classes and Instances The Robot class is like a blueprint 25 of 43

  27. Classes and Instances We can use the Robot class to build actual Robots- instances of the class Robot 26 of 43

  28. Classes and Instances instance instance instance instance 27 of 43

  29. The Robot class public class Robot { public void turnRight() { // code that turns robot right } public void moveForward(int numberOfSteps) { // code that moves robot forward } /* other code elided-- if you’re curious,check out Robot.java in the stencil code!*/ } • public class Robotdeclares that we are about to define a class called Robot 28 of 43

  30. The Robot class • Information about the properties and capabilities of Robots (the class definition) goes within these curly braces public class Robot { public void turnRight() { // code that turns robot right } public void moveForward(int numberOfSteps) { // code that moves robot forward } /* other code elided-- if you’re curious,check out Robot.java in the stencil code!*/ } 29 of 43

  31. Methods of the Robot class • public void turnRight() and public void moveForward(intnumberOfSteps)each declare a method • Since moveForwardneeds to know how many steps to move, we put intnumberOfStepswithin the parentheses • This is called a parameter- more on this next lecture; int is Java’s way of saying “integer” public class Robot{ public void turnRight() { // code that turns robot right } public void moveForward(int numberOfSteps) { // code that moves robot forward } /* other code elided-- if you’re curious,check out Robot.java in the stencil code!*/ } 30 of 43

  32. Methods of the Robot class • Almost all methods take on this general form: • <visibility> <type> <name>(<parameters>) { • <list of statements within method> • } public class Robot{ public void turnRight() { // code that turns robot right } public void moveForward(int numberOfSteps) { // code that moves robot forward } /* other code elided-- if you’re curious, check out Robot.java in the stencil code!*/ } 31 of 43

  33. Methods of the Robot class • When we callturnRightor moveForward, all code between method’s curly braces is executed public class Robot{ public void turnRight() { // code that turns robot right } public void moveForward(int numberOfSteps) { // code that moves robot forward } /* other code elided-- if you’re curious,check out Robot.java in the stencil code!*/ } 32 of 43

  34. Defining our own method • Let’s add a new method: turnLeft • To make a Robot turn left, tell her to turn right three times public class Robot{ public void turnRight() { // code that turns robot right } public void moveForward(int numberOfSteps) { // code that moves robot forward } public void turnLeft() { // our code goes here! } } 33 of 43

  35. The thiskeyword • When working with RobotMover, we were talking to samBot, an instance of class Robot • To tell her to turn right, we said “samBot.turnRight();” • Why do we now write “this.turnRight();”? public class Robot{ public void turnRight() { // code that turns robot right } public void moveForward(int numberOfSteps) { // code that moves robot forward } public void turnLeft() { this.turnRight(); this.turnRight(); this.turnRight(); } } 34 of 43

  36. The thiskeyword • The this keyword is how an instance (like samBot) can call a method on itself • Use thisto call a method of Robot class from within another method of Robotclass • When samBot is told by, say, RobotMoverto turnLeft, she responds by telling herself to turnRightthree times • this.turnRight(); means “hey me, turn right!” public class Robot{ public void turnRight() { // code that turns robot right } public void moveForward(int numberOfSteps) { // code that moves robot forward } public void turnLeft() { this.turnRight(); this.turnRight(); this.turnRight(); } } 35 of 43

  37. We’re done! • We just defined our first method! • Now that the Robot class has the method turnLeft, we can call turnLeft on any instance of Robot public class Robot{ public void turnRight() { // code that turns robot right } public void moveForward(int numberOfSteps) { // code that moves robot forward } public void turnLeft() { this.turnRight(); this.turnRight(); this.turnRight(); } } 36 of 43

  38. Simplifying our code using turnLeft public class RobotMover { public void moveRobot(Robot samBot) { samBot.turnRight(); samBot.moveForward(2); samBot.turnRight(); samBot.turnRight(); samBot.turnRight(); samBot.moveForward(3); samBot.turnRight(); samBot.turnRight(); samBot.turnRight(); samBot.moveForward(2); samBot.turnRight(); samBot.turnRight(); samBot.turnRight(); samBot.moveForward(2); } } public class RobotMover { public void moveRobot(Robot samBot) { samBot.turnRight(); samBot.moveForward(2); samBot.turnLeft(); samBot.moveForward(3); samBot.turnLeft(); samBot.moveForward(2); samBot.turnLeft(); samBot.moveForward(2); } } We’ve saved a lot of lines of code by using turnLeft! 37 of 43

  39. turnAround public class Robot { public void turnRight() { // code that turns robot right } public void moveForward(int numberOfSteps) { // code that moves robot forward } public void turnLeft() { this.turnRight(); this.turnRight(); this.turnRight(); } // your code goes here! // … // … // … } • Let’s define a method that turns the Robot around 180 degrees • See if you can declare and define the method turnAround 38 of 43

  40. turnAround public class Robot { public void turnRight() { // code that turns robot right } public void moveForward(int numberOfSteps) { // code that moves robot forward } public void turnLeft() { this.turnRight(); this.turnRight(); this.turnRight(); } public void turnAround() { this.turnRight(); this.turnRight(); } } • Now that the Robot class has the method turnAround, we can call the method on any Robot • There are other ways of implementing this method that are just as correct 39 of 43

  41. turnAround public class Robot { public void turnRight() { // code that turns robot right } public void moveForward(int numberOfSteps) { // code that moves robot forward } public void turnLeft() { this.turnRight(); this.turnRight(); this.turnRight(); } public void turnAround() { this.turnLeft(); this.turnLeft(); } } • Instead of calling turnRight, we could call our newly created method, turnLeft • Both of these solutions are equally correct, in that they will turn the robot around 180 degrees • How do they differ? When we try each of these implementations with samBot, what will we see in each case? 40 of 43

  42. DEMO 41 of 43

  43. That’s it! • Important concepts: • Calling methods • an object sends a message to another object • example: samBot.turnRight(); • Defining methods • how we describe a capability of a class • example: public void turnLeft() { … } 42 of 43

  44. Important concepts: That’s it! • Classes and instances • a class is a blueprint for a certain type of object • an instance of a class is a particular member of that class • example: samBot is an instance of Robot • The this keyword • how an instance calls a method on itself • example: this.turnRight() 43 of 43

  45. Labs start today at 5PM in the Sunlab. Bring signed collaboration contract and a computer to set up remote access. You must attend the session for which you signed up every week. TA Hours start today at 4:30PM in the Fishbowl (2nd floor of CIT). HW1 and Andybot assignments go out Thursday. HW1 is due at 1PM on Sunday, and Andybot is due by 11:59PM on Wednesday, September 17th. Announcements

More Related