CLASSES & OBJECTSRepresentin’ real-world things in code-spaceBrian Camodeca, Mercyhurst College

What is a class?

Defines, conceptually, some real-world thing and how the computer can build such a thing; a blueprint.

Consists of state (stuff describing the thing) and behavior (stuff the thing does).

Building a class

Classes have built-in mechanisms for state and behavior

Instance variables represent state Methods represent behaviors Consider this…

Release the hounds

What if our application needs to work with dogs?

Built-in types like integers, strings, and arrays alone can’t really help us here.

But, maybe we can unify them in this new class thingie!

Consider things about a dog…

A Dog

Name Breed Fur Color Weight Temperament Hungry Tired

Bark Beg Eat Chase Tail Fetch Sleep

State Behavior

A Dog…in code

Name : String Breed : String Fur Color : String Weight : int Temperament : String Hungry : boolean Tired : boolean

Building a class

For example, Dog.java public class Dog {

String name, breed;

int weight;

public void bark() {

System.out.println(“Woof”);

}

}

Building a class

Creating a class creates a new type If we name our class “Dog”, we can now

create variables of type Dog Dog fido;

Creating an object

An object is a given instance of a class A class is the abstract idea, an object is

the concrete example Dog fido = new Dog();

“fido” is the object, an instance of the Dog class

Manipulating the object

We can change the state of the object by manipulating its instance variables directly (for now)

For example, Dog someDog = new Dog(); someDog.name =

“Fido”; someDog.weight = 35; System.out.println(someDog.name);

Using the object

We can invoke behaviors of the object by calling its methods by name

For example, someDog.bark(); Prints “Woof!” to the console

Manipulating the object II

Before, we changed the values directly. DON’T ALLOW THIS Set instance variables as “private” and

create public “getter” and “setter” methods

For example…

Manipulating the object II

public class Dog {

private String name, breed;

private int weight;

public void setName(String name) {this.name = name;

}

public String getName() {

return this.name;

}

}

Encapsulation

But why? Encapsulation! Also known as

“information hiding” Consider this…

Encapsulation

(Assuming variables are still public) Dog someDog = new Dog(); someDog.name =

“Fido”; someDog.weight = -7; No control over what values get assigned to the instance

variables. If only we had a way to make sure-

“Setters”

Write methods to set instance variables!

public void setWeight (int weight) {

if (weight > 0) {

// phew

this.weight = weight;

}

else {

// AHHHHH! PANIC!!!

// Throw exception

}

}

“Getters”

Uh-oh, only other members of the class can “see” private members. We need a liaison!

public int getWeight() {

return this.weight;

}

The power of instance variables

Make the class dynamic! Consider the correlation between a dog’s

size and the sound of its bark…

The power of instance variables

public void bark() {

if (this.weight > 50) {

System.out.println(“Woof!”);

}

else if (this.weight > 15) {

System.out.println(“Ruff!”);

}

else {

System.out.println(“Yip!”);

}

}

The constructor

Special function that is invoked upon object instantiation

Java convention: named the same as the class’ name, and is that class’ return type

For example…

The constructor

public Dog() {// Do Something

}

The constructor

public Dog(String name) {

this.name = name;

}

public Dog(String name, String breed) {

this.name = name;

this.breed = breed;

}

The toString() method

A method that returns a string representation of that object.

By default it’s not very helpful, but we can implement our own toString() method!

@Override

Where is “static”?

Static members of a class can be accessed without an instantiation, like our readLine() method.

All our variables pertain to the particular instance of the dog, therefore they are non-static.