- To open JGrasp: open a "Terminal", type "jgrasp"
- Compile (check for syntax errors): Use the plus sign "+"
- Run your program (check for run time and logic errors): Use the "running person" symbol
- Use the CSD button to indent the program, check for some simple errors - brackets and semi-colons
Constructors are used to create new instances of these classes
Example: Robot karel = new Robot() --> default constructor, 0 arguments
Robot mary = new Robot(5,4,Display.SOUTH, 10) --> 4 argument constructor
Robot (move, turnLeft, pickBeeper, putBeeper)
^ 2 constructors, p. One-5, default 0 argument and 4 arguments: x,y,direction,beepers
|
|
Athlete (turnAround, turnRight)
^ ^ 2 constructors, p. One-10,One-13, defualt: 1,1,NORTH,INFINITY
| | 4 argument: x,y,direction,beepers
| | calls super 4 argument constructor of Robot
Climber Racer (sprint, put(n), pick(n)) 1 constructor (y)
(climbUpRight, p. One-21
climbDownRight, 1 argument (y),
climbUpLeft, calls super 4 argument constructor of Athlete
climbDownLeft)
1 constructor (x) p. One-14
1 argument (x),
calls super 4 argument constructor of Athlete
- One-3 Discussion: File Management
- Organization of files - Personal folder is your home directory. Unit 1 files, and "maps" folder inside Unit 1 folder
- Vocabulary: source code, compiling and running files, bytecode
- Overview of Karel the Robot
- One-4, Lab00 Hello Robot
- Classes, objects, sending Robot commands. Also program structure
- Know how to create an instance of a Robot ("karel")
- Class Robot knows how to move(), pickBeeper(), putBeeper(), turnLeft()
- class methods: openWorld(), setSize(), setSpeed() - a new object of Display does not have to be created. Lines 9-12. Syntax is Display.openWorld()
- instance methods: move(), turnLeft(), pickBeeper(). Lines 15-23. Syntax is karel.move(). A new instance of Robot (karel) is created
- The new Robot is created in line 13: Robot karel = new Robot();
- Find Unit 1 API: academics.tjhsst.edu/compsci/CSweb/Unit1/webdemos/index.html
- Find Robot class on the left and browse the fields (private variables), constructors (creating new instances), and methods for the Robot class
- Here there are two constructors, one default and one requiring four fields - x,y,direction,beepers
- READ ABOUT AND UNDERSTAND Lines 1-25 in the Specification section
- Use "CSD" in JGrasp to help format and indent your program, and check for matching braces.
- Starting configuration
- Ending configuration
- One-5 Exercises Lab00
- 1. Knowing the difference between the default constructor (no arguments) and the four argument constructor.
- 2. Writing your own 4 argument constructor for the given specs
- 3,4. Writing code: completing the main method to perform specific tasks.
- 5. Know about the default empty map
- One-6 Discussion - Java applications (programs)
- public class FileName
- public static void main(String[] args)
- classname must match the name of the file
- compiling - javac
- bytecode - filename.class
- running the bytecode - java filename
- Study the chart at the bottom of page One-6
- use class Robot
- instance methods used: turnLeft, move, pickBeeper, putBeeper
- Background
- Maps and coordinates - bottom left is (1,1)
- Identifiers - know the rules of valid identifiers
- Instantiate, create, an instance of a class
- methods - things the Robot instance knows how to do.
- Calling, invoking a method using dot notation
- See the specifications for the program assignment, One-7
- Starting configuration
- Step 1 configuration
- Step 2 configuration
- Step 3 configuration
- Ending configuration
- One-8, Exercises Lab 01
- 1. Fields and methods of the Robot, and Display classes.
- 2. Valid/invalid identifiers
- 3,4. Knowing the map coordinate system
- 5. creating a robot-map of a given size
- 7. nouns are the instantiated objects
- 8. verbs are methods
- One-9, Discussion: Errors
- lexical and syntax errors - occur during compilation
- runtime and logic errors - occur during running the program
- investigate the chart at the bottom of One-9. CSD shows syntax errors - such as misplaced braces.
- Grace Hopper - the first computer bug
- use a new class Athlete extends Robot
- Two new constructors
- one default with no arguments, calls the supper Robot constructor with 4 arguments: 1,1,Display.NORTH,Display.INFINITY)
- a four argument constructor - variables for x,y,diretion,number of beepers
- define two new instance methods - turnAround, turnRight
- Two new constructors
- Inheritance, defining instance methods
- Athlete extends Robot - Athlete "isa" Robot, an Athlete is a specialized Robot
- an Athlete can do what a Robot does, but also more - turnLeft() and turnAround()
- See lines 6-13, the constructors for Athlete "overide" the Robot constructors using "super". Athlete has two constructors, default and a 4 arg constructor
- "hasa" - the class Lab02 "hasa" Athlete
- See the Specification for the program assignment
- Starting configuration
- Step 1 configuration
- Step 2 configuration
- Ending configuration
- One-11 Exercises Lab02
- 1,2 writing code - using the methods known by Athlete to accomplish specific tasks
- 3. "hasa" - Lab01 "hasa" ....
- 4. "isa", "hasa" - Lab02 "hasa"..., Athlete "isa" ...
- One-12 Discussion: Resource classes vs Driver classes and Class types vs Primitive types (int, double, boolean,...)
- Driver class has "static main". Resource class is "Athlete"
- The resource class Athlete did have to be instantiated using "new" for a new instance of the class Athlete
- Class types - Robot karel = new Robot()
- creates a reference
- instantiates a new object
- assigns the reference to point to the object
- Primitive types (not accessed with pointers) - int, double, boolean. The data is stored directly in memory spaces
- Understand the bottom of page One-12. Sending actual values when using constructors to instantiate an object.
- One-13 Discussion: Constructors - creating a new instance of a class object
- Study the difference between the default and 4-arg Athlete constructor
- Using "super" to calls Robot's constructor
- a one argument constructor (int x) for the horizontal x position
- this constructor calls the super four argument constructor of Athlete
- Define new instance methods:
- climbUpRight - move up 2 units and over 1 unit (tL,m,m,tR,m)
- climbUpLeft - move up 2 and over 1 to the left (tR,m,m,tL,m)
- climbDownRight - move over 1 unit and down 2 units to the right (m,tR,m,m,tL)
- climbDownLeft - move over 1 unit and down 2 units to the left (m,tL,m,m,tR)
- Climber extends Athlete - a Climber isa Athlete
- Climbers can climbUpRight(), climbUpLeft()
- climbDownRight(), climbDownLeft()
- Climbers use "Mountains" - "up two, over one"
- Only one Climber constructor
- Climber constructor has one argument, x position
- calls super for Athlete's four argument constructor
- Climber pete = new Climber(100)
- Starting configuration
- Step 1 configuration
- Step 2 configuration
- Step 3 configuration
- Step 4 configuration
- Step 5 configuration
- Step 6 configuration
- Step 7 configuration
- Step 8 configuration
- Ending configuration
- One-15 Exercises Lab03
- 1 - write the constructor, Elf extends from Robot - calls super for Robot
- 2 - write the constructor, Spartan extends from Athlete - calls super for Athlete
- One-15 Discussion - actual and formal arguments
- Class Athlete
- define a "class method" takeTheField(Athlete arg) that receives as an argument an Athlete
- Class method takeTheField() and instance methods such as move(), turnRight()
- takeTheField(maria) is correct
- maria.takeTheField() is NOT correct
- takeTheField() is part of the class, not part of the object
- Starting configuration
- Step 1 configuration
- Step 2 configuration
- Step 3 configuration
- Ending configuration
- One-17 Exercises Lab04 pt1 - Identify the error, what is wrong, with each numbered problem
- One-18 Exercises Lab04 pt 2 - changing, rewriting takeTheField to work for another "field pattern". 4-6 learning about the API for Math - http://academics.tjhsst.edu/compsci/CSweb/index.html for the Java API
- One-19 Discussion: Class hierarchy
- class hierarchy
- Robot superclass of ..., Athlete subclass of ...
- Understanding the class hierarchy diagram
- #1. Understanding inheritance of attributes
- #2. Understanding inheriting methods
- class hierarchy
- One-20 Discussion: Understanding "for" loops
- a Racer can:
- jumpRight - jump over a one unit hurdle (tL, m, tR, m, tR, m, tL), beginning facing into the hurdle
- sprint(n) - use a for loop to move forward n units
- put(n) - use a for loop to put down n beepers
- pick(n) - use a for loop to pick up n beepers
- has a one argument constructor for y, the vertical location to start at. This calls the super constructor for Athlete with arguments 1,y,Display.EAST,Display.INFINITY
- Background
- Racers start on the left at x=1, facing Display.EAST with an infinite (Display.INFINITE) number of beepers
- defines a new 1 argument constructor for y, the vertical starting position, calls the super constructor for Athlete (see the description above)
- Racers can sprint n steps, pickup n beepers, put down n beepers, and jump over a one unit hurdle to the right
- These new instance methods use for loops to define
- pete.sprint(100) moves Racer pete 100 steps
- Try defining a class method runTheRace(Racer r) similar to your takeTheField() from Lab04
- To run Lab05
- Each racer does the complete task before the other racer starts.
- Each pile of beepers is brought back individually
- At the end, the racer steps away from the pile to confirm that all 15 beepers have been moved
- Starting configuration
- Step 1 configuration
- Step 2 configuration
- Step 3 configuration
- Step 4 configuration
- Ending configuration
- One-22 Discussion: Loops and If
- Writing a for loop as a while loop
- for loop is a "definite" loop. while loop is an "indefinite" loop
- Examples:
- while(k <= n)
- while (karel.nextToABeeper())
- An if statement is similar to a while loop, but only makes a decision. The if statement DOES NOT LOOP, it only goes once.
- There is no such thing as an if loop
- void methods and return methods
- void methods take action and change a situation, but send back nothing
- return methods provide information about a robot's situation - a value of some kind is returned, such as a boolean true/false value.
- public void turnRight() takes an action, does not send any information
- public boolean nextToABeeper() sends back true/false whether the robot is on a beeper
- frontIsClear() sends back true/false whether the robot is facing a wall immediately in front of itself
- !frontIsClear() is true if the front is blocked. "!" means "not"
- One-23 Exercises Boolean methods
- Look at the Robot's API - click on the Robot link on the left
- write commands to face a robot west, have an Athlete put down all beepers, have a Climber pick up all beepers in a pile, stop a racer from moving when it's on top of another racer
- find the true/false value of each statement in #5
- Evaluate AND and OR for #1 at the bottome of the page
- Use tasks1, tasks2, and tasks3 map worlds. Each has 6 "tasks" to solve. For example use:
- while(temp.nextToABeeper()) and while(!temp.nextToABeeper())
- while(temp.frontIsClear())
- if(temp.nextToABeeper())
- Tasks1
- Tasks 2
- Tasks 3
