Goals

• To learn know enough about objects to use Java
  • To understand Java access control
  • To understand proper object encapsulation - the getter and setter
  • To understand interfaces
  • To understand class and instance variables
  • To understand class and instance methods

Resources

Java Interfaces

Access Control

It is time to begin to make the transition to using full Java objects. Java offers a number of features for object-oriented programming. In this module, we will highlight a few of the most important features. You can do more than this with objects, but this should be enough to get you started. You can read more at the Java tutorial.

Let's start with access control. There are two types of access control:

• public
• private

These are Java keywords use to indicate whether a method or variable can be accessed from a reference variable. A public method or variable can be accessed using the reference variable. A private one can not. Its scope is limited to the definition of the class. Let's take a look.

class Ball { //private access modifiers will help protect our fields public float xPos, yPos; private float xVel, yVel; //Constructors are always public Ball(){ ... } //The update method is private private void update() { ... } //The draw method is public public void draw() { ... } } void setup(){ Ball b = new Ball(); b.xPos = 10 // works b.xVel = 2; // error: xVel is private. b.draw(); // works b.update(); // error: update() is private }

Why?

We do this in order to keep the interface, the methods and variables accessible from the reference variable to a minimum. Sometimes variables are only used inside the object. The should never be changed by a programmer who using instances of the object, so we hide them. As you design your objects, you want to expose only the most important details. Everything else should stay locked inside of the object.

Getter / Setter

If you set a variable to be private, it means you can't change its value. What's happens if you need to? That is what a getter and setter is for. A getter / setter is a public method for changing the value of a private variable.

It might seem a little clumsy to use a getter / setter at first, but the power comes in when you want to do something special like storing the radius in addition to its diameter.

class Ball { private int radius; private int diameter; Ball(){...} public void draw() {....} private void update() { ....} public void setSetDiameter(int d){ radius = d/2; diameter = d; } public int getDiameter(){ return diameter; } }

Interfaces

An interface is a description of what an implementing object can do. It like the buttons on a controller. It is a list of methods. It does not include any implementation. We use interfaces to describe the possible behaviours of all the implementing objects. An object can implement multiple interfaces.

// describes what all Balls should do. interface Ball { abstract void draw(); abstract void move(); } interface Collider { abstract boolean checkBounds(int width, int height); } class BouncyBall implements Ball, Collider { //some variables BouncyBall(){ ... } //implement move void move(){ //code for moving the bouncy ball } //implement draw void draw(){ //code to draw the ball } //implement checkBounds boolean checkBound(int width, int height){ //code to check the ball's position inside the bounds. } }

Methods

There are two different kinds of methods:

• class
• instance

A class method is a method that is defined one and stored in memory only once for every instance of the object created. An instance method is a method that has a copy stored in memory for each instance of the object.

class Ball { PVector position; PVector velocity; Ball(){ ... } //each instance will have its own copy of the method void update() { ... } //only one copy of the method will be created static void draw() { ... } }

Variables

A variable can also be static. It means that all instances of the class share the variable.

A variable can also be declared final. This means that it will never change. We often tell Java that a variable is a constant by declaring that it is both static and final.

class Ball { static final int BALL_SIZE = 10; static int ballCount = 0; PVector velocity; Ball(){ ballCount += 1; } int getNumberOfBalls(){ //return the number of Ball objects that have //been instantiated by during the run of program return ballCount; } ... }