Download Lecture 3

Programming section 3
1
Importing classes
purpose
packages
CLASSPATH
creating and using a package
2
Importing classes
Purpose
Serious Java programming deals with many
classes …
… and so some sort of organisation is
needed.
Organisation in Java is achieved using the
concept of a package

(c.f. the use of folders or directories to organise
files).
A program can import classes from a package
3
Importing classes
Packages
Packages are collections of classes and
sub-packages. (c.f. directories can hold
files and subdirectories)
The standard package or collection of
classes used in Java is called java.lang
4
Importing classes
Standard classes

Standard classes in java.lang can be
used directly e.g.
System.out.println(“Hello
world”);
 out is a member variable (attribute) of
the System class. It is of class
PrintStream
 println is a method of the
PrintStream class
5
Importing classes
A number of package classes
If a number of classes required are in
some other package then import all the
public classes in the package.
e.g.
import java.awt.*;
:
Font f = new Font();
6
Importing classes
Name clashes
This fails if FTP is in both packages
import com.naviseek.web.*;
import com.prefect.http.*;
:
FTP out = new FTP();
This succeeds since ambiguity removed
:
com.prefect.http.FTP out = new
com.prefect.http.FTP();
7
Protecting methods and
attributes
Basic Java Language Section
8
Protecting Your Class
Usually you don’t want other objects directly
changing your attributes because if you
modify the type of name of the attributes you
have to modify the other classes…
So you can protect any method or attribute
from outside interference.. by providing a
setter to change its value
You can also protect parts of your class using
private and protected in their declaration
9
Problems with Accessing
attributes directly
class Hero
{
int bullets=10;
}
This is a silly value for the
number of bullets but because
the variable is accessed directly
no error checking can be
performed by the hero class
Hero h=new Hero();
h.bullets=-20;
10
Using setters to change
attributes
class hero
{
int bullets=0;
void set_Bullets(int b)
{
before we change the
bullets attribute we could
add error checking to
detect bad values for b
bullets=b;
}
}
Hero h=new Hero();
h.set_Bullets(-20);
11
Protecting Your Class
Private – this means the method or attribute
is not available outside the class it is defined
in not even subclasses can access it
Protected – only subclasses and classes in
the same package can access it
Public - anyone can access it
Any class can always access the attributes
and methods it defines
12
Protection
class Hero
{
protected int bullets;
public set_Bullets(int b)
{
bullets = b
}
private boolean spy;
}
now bullets cannot be
accessed from outside
the class from
another package
directly...
... so the setter must
be used to modify
bullets and can provide
error checking
13
Example of protection
package examples;
class Example1
{
void doit()
{
Hero john = new Hero();
john.set_bullets(10); // legal because set_Bullets
is public
john.bullets=20; // illegal because height is
protected
john.spy=true; // illegal because spy is private
}
}
14
Protection with inheritance
package examples;
class Hero2 extends Hero
{
void doit()
{
set_bullets(10); // legal because grow is public
bullets=20; // legal because height is protected
and we are a subclass of Person
spy=true; // illegal because spy is private
}
}
15
Arrays
Mass Storage
16
Arrays
Arrays allow large numbers of simple data
types such as int or instances of classes to be
easily accessed.
indicates that the array will hold 10 items
indicates variable is an array
int array[]=new int[10];
array[0]=4;
accessing an element of an array also
uses [] arrays start at 0
this is the last element of the array
array[9]=1234;
System.out.println(array[0]);
17
Arrays holding Objects
Arrays can also hold instances of a class or
any of its subclass
indicates that the array will hold 10
instances of the Monster class or subclass
Monster array[]=new Monster[10];
array[0]=new Monster();
Dragon is a subclass of Monster so this is fine
array[9]=new Dragon();
array[0] is an instance of Monster so we can
call take_damage on it
array[0].take_damage();
18
Dangers of Arrays of Objects
with an array of simple types such as ints
every element in the array exists even if we
don’t assign a value to them
no problem!!
int array[]=new int[2];
System.out.println(array[0]);
with an array of Objects elements are null
until we assign an instance to them
Monster array[]=new Monster[2];
null pointer exception!
array[0].take_damage();
19
Initialising Object Arrays
unlike arrays of simple types arrays of
any type of object require each element
to be instantiated and inserted into the
array...
Monster array[]=new Monster[2];
array[0]=new Monster();
array[1]=new Monster();
array[0].take_damage();
20
Finding the number of
elements in an array
Fortunately we can ask the array how long it
is using .length
int array[]=new int[10];
int index;
for (index=0;index<array.length;index=index+1)
{
array[index]=0;
}
Now we can make the array bigger or smaller
and the code will not crash and will initialise
21
the entire array
Problems with Arrays I
The single biggest problem with an
array is that it is not variable length.
You have to declare the length of the
array as a constant and you can not tag
on extra elements
int array[]=new array[20];
array out of bounds
array[30]=1234;
exception!
22
Problems with arrays II
You also can not remove elements in an
array even if they are no longer
needed. For instance suppose I have an
array of 4 Monsters which the Hero is
fighting. If the Hero kills 2 it would be
nice to remove two from the array... the
only thing you can do is to replace the
dead instance with null.
23
Strings
Mass Storage
24
Strings
The String class allows you to store and
manipulate sequences of characters
Like chars, Strings are case sensitive so
“hello” is not the same as “Hello”
Strings are in fact Objects
The length method tells you the length of a
string in chars e.g. “hello”.length()==5
You can get a copy of the character at any
position in a string using charAt()


“hello”.charAt(0)==‘h’
“hello”.charAt(4)==‘o’
25
Relationship between String
and Arrays
It is possible to get a copy of the contents of
a String as a char array
String s="hello world";
make sure the array is large
enough to store the entire String
char con[]=new char[s.length()];
Starting char in the String
ending char +1 in the String
s.getChars(0,s.length(),con,0);
array to copy chars into
starting position in the array
26
Relationship between String
and Arrays
It is also possible to create a string from a
char array
String s="hello world";
char con[]=new char[s.length()];
s.getChars(0,s.length(),con,0);
con[0]='H';
s=new String(con);
System.out.println(s);
However, manipulating char arrays is not easy
so in general it is better to manipulate the
27
String by keeping it in its String format
Manipulating Strings
There are many manipulation functions
defined for the string object one of the most
useful is subString
You can get a copy of part of a string using
subString
starting index

“hello”.subString(0,2)==“hel”

“hello”.substring(2,3)==“ll”
ending index
28
Adding to your String
Unlike arrays, Strings can be appended and
pre-pended to easily
String s=“world”;
s=“hello “+s;
s=s+”!”;
This gives the String “hello world!”
29
Seeing if Two Strings are
Equal using ==
For simple types you can use == and != to
see if something is equal or not equal.
== and != do not work correctly for objects
String s=“hello there”;
String s1=“hello there”;
s==s is true
s1==s1 is true
s==s1 is false!!!!!!!!!!!!!!
This is because for objects == and !=
check where the instance is in memory
and not the contents of the instances
30
Seeing if Two Strings are
Equal using equals
To see if two Strings are identical you need to
use equals() or equalsIgnoreCase()
String s=“hello there”;
String s1=“hello there”;
s.equals(s) is true
s.equals(s1) is true
s.equals(s1) is true
This is because equals and equalsIgnoreCase
check the contents of the instances and not
their locations in memory
31
Converting other types into
Strings
Java will convert almost any simple type into
a String for you
String s=“”;
“” is an empty String
int i=166;
“” converts a copy of i into
a String
s=“”+i;
This does not work for Objects because Java
can not work out how to convert an object
into a String
32
Converting Strings into other
types.
Java provides static methods in classes called
Integer, Long, Float and Double to help you:
int i=Integer.parseInt("100");
long l=Long.parseLong("100");
float f=Float.parseFloat("100");
double d=Double.parseDouble("100");
If and only if the entire String looks like
another type can the conversion take place.
Exception
int i=Integer.parseInt(“hello 100");
33
More String Functions
There are many more String
manipulation functions than we have
time for to look at here
Take a look at the Java documentation
for the String class and have some fun!
34