Serge.V Lumber Barn

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
[ [[tutorial-en-001 | Intro]]    | [[tutorial-en-002 | Begin]] |
[[tutorial-en-003 | if/else]]    | [[tutorial-en-004 | Loops]] |
[[tutorial-en-005 | Arrays]]     | [[tutorial-en-006 | Graphics]] |
[[tutorial-en-007 | Animation]]  | [[tutorial-en-008 | Mouse]] |
[[tutorial-en-009 | Game]]       | [[tutorial-en-010 | Real]] |
[[tutorial-en-011 | Methods]]    | [[tutorial-en-012 | Class]] |
[[tutorial-en-013 | Class 2]]    | [[tutorial-en-014 | Applet]] |
[[tutorial-en-015 | MouseClick]] | [[tutorial-en-016 | Thread]] |
[[tutorial-en-017 | Button]]     ]
----
====== Java Classes ======

A Java class is a reusable entity. It is self-contained and may be
thought of as an object like a fish or a rock or book. In a Space Invaders
game  you might have an  alien class, a defender class, a bullet class,
a bomb class and a game class that controls the whole thing. If I wanted
to write another game that had baddies, i might be able to reuse
the aliens and bullet classes. classes can be thought of as modular.
They are connected together through methods. Let's make an example
to show you:
<code java>
    public class Employee{
	private int empNum;

	public void setEmpNum(int _x) {
		bulletx = _x;
	}
	public int getEmpNum() {
		return empNum;
	}
    }
</code>

A class needs an access modifier, the word "class" to signal what it is,
and a unique name. Our Employee class has only one variable - its employee
number. It is private so that it cant be hacked into from outside. The only
access to it is through the set and get methods. The set method(setEmpNum)
allows other classes to access the Employee class and change
the empNum variable. The get method(getEmpNum) allows access to what
the value of it is.

Say you had an managing class called Accountant. It might be something
like this:
<code java>
    public class Accountant {
	public static void main(String[] args) {
	    // create an instance of class Employee called steve
	    Employee steve = new Employee();

	    steve.setEmpNum(234);
	    System.out.println("Steve: Employee Number:" + steve.getEmpNum());
	}
    }
</code>

But what is this line:
<code java>
Employee steve = new Employee();
</code>
What is that? What we have done in this line is to INSTANTIATE
the Employee class. We have made a clone of the Employee class
and named it steve.

We use the keyword new to allocate memory for it and to make
a new copy of that class.

Employee() is the CONSTRUCTOR. I allows us to create copies.

Later on we will write our own constructor methods, but for now
we will use the default inbuilt constructor.

Lets write our own Alien class for our game. What do you think it will need?

A position (x and y), and a boolean flag to tell when it has been hit.
Let us have a go at it:
<code java>
    public class Baddie {
	// declare our variables
	private int xpos;
	private int ypos;
	private Boolean isHit;

	// declare our methods
	public void setXpos(_x) {
	    xpos = _x;
	}
	public void setYpos(int _y) {
	    ypos =_y;
	}
	public void setHit(boolean hitFlag) {
	    isHit = hitFlag;
	}
	public int getXpos() {
	    return xpos;
	}
	public int getYpos() {
	    return ypos;
	}
	public boolean getIsHit() {
	    return isHit;
	}
    }
</code>

So how are we going to use this class? Make a Game class that controls
our baddies. Try something like  so:
<code java>
    public class Game {
	public static void main(String[] args) {
	    String aliveOrDead;

	    // instantiate a baddie
	    Baddie pugwort = new Baddie();
	    pugwort.setXpos(50);
	    pugwort.setYpos(100);
	    pugwort.setHit(true);
	    if (pugwort.getIsHit == true) {
		aliveOrDead = "Dead";
	    } else {
	        aliveOrDead = "Alive";
	    }
	    System.out.println("pugwort is at " + pugwort.getXpos() +
		": " + pugwort.getYpos() + " and he is " + aliveOrDead);
	}
    }
</code>

What did you get? Where was he? Was he dead or alive? What did we do
in Game class?

  * Set up a variable to output whether the baddie was dead or not
  * Instantiated a new Baddie named pugwort
  * We called methods of Baddie through our created Baddie, pugwort
  * set the x:y position to 50:100
  * We killed the baddie by setting its isHit flag to true
  * Did an if check to see whether isHit was true or false and according to the answer, set our output variable, aliveOrDead, accordingly
  * Printed out the position of pugwort and whether it was dead or not

===== Java Class Constructors =====
A constructor is something like a method in that has Parentheses.
It may be thought of as a method that constructs a class object.
You can write your own constructor methods but if you don't Java
writes one for you automatically. Called the default constructor.
Any constructor you write must have the same name as the class and
cannot have a return type.

It is usually called in the form of:
<code java>
    Object anotherObject = new Object();
    // or
    ClassName instantiatedName = new ClassName();
    // e.g.
    Defender superDork = new Defender();
</code>

Lets make a java class constructor for our Employee class.
It will have another variable which will be the same for all
employees  - the salary. Let's do it:

<code java>
    public class Employee {
	private int empNum;
	private double salary;

	// overwrite our default constructor
	Employee() {
		salary = 300.00;
	}

	// access methods
	public void setEmpNum(int _x) {
		bulletx = _x;
	}
	public int getEmpNum() {
		return empNum;
	}
    }
</code>

Any employee instantiated will have a default salary of $300.00.

=== Exercise ===
Create a Circle class with attributes of radius, area and diameter.
Use a constructor that sets the radius to 1.

Write methods such as setRadius, getRadius, computeArea and computeDiameter.
Hints:
  Diameter = 2 * radius
  area = PI * Radius * Radius

Create another class called TestCircle and instantiate 3 Circles.
Use the get and set methods for Circle and compute the diameter and
area of each circle and display those statistics.

[[tutorial-en-013 | Next lesson]]
we will get more into writing constructors and delving
deeper into the murky depths of classes.