1. Introduction to Java 2 Programming
Lecture 2
Java Syntax, Robocode

2. Overview Java Syntax Robocode Practical Exercises The Basics
Classes, Packages
Robocode
How it works
Writing Robots
Anatomy of a Robot
Practical Exercises

3. Naming All Java syntax is case sensitive Valid Java names
Consist of letters, numbers, underscore, and dollar
Names can only start with letter or underscore
E.g. firstAttribute but not 1stAttribute
“Camel case” convention
Java encourages long, explanatory names
Start with a lower case letter, with words capitalised
E.g. thisIsCamelCase, andSoIsThisAsWell
Meaningful names are an important way to make your code understandable. While the later examples don’t always follow that recommendation, that’s just to save space on the slides.
Camel case is also recommended as it makes long identifier names much more readable. It’s called camel case because there are humps in the words!
Note that there are naming conventions for method names and variables also (see later slides)

4. Java Types Java has two basic types Reference types Primitive types
integers, floating point numbers, characters, etc
Refer to actual values
Reference types
Arrays, Classes, Objects, etc
Refer to memory locations (by name, not location)
Primitive types are basic values. References types are structures (arrays, classes, objects, etc). A reference is as close as Java gets to a C pointer, but references are accessed by name and not by location.
A Java programmer has no control over memory allocations, locations, etc.
Ideally in an OO language everything would be an object of some form, and Java does have objects that represent the kinds of values that can be stored in primitive types. However reference types take up more memory so for efficiency, Java allows values to be stored in a primitive form.

5. Primitive Types Type Description Size Boolean (boolean)
True/false value
1 bit
Byte (byte)
Byte-length integer
1 byte
Short (short)
Short integer
2 bytes
Integer (int)
Integer
4 bytes
Long (long)
Long Integer
8 bytes
Float (float)
Single precision floating point number
Double (double)
Double precision float
Char (char)
Single character

6. Syntax Examples (Variables)
int anInteger;
Boolean isSwitchOn;
Variables can be initialised when they are declared
Int anInteger = 10;
Boolean isSwitchOn = true;

7. Syntax Examples (if) if (x == y) { //executes if true }
if (somethingIsTrue())
doSomething();
else
doSomethingElse();

8. Example (for) int x=0; for (int i=1; i<=10; i++) {
//code to repeat ten times
x = x + i; }

9. Example (while) int x=0; while (x < 10) { doSomething(); x++; }
//loop forever
while (true)

10. Methods Define some behaviour of a class
Method declarations have four basic sections, and a method body:
Visibility modifier (who can call the method)
Return type (what does it return)
Method name
Parameter list (what parameters does it accept)
Methods can also indicate what kinds of errors (exceptions) might arise when they’re called. We’ll cover these in a later section.
Methods defined in interfaces don’t have a method body, again we’ll cover these later.
There are also some additional types of modifiers (e.g. abstract, final) which we’ll also cover later!

11. Syntax Examples (Methods)
public void calculatePayroll() {
//code goes here }
private int addNumbers(int x, int y)

12. Method Naming Conventions
If a method sets some value on an object
public void setVatLevel(float vat);
If a method retrieves some value from the object
public float getTotalPayroll();
If a method returns a boolean value
public boolean isSwitchOn();

13. Classes One Java class defined in each .java file
File name must match the name of the class
Otherwise there will be compilation errors
Class names start with an upper case letter
Compiler will generate a .class file with same name
Contains the bytecode
Classes defined using the class keyword.
There’s no equivalent of the C/C++ header file: just the .java file. One class per file (some exceptions, but outside the scope of this course).
File name matching the class name is important. File names are case sensitive, just as class names are.

14. Packages Group related classes together
Each class in a package must have a unique name
Indicate the package a class belongs to with the package keyword
Recommended each class is put in a package
Gain access to public classes in other packages using the import keyword
The JVM needs to know where the classes are defined before you can use them
Classes declare that they belong to a package. There’s no way for a package to be defined separately.
Packages are a way of grouping relating classes together, to build a modular unit. The basic Java API has a
Large number of pages, e.g. java.lang for the basic, java.util for utility classes, java.net for networking, etc.
If a class wishes to refer to a class defined in another package, it must declare that it needs access to that package. This is done using the import keyword. It’s the responsibility of the JVM to find the relevant package, and classes on disk.

15. Anatomy of a Java Source File
package intro2java;
import java.util.*;
/**
* A description of the class */
public class MyFirstClass {
//attributes
private boolean isSomething;
private int aCounter;
//methods
public void doSomething() {
//code goes here }

16. Common Sources of Error
Mistakes in naming
Wrong case, illegal names
class name and source file name not the same
Missing semi-colon
Missing curly brackets
Incorrect Loop checks
Loop is too large/small, or occurs forever
Testing equality
Assignment with = (single equals sign)
Comparison with == (two equals signs)

17. Overview Java Syntax Robocode Practical Exercises Quick Overview
How it works
Writing Robots
Anatomy of a Robot
Practical Exercises

18. Anatomy of a Robot package yourname; import robocode.*; /**
* Description of Robot */
public class MyRobot extends Robot {
* Description of run method
public void run() {
//the robots behaviour }