Transcript Document 557001

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;
}
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
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.
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
21
22
23