Transcript Chapter 5 Objects and Classes

Chapter 5
Objects and Classes
5.1.2 A Student example
public class Student {
public String name; // Student’s name.
public double test1, test2, test3; //Grades on 3 tests.
public double getAverage() { // compute avg. test grade
return (test1 + test2 + test3) / 3;
}
} // end of class Student
Properties and Methods of Student
• Properties
•
•
•
•
name – String
test 1 – double
test 2 - double
test 2 – double
• Methods
• getAverage() (a method to get average test grade.)
Using the Student Class
public class StudentDemo {
public static void main(String[] args)
Student george = new Student();
Student fred = new Student();
george.test1 = 98.6; //’reaches in’
george.test2 = 88.9;
george.test3 = 94.0;
System.out.println("George's avg.: "
System.out.println("Fred's avg.: " +
}
}
{
and set a score
+ george.getAverage());
fred.getAverage());
What is the variable “fred”?
• In Java, no variable can ever hold an object.
• A variable can only hold a reference to an object.
• It is possible for a variable like fred, whose type is given by a class, to
refer to no object at all. We say in this case that fred holds a null
pointer or null reference.
Another Example
Student std, std1,
std2, std3;
std = new Student();
// Declare four variables of
// type Student.
// Create a new object belonging
// to the class Student, and
// store a reference to that
// object in the variable std.
std1 = new Student(); // Create a second Student object
// and store a reference to
// it in the variable std1.
std2 = std1;
// Copy the reference value in std1
// into the variable std2.
std3 = null;
// Store a null reference in the
// variable std3.
std.name = "John Smith"; // Set values of some instance variables.
std1.name = "Mary Jones";
// (Other instance variables have default
// initial values of zero.)
Copy objects? Compare Objects?
• When one object variable is assigned to another, only a reference is
copied.
• The object referred to is not copied.
• The expression greeting == "Hello" tests whether
greeting and "Hello" contain the same characters stored in the
same memory location.
• Bottom line: operations like copying and comparing usually require
using special methods written to what you really want to do.
Passing to methods
void dontChange(int z) {
z = 42;
}
void change(Student s) {
s.name = "Fred";
}
x = 17;
dontChange(x);
System.out.println(x);
stu.name = "Jane";
change(stu);
System.out.println(stu.name);
//prints 17
//prints Fred
5.1.3 Getters and Setters
• Access Control: who gets to see and change variables?
• Modern programming practice discourages allowing variables to be
“seen” outside a class.
• Statements like: std.name = "John Smith"; are
discouraged.
• It is considered better to “route” through getters and setters:
methods whose job it is to control access to variables.
• This keeps the method a “black box”
Getters or accessors
• The name usually starts with “get” (or “is” if the variable is a
boolean).
• The argument list is usually empty: getName()
• A getter’s type is the type of the variable.
• A getter can do more than just return the value, if you want. This is
up to the programmer.
• A getter can hide whether a value is just returned from a stored copy,
or calculated “on the fly”.
Setters or mutators
• These are usually of type void: their job is to do something, not return
something.
• There is usually one argument, of the type of the variable in question.
• Once again, the method can do more than just set the value (It might
want to track how often a variable is being changed, for example.)
• Example: setName("George Washington");
• There doesn’t even have to be a variable of that name, although
there usually is. That’s internal business of the method.
5.2.2 Constructors
• This is a special type of method (or is it really a method?):
•
•
•
•
Unlike all other methods, it does not have a type.
They are neither instance methods nor static methods.
The name of the constructor method is identical to the name of the class.
It is invoked with the operator new.
• There is a default, no-arg constructor that “goes away” as soon as you
write any constructor.
• Constructors are frequently overloaded.
5.2.3 Garbage Collection
Student std = new Student("John Smith");
std = null;
Java uses a procedure called garbage collection to reclaim memory
occupied by objects that are no longer accessible to a program. It is the
responsibility of the system, not the programmer, to keep track of
which objects are “garbage.” In the above example, it was very easy to
see that the Student object had become garbage. Usually, it’s much
harder. If an object has been used for a while, there might be several
references to the object stored in several variables. The object doesn’t
become garbage until all those references have been dropped.
5.3.1 Some Built-in Classes
• String
• StringBuilder with .append() and .toString() methods
• java.util.Date
• java.util.Random with .nextInt()
• java.awt.Color
• Strings and Colors are immutable.
5.3.2 The class “Object”
• Subclass and inheritance: Classes can be made from other classes. In
fact, every class is a subclass of Object.
• several instance methods that are inherited by every other class
• toString() The built-in toString() usually isn’t very useful, just a name and a
hash code. You usually write your own to replace the inherited version.
• equals() compares to another object, but usually will be replaced.
• clone() makes a copy
• getClass() gets the class
• finalize(), notify(), notifyAll(), wait() these are a bit technical and beyond this
course.
5.5 Inheritance, Polymorphism, and Abstract Classes
• Inheritance: “Extends”
• Polymorphism: More of a Java II topic, useful when having different
related types of objects in a data structure.
• Abstract Classes: Polymorphism taken a bit farther: The parent class
need not be a “real” class at all, but just a template for real classes.
(Here by “real class”, I mean a class that can be instantiated: you can
use it to make an object. An abstract class can only be used to make
other classes)
this
• A special variable that refers to the object.
• It is useful for:
• Avoiding “shadow” names in constructors and sets.
• In the Eclipse debugger, it lets you examine the instance variables of the class.
• Eclipse uses it automatically when you let it create setters and getters.
super
• When a child class overrides a method in its superclass, the special
variable super lets the child class method call the corresponding
method in the superclass.
• This can be very useful in constructor methods. If used in a
constructor, it must be the very first statement in the child’s
constructor method.
• It can be used in other overwriting methods as well. For example it is
pretty handy in a toString method.
Interfaces
• Easy for a novice to confuse with abstract classes
• You can extend exactly one abstract (or non-abstract) class
• You implement one or more interfaces.
• By implementing an interface, you promise to write all the methods
required for that interface.
• This lets Java and Eclipse know that it is safe to call those methods.
Nested Classes
• These are more advanced (Java II) topics.
• Nested classes can be static or instance.
• Anonymous inner classes are used by Eclipse Window Builder to build
event handlers.