Week9 Intro to classes and objects in Java

Opening the World of Potential
Java programs are made of objects that interact
with each other
◦ Each object is based on a class
◦ A class describes a set of objects with the same behavior
Each class defines a specific set of methods to use
with its objects
◦ For example, the String class provides methods:
◦ Examples: length() and charAt() methods
String greeting = “Hello World”;
int len = greeting.length();
char c1 = greeting.charAt(0);

Diagram of a Class
Private Data
◦ Each object has its own private data
that other objects cannot directly
access
◦ Methods of the public interface
provide access to private data, while
hiding implementation details:
◦ This is called Encapsulation
Public Interface
◦ Each object has a set of methods
available for other objects to use
Class
Private Data
(Variables)
Public Interface
(Methods)

Public Interface of a Class
Why do you need a class?
◦ What tasks will this class perform?
◦ What methods will you need?
◦ What parameters will the methods need to receive?
◦ What will the methods return?
Task Method Returns
Add the price of an item addItem(double) void
Get the total amount owed getTotal() double
Get the count of items purchased getCount() int
Clear the cash register for a new sale clear() void

To create a Class
You need:
◦ Public class name
◦ Private instance variables
◦ Constructors
◦ Getters & Setters
◦ Helper methods

Classes – Instance Variables
Each object instantiated from the class has its own set of
instance variables
◦ Instance variables describe the class
◦ They store the state of the object
Defining instance variables:
◦ Access Specifiers
◦ Classes (and interface methods) are public
◦ Instance variables are always private
◦ DataType
◦ Instance Variable name – EXTREMELY IMPORTANT TO USE CAMEL
CASING

public class Animal
private String type;
private String name;
private double weight;
private int age;
Private access modifiers mean the variable is
only accessible within the class.

Accessing Instance Variables
public static void main(String[] args)
{
. . .
System.out.println( cat.age ); // Error
. . .
}
The compiler will not allow
this violation of privacy
 Use accessor methods of the class instead!
{
. . .
System.out.println( cat.getAge() ); // OK
. . .
}
Encapsulation provides a public interface
and hides the implementation details.

Accessor and Mutator Methods
1) Accessor Methods: 'get' methods
◦ Asks the object for information without changing it
◦ Normally return a value of some type
2) Mutator Methods: 'set' methods
◦ Changes values in the object
◦ Usually take a parameter that will change an instance variable
◦ Normally return void
public void addItem(double price) { }
public void clear() { }
public double getTotal() { }
public int getCount() { }

Constructors
A constructor is a method that initializes instance
variables of an object
◦ It is automatically called when an object is created
◦ It has exactly the same name as the class
public class Animal
{
. . .
public Animal() // A default no-arg constructor
{
}
}
Constructors never return values, but
do not use void in their declaration

POJO Characteristics
All POJOs MUST HAVE A DEFAULT NO-ARG CONSTRUCTOR
◦ (yes, I‘m yelling about it!)
Either implicit or explicit
◦ Implicit – assumes one but not specifically defined
◦ Explicit – if you have a non-default constructor, you must
add in a default no-arg constructor

The Default Constructor
If you do not supply any constructors, the compiler will
make a default constructor automatically
◦ It takes no parameters
◦ It initializes all instance variables
public class Animal
{
. . .
/**
Does exactly what a compiler generated constructor would do.
*/
public Animal()
{
//all instance variables would be set to a default value
}
}
By default, numbers are initialized to 0,
booleans to false, and objects as null.

Multiple Constructors
A class can have more than one constructor
◦ Each must have a unique set of parameters
public class Animal
{
. . .
/**
Constructs an animal with no features */
public Animal( ) { . . . } // default no-arg constructor
/**
Constructs an animal with a type
@param type the type of animal
*/
public Animal(String type) { . . . } // a non-default constructor
}
The compiler picks the constructor that
matches the construction parameters.

Common Error – Declaring a Constructor as void
◦ Constructors have no return type
◦ This creates a method with a return type of void which is NOT a
constructor!
◦ The Java compiler does not consider this an error
public class Animal
{
/**
Intended to be a constructor.
*/
public void Animal( )
{
. . .
}
}
Not a constructor…. Just another
method that returns nothing (void)

Constructors are defined in the class.
public class Animal
Constructors are used to create the objects in another class.
public class AnimalTester

Overloading Constructors
◦ Multiple constructors can have exactly the same name
◦ They require different lists of parameters
◦ Actually any method can be overloaded
◦ Same method name with different parameters
public Animal() { . . . }
public Animal(String type) { . . . }
public Animal(String type, String name) { . . . }
public Animal(String type, String name, int age) { . . . }
public Animal(String name) { . . . }

Helper Methods
toString( ) to see what is inside the instance variables
Other methods needed to use the class
haveBirthday( ) to add another year to the age
loseWeight(double weightLoss) to remove pounds
gainWeight(double weightGain) to add more pounds

Constructor this reference
Use the this reference in constructors
◦ It makes it very clear that you are setting the instance variable:
public class Animal
{
private String name;
public Animal(String name)
{
this.name = name;
}
}

public class AnimalTester
{
{
Animal dog = new Animal();
...
Testing a Class
We wrote an Animal class but…
◦ You cannot execute the class – it has no main method
It can become part of a larger program
◦ Test it first though with unit testing
To test a new class, you can use:
◦ Junit
◦ Or write a tester class:
◦ With a main

Instantiating Objects
Objects are created based on classes
◦ Use the new operator to construct objects
◦ Give each object a unique name (like variables)
You have used the new operator before:
These do NOT go into the class definition file!
Scanner in = new Scanner(System.in);

Separating the View and
Model
Scanners go in the main method
No sysouts in the classes – except for testing. Comment them out
before submission.
✔ MVC View Pattern – Model View Controller

Use the new operator to
construct objects of a class.
Animal penguin = new Animal();
Animal cat = new Animal();
Object nameClass name Class name
Creating two instances of Animals objects
AnimalTester.java
Add a main method

public class AnimalTester {
public static void main(String[] args) {
Animal dog = new Animal();
dog.setType(“Dog”);
sysout(dog.toString( ));
Animal tiger = new Animal(“Tiger”);
sysout(tiger.toString( ));

Name Bark Leaves
Leaf Size
in cm
Fruit
Zone of
Tree
Hardiness
Hackberry flaky
3 veins
at base 9 TRUE 6
Red oak smooth
matte,
variable 20 FALSE 3
English
Walnut
smooth
plates
between
fissures leaflets 45 TRUE 8

Week9 Intro to classes and objects in Java

More Related Content

What's hot (20)

Similar to Week9 Intro to classes and objects in Java (20)

More from kjkleindorfer (8)

Recently uploaded (20)

Week9 Intro to classes and objects in Java