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
4. Java Types
• Java has two basic types
– Primitive 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)
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 4 bytes
point number
Double (double) Double precision float 8 bytes
Char (char) Single character 2 bytes
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();
}
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)
11. Syntax Examples (Methods)
public void calculatePayroll()
{
//code goes here
}
private int addNumbers(int x, int y)
{
//code goes here
}
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.
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
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)
Editor's Notes
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)
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.
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!
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.
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.