Java Building Blocks

Java: Building Blocks
Cate Huston
@kittenthebad

What We’ll Cover
• Java: an Object Oriented Language

• The Eclipse IDE

• Writing your ﬁrst program

• Primitive Types

• Strings

• Conditions

• Loops

Java: an Object
Oriented Language

What Does Object
Oriented Mean?
• If Ikea were made of code, it would totally
be written in an Object Oriented language.
• Object-Oriented means that we break our
code down into components (objects) with
properties (ﬁelds), that can be used to
make other objects, or interact with each
other.
• (See? It’s a little bit like Ikea furniture!)

OK, Give Me an
Example!
• Imagine a bike. If we wanted to “code” a bike, it
would be a lot easier if we split it down into its
component parts.

• wheels (x2)

• breaks

• seat

• frame

• peddles...

Another?
• How about a ToDo list?

• It’s make up of tasks.

• Each task should have things associated with it, such as:

• It’s name

• The date it’s due

• The date we actually complete it

• An estimate of how long it will take

• The date we started it

Try It!

• Think of a complex object
• Break it down into it’s component parts
• What information does each component
need to know about itself?

Eclipse is a powerful, free and open source Java IDE
(Integrated Development Environment). It has some
very useful features for learning to program.

Let’s start by making a new project.
File => New => Java Project

Let’s call it “Hello World”.
It’s a programming tradition.

Now we make a new “class”. Java classes
are where we represent our “objects”.

Let’s call this “HelloWorld”. Notice how
there are no spaces? That’s important.

Our ﬁrst class!
It should look like this.

Writing Your First
Program

Finally! Write Some
Code

• For our ﬁrst program, we’re going to write
something that prints out “Hello World” in
the terminal.
• (Sorry, programmer tradition)

Click on “Run” (the green “play
button), and see what happens.

What Does It All Mean?
• public class HelloWorld {

• Declares our class/object with name “HelloWorld”. Everything inside the “{“ is part of the
class. Public is to do with it’s visibility (don’t worry about that for now).

•
public static void main(String[] args) {

• This is our “main” method, what’s called when we click “run”. The String[] args means
we can pass arguments to it, if we want to. Everything inside the “{“ is part of the main
method.

•

System.out.println("Hello World");

• This means - print out “Hello World” to the terminal. The “;” is important, it denotes the
end of the line of code. We’re going to be using a lot of these.

•
} }

• The ﬁrst closing bracket denotes the end of the “main” method, the second the end of the
HelloWorld class.

Building Blocks
• Primitives are the most basic kinds of “type”
in Java (a building block!)
• You can also think of them as like atoms in
chemistry.
• A “type” is where we say what kind of thing
a variable is.
• Objects are made up of other objects and
primitives.

For Example...
• Whole numbers, like 42, or 926 are of type
int (or short, or long).

• Decimal numbers, like 2.34376 or 1.203 are
ﬂoat, or double.
• True or False are boolean.
• A character like ‘a’ or ‘c’ is a char. Notice
the single quotes? Those are important.

Declaring Variables
• We can declare a variable of a primitive type in Java as
follows:

• int i = 42;

• double d = 735.27;

• boolean b = true;

• char c = ‘h’;

• So:

• type variable_name = value;

See how we can use the “+” sign to
include it in our output?

Strings

• A String is not a primitive, it’s an Object,
but we can declare it like a primitive.

• It’s a little more complex to declare
Objects (but we’ll look at that later)
• String s = “hello world”;
• String s = “hello world” + “nhow are you?”

Comparing Things
• We compare things in • Equals: ==
Java using conditional
logic. • Greater Than: >

• We can put this in an “if • Less Than: <
statement”
• Greater Than or
• if (a == b ) { ... } Equal To: >=

• else if (a < b) { ... } • Less Than or Equal
To: <=
• else { ... }

Try this for different values of a
and b

Repeating Things
• Loops are helpful for sections of code
that we want to repeat.
• There are three kinds of loop.
• while
• do while
• for

For Loops
• For when we know how many times
we want to repeat something.
• 10 times
• for(int i = 0; i < 10; i++)
• For each character in a string
• for(int i = 0; i < stringname.length(); i++)

For each character in a string. s.charAt(i) gets
the character in the string at position i.

While and Do-While
Loops
• When we want to repeat something until a
condition changes.

• In a while loop we check that condition at the
start of the loop

• while(a == b) { ... }

• In a do-while loop we check that condition at
the end of the loop.

• do { ... } while (a == b)

Tidy Code
• Tidy code is much easier to read (and debug!)

• Debug - ﬁx when it’s not working.

• As a rule, indent in one inside each set of {}.

• In longer sections of code, we can use // to denote a
comment.

• A comment is code that is ignored by the compiler.

• The Java compiler ignores whitespace, so use line breaks
wherever you think it will make your code clearer.

Finally

• This slide deck covers the very basics of
Java - the building blocks.
• It’s important to understand these, because
everything else builds upon them.
• Next, we’re going to look at Processing.

@kittenthebad
http://kittenthebad.wordpress.com/

catehuston@googlewave.com

Java Building Blocks

More Related Content

What's hot (20)

Similar to Java Building Blocks (20)

More from Cate Huston (10)

Recently uploaded (20)

Java Building Blocks