Transcript The Building Blocks - Utah Valley University

Objects and Classes
CS 3250
The Building Blocks
• Classes:
– Classes have variables and methods.
– No global variables, nor global functions.
– All methods are defined inside classes
(except native methods)
• Java class library, over 3,000 classes:
– GUI, graphics, image, audio
– I/O
– Networking
– Utilities: set, list, hash table
Organization of Java Programs
• Java provides mechanisms to organize
large-scale programs in a logical and
maintainable fashion.
– Class --- highly cohesive functionalities
– File --- one class or more closely related
classes
– Package --- a collection of related classes
or packages
Organization of Java Programs
• The Java class library is organized into
a number of packages:
– java.awt --- GUI
– java.io --- I/O
– java.util --- utilities
– java.applet --- applet
– java.net --- networking
• See the online API documentation
– link on class page
Objects and Object Variables
Suppose you have the following line in
your program:
String word = "kryptonite";
What kind of thing is word?
Objects and Object Variables
Suppose you have the following line in
your program:
String word = "kryptonite";
What kind of thing is word?
Hint: It is not an object of class String.
Objects and Object Variables
Suppose you have the following line in
your program:
String word = "kryptonite";
What kind of thing is word?
Answer: It is a variable that can refer to
objects of class String.
Object References
String word = "kryptonite";
word
instance of String
"kryptonite"
Sometimes it is very important to
understand how reference variables
work, like in the following situations...
Null References
String word;
int length = word.length();
word
What will happen when this code
executes?
Aliases
String word = "kryptonite";
String word2 = word;
word
instance of String
"kryptonite"
word2
Aliases of mutable
objects can be tricky.
Why?
Aliases
bob.setSalary(50000);
sue.setSalary(60000);
bob
sue
salary
???
Variable, Object, Class, Type
• Variables have types, objects have classes.
• A variable is a storage location and has an
associated type.
• An object is an instance of a class or an
array.
• The type of a variable is determined at
compilation time.
• The class of an object is determined at run
time.
Variable, Object, Class, Type
A variable in Java can be of:
• primitive type --- hold exact value
• reference type --- hold pointers to
objects
• null reference: an invalid object
• object reference: pointer to an object
whose class is assignment compatible
with the type of the variable.
Reference Type and
Garbage Collection
• All objects reside on the heap
– Must use the new operator
• A “reference” is returned
– More like a pointer than a C++ reference
• You can’t “delete” the object through its
reference
• It is cleaned up by the garbage collector
– After the object is no longer used
– When the GC is good and ready to do it!
– Memory leaks are practically non-existent in Java
Class Declaration
[ClassModifiers] class ClassName
[extends SuperClass]
[implements Interface1, Interface2 ...] {
ClassMemberDeclarations
}
public class MapDisplay
extends JPanel
implements MouseListener,
KeyListener {
...
}
Class Modifiers
public
Accessible everywhere
One public class allowed per file.
The file must be named ClassName.java
private
Only accessible within the class
<empty>
Accessible within the current class package.
abstract
A class that contains abstract methods
final
No subclasses
Method And Field Declaration
[MethodModifiers] Type Name ( [ParameterList] ) {
Statements
}
public static void main(String[] args) {
System.out.println
("Red alert, shields up!");
}
[FieldModifiers] Type FieldName1 [= Initializer1 ] ,
FieldName2 [= Initializer2 ] ...;
private final int MAX_SPEED = 60;
Method and Field Modifiers
•For
both methods and fields:
public protected private
static final
Final methods cannot be overridden
•For
methods only:
abstract synchronized native
•For
fields only:
volatile transient
Class Declaration Example
public class Point {
public int x, y;
}
public void move(int dx, int dy) {
x += dx; y += dy;
}
Point point1; // Point not created
Point point2 = new Point();
point1 = point2;
point1 = null;
x and y are initialized to their default initial values.
Explicit Initializer
public class Point {
public int x = 0, y = 0;
}
public void move(int dx, int dy) {
x += dx; y += dy;
}
Point point1 = new Point(); // (0,0)
Constructors
public class Point {
public int x, y;
public Point() { // no-arg
x = 0; y = 0;
}
}
public Point(int x0, int y0) {
x = x0; y = y0;
}
Point point1 = new Point(); // no-arg
Point point2 = new Point(20, 20);
• Constructors are invoked after default initial values are assigned.
• No-arg constructor is provided as a default when no other
constructors are provided.
Initialization Block
public class Point {
public int x, y;
}
1.
2.
3.
4.
// Object initialization block
// Executes before constructor
{
x = 0;
y = 0;
}
Data fields initialized to default value (0, false, or null)
Field initializers and initialization blocks are executed in order
they appear
If first line of constructor calls another constructor, that other
constructor is executed.
The body of the constructor is executed.
Object Reference: this
• You can use this inside a method,
• It refers to the current object on which
the method is invoked.
• It's commonly used to pass the object
itself as a parameter
aList.insert(this);
Object Reference: this
• It can also be used to access hidden
variables:
public class Point {
public int x, y;
public Point(int x, int y) {
this.x = x; this.y = y;
}
}
• It can also be used to call other constructors
Wrappers
• Objects that hold primitives
– Read-only!
• Used when objects are called for
– In collections, for example
• More expensive than using primitives
• Have symbolic constants for min/max,
conversion functions to primitives
• Example: Primitives.java, Wrappers.java
– Compares time with primitives to time with
wrappers
Static Variables
• Static variable or fields:
one per class, rather than one per object.
• Static variables are also known as class variables.
– Initialized when the class is loaded by the JVM
• Non-static variables are called instance variables.
class IDCard {
public long id;
protected static long nextID = 0;
}
public IDCard() {
id = nextID++;
}
Static Methods
A static method
• can only access static variables and invoke
other static methods
– (unless an object reference is used)
• can not use this reference
class IDCard {
public long id;
protected static long nextID = 0;
...
public static void skipID() {
nextID++;
}
}
Invoking Methods
• Non-static methods must be invoked through an
object reference:
object_reference.method(parameters)
• Static methods can be invoked through an object
reference or the class name:
class_name.method(parameters)
So, you can do either of the following:
IDCard.skipID();
// the preferred way
IDCard mycard = new IDCard();
mycard.skipID();
Why is this
way preferred?
Passing Parameters
All parameters are passed by value:
A copy of the parameter will always be
made, but never a copy of an object.
doSales(bob, 2005);
Why not?
void doSales(Employee emp1, int year) {
String name = emp1.getName();
int sales = emp1.getSales(year);
emp1.setCommission(sales * pct);
}
Passing Parameters
doSales(bob, reportYear);
reportYear
bob
2005
commission
year
emp1
???
2005
void doSales(Employee emp1, int year) {
String name = emp1.getName();
int sales = emp1.getSales(year);
emp1.setCommission(sales * pct);
}
final "variables"
• Final variables are named constants.
class CircleStuff {
static final double pi =3.1416;
}
• Final parameters are useless.
Blank finals
• Allows you to declare a final without
initializing it
• Applies to fields as well as local vars
• Must still be initialized before it’s used:
class MyClass {
final String s;
MyClass(String s) {
this.s = s;
}
}
Can not be
initialized after
construction.
The toString() Method
The toString() method converts objects to strings.
public class Point {
public int x, y;
...
public String toString() {
return "(" + x + "," + y + ")";
}
}
Then, you can do
Point p = new Point(10,20);
System.out.println("A point at " + p);
// Output: A point at (10,20)
Access Specifications
• Public
– Available anywhere (public keyword)
– Only one public class per file allowed
• Protected
– Available in subclasses, and in the package
– protected keyword
• Package (“Friendly”)
– Available in the package only
– No access specifier
• Private
– Available in class only (private keyword)
What’s a Package?
• A set of classes (.class files) in the same
directory
– Similar to C++ namespaces
– Don’t have to use import
– A “substitute” for friend in C++
• The directory must match the package name
– Can have multiple segments (dot-separated)
– java.util corresponds (loosely) to the subdirectory
java/util
• Use the package keyword
– Must be first non-comment line of file
The Class Path
• A search path
• Consists of directories or JAR files
• All package directories must be
subdirectories of a directory in the class
path
• -classpath option
• CLASSPATH environment variable
The Unnamed Package
• The “default” package
• All classes not in a named package are
in this package
– Can span multiple directories
– Uses the classpath
JAR Files
• “Java Archive”
• A way of collecting/compressing .class files
jar –cf myJar.jar *.class
•
•
•
•
For faster loading of applets
And for distributing pre-compiled software
Uses ZIP format
Can run from command-line with the “java”
command
java –jar myJar.jar