Transcript Chapter 1 - Object-Oriented System Development

Applying OO Concepts
Using Java
In this class, we will cover:
•
•
•
•
•
•
•
Overriding a method
Overloading a method
Constructors
Mutator and accessor methods
The import statement and using prewritten classes
Packages and the protected access modifier
The finalize() method
Overriding a Method
Overriding:
• If you declare a variable within a class, and use
the same variable name within a method of the
class, then the variable used inside the method
takes precedence, or overrides, the first variable
Overloading a Method
Overloading:
• Involves using one term to indicate diverse
meanings
• Writing multiple methods with the same name, but
with different arguments
• Overloading a Java method means you write
multiple methods with a shared name
• This is polymorphism in action.
Constructors
• Constructors are a special type of method.
• Used to create an instance of the class.
– e.g. Employee e = new Employee( );
This calls the Employee constructor.
• Java automatically provides a constructor method when
you create a class
• Programmers can write their own constructor classes
• Programmers can also write constructors that receive
arguments
– Such arguments are often used for initialization
purposes when values of objects might vary
Overloading Constructors
• If you create a class from which you instantiate
objects, Java automatically provides a constructor
• But, if you create your own constructor, the
automatically created constructor no longer exists
• As with other methods, you can overload
constructors
– Overloading constructors provides a way to create
objects with or without initial arguments, as needed
Example of
Overloading a Constructor
• public class Employee
{
public Employee (String n, double a)
{
name = n;
salary = a;
}
public Employee ( )
{
name = “ “;
salary = 0;
}
}
Mutator and Accessor Methods
• Often referred to as get/set methods.
• Mutator methods modify fields in a class.
– Example:
public void setName (String n)
{
empName = n;
}
• Accessor methods retrieve fields in a class
– Example:
public String class getName ()
{
return empName;
}
• Be careful not to return mutatable objects in your accessor
methods. Why is this important?
Mutator and Accessor Methods
• Returning mutatable objects in public accessor methods
breaks encapsulation!!!!
• Even if the data element is private, outside classes can now
modify it.
• You should return immutable objects (Strings, ints, etc).
• If you must return a reference to a mutatable object, you
should clone it first.
• See pg. 112 in book for example of this rogue code.
The finalize() Method
• Inherited from the Object class.
• Called by the VM before an object is destroyed and it’s
memory is released
• Use it to release resources that might not otherwise be
released (e.g. files)
• Use it to record the fact that an object has been destroyed
The Import Statement and
Using Pre-written Classes
• The creators of Java wrote nearly 500 classes
– For example:
• System, Character, Boolean, Byte, Short, Integer,
Long, Float, and Double are classes
• These classes are stored in packages, or a library
of classes, which is a folder that provides a
convenient grouping for classes
The Import Statement and
Using Pre-written Classes
• java.lang – The package that is implicitly imported
into every Java program and contains fundamental
classes, or basic classes
• Fundamental classes include:
– System, Character, Boolean, Byte, Short, Integer, Long,
Float, and Double
• Optional classes – Must be explicitly named
The Import Statement and
Using Pre-written Classes
• To use any of the prewritten classes (other than java.lang):
– Import the class
OR
– Import the package which contains the class you are
using
• To import an entire package of classes use the wildcard
symbol - *
• For example:
– import java.util.*; //imports all java.util classes
– import java.util.Vector; //imports the Vector class
– Represents all the classes in a package
Packages
• Creating packages encourages others to reuse software
because it makes it convenient to import many related
classes at once
• Packages are used to:
– maintain the uniqueness of class names
• Using Packages in your programs prevent class name scope conflicts
if multiple classes of the same name are used.
• e.g. both java.util and java.sql have a Date class, so if you are using
both packages you need to reference with java.util.Date or
java.sql.Date.
– group classes to make them more easily accessible to your classes
– reference classes in a particular scope
• What access modifier helps you limit access to packages?
Packages and the
Protected Access Modifier
• the protected access modifier:
– Provides you with an intermediate level of security
between public and private access
– Is used to limit access to classes within the same
package
– If you create a protected data field or method, it can be
used:
•
•
•
•
within its own class
in any classes extended from that class
or in classes in the same package
but it cannot be used by “outside” classes
Putting Your Class in a Package
• To include your class into a package, use the package
statement
– The package statement must appear outside the class definition
– The package statement looks like this:
• package <name of package>;
• example: package MC697;
class Person {
...
}
Packages and Directory Structure
• Packages map to the directory structure.
– Example:
package com.MC697;
public class Test {
public static void main (String[] args) {
System.out.println(“Testing packages”);
}
}
– This package statement maps to the directory:
<base directory>/com/MC697
where base directory is the directory you are going to compile and
execute the class file from
Compiling and Executing
Using Packages
• When using packages you must compile and run from the
base directory.
• So, let’s say c:\temp is the base directory we want to use.
The file in the example should be saved to
c:\temp\com\MC697\Test.java.
• To compile:
– cd to c:\temp
javac com/MC697/Test.java
• To execute:
– cd to c:\temp
java com.MC697.Test
Setting the Classpath
• When using packages or classes outside the java. packages, you
need to modify the classpath.
• What is the classpath?
– It is a environment variable that points the jvm to the needed class files.
• How do you set the classpath?
– You can set it using the -classpath option in the javac or java command.
• This is temporary. You will need to do this every time you use those
commands.
• e.g. javac -classpath c:\user\classdir PackageTest.java
java -classpath c:\user\classdir PackageTest
– Another way is to modify the environment variable on your machine.
• e.g. SET CLASSPATH=c:\com\MC697
• Different operating systems have different ways of setting this variable.
• See pg. 137 in book for examples of how to set this on different platforms.
JAR Files
• Jar files are Java’s version of the zip file.
• They group packages and class files together in a unit to make it
easier to deploy.
• Can be viewed using Winzip or similar utility.
• You can point your classpath variable to jar’s that contain
needed classes.
– e.g. SET CLASSPATH=c:\j2sdk1.4.1\jre\lib\rt.jar;%CLASSPATH%
Javadocs
• Javadocs are documentation for class files.
• Javadoc is a utility built into the sdk to automatically build
documentation from the java files.
– e.g. javadoc VectorDemo.java
• Remember the /** …. */ documentation symbols?
– These are used to denote documentation comments.
– Put these before a method or field to include comments about these in the
javadocs.
– Special tags can be used:
• @author
• @version
• @param for methods
– See pg. 139 in book for more information