Coding Bootcamp: Creating classes

Defining the term class

Is a blueprint/recipe/template that creates objects of specific types. Objects are also called instances of a class
Encapsulates data (fields/variables) and behaviour (methods) in a single unit

Class representation

Porting a 'logical' entity into a class

Circle's attributes:
x coordinate
y coordinate
radius

Class name

public class Circle {
    /* class body */
}

Public is the access modifier of the class. Public makes this class visible to classes in other packages
Important
Filenames should have the same name with the class ending with the .java extension
Good practice:
Class names should begin with a capital letter and follow the camel-case style
Examples: MyCustomClass, DatabaseConnection

Instance variables

class Circle {
    /* Instance variables are defined here*/
    
    /* Point x coordinate */ 
    private int x;
    /* Point y coordinate */
    private int y;
    /* Circle's radius */
    private int radius;
}

Fields have a type, a name and (optionally) an access modifier
Good practice:
Instance variables' names should begin with a lower-case letter and follow the camel-case style. Example: firstName, lastName, telephoneNumber
Instance variables should have a private access modifier

Class methods

class Circle {

    /* Point x coordinate */ 
    private int x;
    /* Point y coordinate */
    private int y;
    /* Circle's radius */
    private int radius;

    /* Methods are defined here */

    /* Returns the x coordinate */
    public int getX() { return x; }
    /* Returns the y coordinate */
    public int getY() { return y; }
    /* Returns the radius */
    public int getRadius() { return radius; }
}

Methods, have a (return) type, a name, (optionally) an access modifier and (optionally) one or more arguments/parameters

Access modifiers

public - visible to all classes
private - visible only inside the current class
protected - Visible only to subclasses of the current class
Good practices:
All fields should be private
Methods that are not design to interact with other classes should also be private

Getters and setters methods

Fields should be accessed and modified only through dedicated methods

class Circle {

/* x and y coordinates and radius */
private int x;
private int y; 
private int radius;

/* getters and setters methods */
public void setX(int x) { this.x = x; }
public int getX() { return this.x; }
public void setY(int y) { this.y = y; }
public int getY() { return this.y; }
public void setRadius(int r) { this.radius = r; }
public int getRadius() { return radius; }
}

Getters and setters methods

Recommended way to access or modify fields

Circle c = new Circle();
c.setX(5);
c.setY(3);
System.out.println("Hello, I'm circle (" + p.getX() + "," + p.getY() + ")");

I'm circle (5,3)

And never directly (this would be possible only if x and y instance variables had public access

Circle c = new Circle();
c.x = 5;
c.y = 3;
System.out.println("Hello, I'm circle (" + p.x + "," + p.y + ")");

The keyword this

class Circle {

    /* x and y coordinates and radius */
    private int x;
    private int y; 
    private int radius;

    public void setCoordinates(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

The keyword this refer to the instance variables
Good practice:
Always use this when you are refering to an instance variable

Anatomy of a method

public double getPerimeter(double pi) {
    double perimeter = 2*pi*this.radius;
    return perimeter; 
}

public : access modifier
double : return type
getPerimeter : name
pi : argument/parameter of type double named as pi

A method's signature is the method name + the parameters. Signature defines how a method can be Overloaded
```
public double getPerimeter(double pi)
```

Non-returning methods

void methods perform an operation without returning a value

public void printPerimeter(double pi) {
    double perimeter = 2*pi*this.radius;
    System.out.println("Perimeter is " + perimeter); 
}

Overloading methods

Is the ability to have more than one methods with the same name but with different parameters. Different in sense of, type, number and order

/** valid overloaded methods **/
public void dummy() {}
public void dummy(String message) {} // different number of arguments
public void dummy(String message, int number) {} // different number of arguments
public void dummy(int number) {} // different number of arguments
public void dummy(int number, String message) {} // different order of arguments
public void dummy(float number) {} // different type of arguments
public int dummy(String message, double d) { return 0; } // different return type. The return type does not affect the overloading process
private void dummy(int[] array) {} // different type of arguments. Private does not affect the overloading process
public static void dummy(double real) {} // static modifier does no affect the overlaoding process
public final void dummy(float f1, float f2) {} // final modifier does no affect the overlaoding process

/** invalid overloaded methods **/
public void dummy(String text) {} // different argument name but same type
public void dummy(String message, int x) {} // the same as above

In other words, only the signature of the method affects its overloading ability

Constructor - a special method!

/* default constructor */
Circle() {
    this.x = this.y = 0; // you can omit this line. x and will be initialized to zero either way. 
    this.radius = 3;
}

Creating an object of type Circle:
```
    Circle c = new Circle();
```
Constructors should have the same name with the class
Constructors inherit the class's access modifier

Overloaded constructor

/* Overloaded constructor */
Circle(int x, int y) {
    this.x = x;
    this.y = y;
    this.radius = 3; //hard coded
}
/* Overloaded constructor */
Circle(int x, int y, int r) {
    this.x = x;
    this.y = y;
    this.radius = r;
}

Creating instances of type Circle:

    Circle c1 = new Circle();
    Circle c2 = new Circle(4,4);
    Circle c3 = new Circle(3,4,5);

Chaining constructors

Similarly, a constructor with the this call can trigger any other constructor in the class!

/* default constructor */
Circle() {
    this.x = 0;
    this.y = 0;
    this.radius = 3;
}
/* Overloaded constructor calling the default 
   constructor with the use of this */
Circle(int x, int y) {
    this();
    this.x = x;
    this.y = y;
}

Creating instances of type Circle:

    Circle c2 = new Circle(2,3);

Copying objects

Circle c1 = new Circle(5,2,5);
Circle c2 = new Circle(10,4,10);
c2 = c1;

The perimeters of c1 and c2 are equal or different?

Memory allocation

Circle c1 = new Circle(5,2,5);
Circle c2 = new Circle(10,4,10);
c2 = c1;

Copying objects (2)

c1.calculatePerimeter();
c2.calculatePerimeter();

Results to:
```
Perimeter is 18.84
Perimeter is 18.84
```

Copying objects (3)

Circle c1 = new Circle(5,5);
Circle c2 = c1;
c2.setRadius(10);
c1.calculatePerimeter();
c2.calculatePerimeter();

Are the perimeters equal or not?

Copying objects (4)

Circle c1 = new Circle(5,5);
Circle c2 = c1;
c2.setRadius(10);
c1.calculatePerimeter();
c2.calculatePerimeter();

Results to:
```
Perimeter is 18.84
Perimeter is 18.84
```

Copy constructor

/* Regular Overloaded Constructor */
Circle(int x, int y, int r) {
    this.x = x;
    this.y = y;
    this.radius = r;
}

/* Copy Constructor */
public Circle(Circle original) {
    this(original.x, original.y, original.radius);
}

Copying/cloning an object process:
Create a new object of type circle
Assign the values of the old object to the new

Return the new object

Circle original = new Circle(5,2);
Circle copyOfOriginal = new Circle(original);

Garbage Collector and Destructor method

/** Circle destructor */
public void finalize() {
    System.out.println("Circle (" + 
        this.x +"," + this.y + "," + this.radius + ") deleted");
}

Release the memory and run the garbage collector

c = null;
System.gc(); // Garbage Collector call

Results to
```
Circle (5,5,10) deleted
```
The garbage collection is a process that identifies unused object that are no longer referenced by any part of your program and reclaims the allocated memory

Static fields and methods

class Circle {
    /* counts the number of the created circles */
    public static int count;

    /* Constructor */
    Circle() {
        count += 1; // increase count by one after creating a new circle 
    }
}

Static fields are common for all instances of the class

Circle c1 = new Circle();
Circle c2 = new Circle();
System.out.println("c1 count is " + c1.count); //c1.count gives a warning. Why?
System.out.println("c2 count is " + Circle.count);

Static fields and methods (2)

c1 count is 2
c2 count is 2

Static methods can access only static fields (Doesn't apply on Constructors) If count was private we would need a get method to access it as follows
```
public static int getCount() { return count; }
```

Static methods can be called by other classes only by the name of the class

System.out.println("Number of existing circles : " + Circle.getCount());

Number of existing circles : 2

Memory allocation of static fields

Circle c1 = new Circle();
Circle c2 = new Circle();

The final modifier

In our previous Circle class example we add the following field
```
/* The unique id of a circle */
private final int id;
```

We are obliged to initialize the field id

/* Modified constructor */
Circle() {
    this.x = 0;
    this.y = 0;
    this.radius = 3;
    count += 1;
    /* we assign the current count as the circle's id */
    id = count; 
}

final fields cannot change their value/state after their initialization

The final modifier (continued)

As in the static example, we execute the following commands

Circle c1 = new Circle();
Circle c2 = new Circle();
Circle c3 = new Circle();

System.out.println("c1 count is " + Circle.getCount() +  ", id is " + c1.getId());
System.out.println("c2 count is " + Circle.getCount() +  ", id is " + c2.getId());
System.out.println("c3 count is " + Circle.getCount() +  ", id is " + c3.getId());

Which result the following output

c1 count is 3, id is 1
c2 count is 3, id is 2
c3 count is 3, id is 3

Singleton

class DBConnector
{
    /* unique instance of the class */
    private static DBConnector unique_db_connection_instnce;

    /* Private constructor of the class */
    private DBConnector()
    {
        ... 
    }

    /* method that creates (if not initialized)
    and returns the unique_db_connection_instnce of the class */
    public static  DBConnector getInstance()
    {
        if (unique_db_connection_instnce == null)
            unique_db_connection_instnce = new DBConnector();

        return unique_db_connection_instnce;
    }

    /* sample method */
    public void connect()
    {
        ... 
    }
}

Only one instance of a Singleton class can exist at a time
The constructor is private

Classes as custom types

class Laptop {
    /* The serial number of the product */
    private String serialNumber;
    /* Custom class representing the central processor unit */
    private Cpu cpu;
    /* Custom class representing the random access memory */ 
    private Memory memory;
    /* Custom class representing the Operating system license
       The license is bound to this Laptop object */
    private OSLicense osLicense;
}

Custom types behave as normal primitive type fields

Classes as custom types (continued)

class Laptop {
    private String serialNumber;
    private Cpu cpu;
    private Memory memory;
    private OSLicense osLicense;

    /* Constructor */
    Laptop () {
        this.serial_number = "XXXX-XXXX-XXXX-XXXX";
        this.cpu = new Cpu();
        this.memory = new Memory();
        //osLicense is not initialized
    }
}

Not initialized objects have the null value

Deep vs shallow copies

Copying complex objects (that have other non-primitive types as instance variables) can be tricky. If we copy only the top object of the hierarchy we end up having a shallow copy of the object, as shown in slide "Memory allocation"
In order to have a complete (deep) copy of this object, we need to ensure that all objects (in all hierarchies) are also copied properly, with their copy constructors.
Avoid using the clone() method that all objects inherit from their Object superclass if you haven't properly overidden them.

Packages

Groups of related parts (Classes) of a system
Provide access control to classes between other packages

Relationship among classes

Simple dependency

An instance b of type ClassB is used and exists only in the scope of a method of ClassA

Association/Aggregation

ClassA holds an instance of ClassB
The aggregated object b can live even after the destruction of the ClassA's instance

Composition

ClassA, like in Association/Aggregation holds an instance of ClassB
ClassA is responsible for object's b lifecycle and object b should be destroyed upon ojbect's a destruction.

References

Thinking in Java (4th Edition) - B. Eckel
Object Oriented Design - A. Chatzigeorgiou
Oracle Certified Professional Java SE 8 Programmer Exam 1Z0-809, A Comprehensive OCPJP 8 Certification Guide - S. G. Ganesh, Hari Kiran, Tushar Sharma
Java Programming - wikibooks (link)
Java™ Platform, Standard Edition 8 API Specification (link)
Contact details
email: antoniosgkortzisATgmailDOTcom
slack: agkortzis

Exercise 1

Step 1: Create a class that represents a circle shape. The class should be named as Circle and include the following three integer fields:
x : the x coordinate
y : the y coordinate
r : the radius

Choose appropriate access modifiers for the fields so that they cannot be accessed by other classes.

Exercise 1 (continued)

Step 2: Create methods that provide access and modification (getters and setters) to the x, y and r fields.
Choose appropriate names that briefly describe the functionality of each method
Choose appropriately the return type and access modifiers of your methods

Exercise 1 (continued)

Step 3: Create a default constructor that initializes a Circle to x=y=0 and r=5
Step 3.1: Create an overloaded constructor that initializes all three instance variables
Step 4: Create a method printCircleDetails that prints the details of your circle in the following message
* I'm a circle at point (x,y) with radius r
Where x,y and r are the values of the current circle

Exercise 1 (continued)

Step 5: Create a new class named TestCircles in the same package (directory) as your Circle class.
Create a main method in your TestCircles class. In the main method:
create a circle object,
assign values (of your preference) to the object using the setter methods from Step 2 and
print the details of your circle using the printCircleDetails method from Step 3
Compile and run your program!

Exercise 1 (continued)

Step 6: Create an overloaded constructor which will initialize the x & y instance variables. The r instance variable should be initialized by calling the constructor from Step 3
In your main method, create objects using each one of the (now three) available constructors and print (using the print method) your objects

Exercise 1 (continued)

Step 7: Extend the functionality of your class by adding the following two methods:
the calculateArea which will calculates and returns the area (π*radius*radius, π=3.14) and
the calculatePerimeter which will calculates and returns the perimeter (2*π*radius, π=3.14)
Choose the appropriate return types for your methods
Test the functionality of the two new methods with the Circles that you created earlier in your main method

Exercise 1 (continued)

Step 8: Add to your class a static and final field name pi (for π). Initialize its value upon declaring the field. Then, modify your calculateArea and calculatePerimeter methods of Step 7 so that they make use of the new pi field.

Exercise 1 (continued)

Step 9: Create a copy constructor for your Circle class.
Create two circles where the second one will be a copy of the first one
Print their details
Change the values of the first circle and print again their details
What do you observe? Explain your findings according to the memory allocation in slide #17

Exercise 1 (continued)

Step 10: Create a method name cocentric that checks if two circles share the same centre (co-centric circles). The method should return true if circles are co-centric, or false if circles have different centres.
What is the return type of the method?
What type of argument should your method have?

Exercise 1 (continued)

Step 11: Declare a field named numberOfCreatedCircles that is common to all instances of class Circle and counts the number of the created circles. Think carefully of:
the type of your numberOfCreatedCircles field,
any special modifiers that might need and,
the place/places that the value of the field should be incremented

Exercise 2

Create a class diagram (on paper or any other tool) for the relation among the following entities (Each entity is a Class):
There is a Car that has a CarLicense. The CarLicense cannot exist without a Car.
There is a Driver that owns (only one) DriversLicense. The DriversLicense cannot exist without a Driver.
The Driver owns one or more Cars. The Car exists even without a Driver.

Exercise 2 (continued)

Use the correct UML connectors for the above relations among the entities
Create the skeleton source code for the above classes (no need for fields, constructors or methods) and compile it

Exercise 3

You have the following relations between entities:

There is a Library that has a collection (single dimension array) of Books
Each Book has an Author
The Library is operated by a Librarian
The user can make requests regarding authors' and book availability only by asking the Librarian
For all of the following classes, additional to the requirements described in the slides, create the getter and setter methods (only where is needed) for interacting with their instance variables and any necessary constructors

Exercise 3 (continued)

Class Author
Fields:
name, of type String
Methods:
toString, return type String, returns the name of the author

Exercise 3 (continued)

Class Book
Fields:
title, type String,
author, type Author,
isbn, type String,
physicalCopies, type int,
availableCopies, type int, and
timesRented, type int
Important :
isbn cannot change after the initialization

Exercise 3 (continued)

Class Book
Methods:
toString, return type String. Returns the details of the book including the Author details. The Authors' details should be acquired by the proper toString method
rentPhysicalCopy, type void. Checks if there is an available copy for renting. If yes, then it prints a message of success. What fields should be modified upon a successful rental?
isAvailable, return type boolean. Checks if there is at least one available physical copy of the book, and
hasAuthor, return type boolean. Checks if a given name is the name of this book's author

Exercise 3 (continued)

Class Library
Fields:
books, type Book[] (array of Books)
Methods:
printAvailableBooks, type void. Prints books that have at least one available physical copy. Hint: Use the isAvailable and the toString methods from the Book class
printBookDetails (Searches for a book based on a given title. If the book exists then its details should be printed, otherwise an error message should be displayed)

Exercise 3 (continued)

Class Library
Methods:
printBooksFromAuthor, type void. Prints only the books that have an author that matches a given name
printTheMostPopularBook, type void. Prints the book with the highest number of the timesRented field.

Exercise 3 (continued)

Class Librarian
Fields:
library, type Library. The library that he manages.
Methods:
findMeBooksFromAuthor, type void. Receives an author name and delegates the request to the library's printBooksFromAuthor method
findMeAvailableBooks, type void. Delegates the request to the library's printAvailableBooks method
findMeBook, type void. Receives a book's title and delegates the request to the library's printBookDetails method
findMostPopularBook, type void. Delegates the request to the library's printTheMostPopularBook method

Exercise 3 (continued)

Create a TestLibrary class with a main method in which you will execute the following code block:

/** Create Random authors */
Author ruth = new Author("Ruth");
Author diane = new Author("Diane");
Author jacqueline = new Author("Jacqueline");
Author rachel = new Author("Rachel");
Author joan = new Author("Joan");
Author theresa = new Author("Theresa");
Author angela = new Author("Angela");
Author helen = new Author("Helen");
Author lisa = new Author("Lisa");
/** Create Random books from the above authors */
Book book1 = new Book("Book1",ruth,"368777540-2",10,2,20);
Book book2 = new Book("Book2",diane,"963099898-2",10,1,22);
Book book3 = new Book("Book3",jacqueline,"005382097-2",10,0,23);
Book book4 = new Book("Book4",rachel,"538310208-2",10,3,24);
Book book5 = new Book("Book5",joan,"562448132-2",10,4,26);
Book book6 = new Book("Book6",theresa,"670364563-2",10,2,21);
Book book7 = new Book("Book7",angela,"466916869-2",10,5,17);
Book book8 = new Book("Book8",helen,"764674973-2",10,0,15);
Book book9 = new Book("Book9",lisa,"052469721-2",10,6,17);
Book book10 = new Book("Book10",ruth,"609291817-2",10,3,13);
Book book11 = new Book("Book11",diane,"451378028-2",10,8,12);
Book book12 = new Book("Book12",jacqueline,"142352773-2",10,6,20);
Book book13 = new Book("Book13",rachel,"115135166-2",10,0,20);
Book book14 = new Book("Book14",joan,"631942468-2",10,3,20);
Book book15 = new Book("Book15",theresa,"323662444-2",10,0,23);
Book book16 = new Book("Book16",angela,"121360492-2",10,0,12);
Book book17 = new Book("Book17",helen,"391199302-2",10,0,20);
Book book18 = new Book("Book18",ruth,"549307784-2",10,1,20);
Book book19 = new Book("Book19",ruth,"368777230-2",10,23,20);
Book book20 = new Book("Book20",ruth,"793027213-2",10,0,20);
/** Add the books to a Book array*/
Book[] books = {book1,book2,book3,book4,book5,book6,book7,
book8,book9,book10,book11,book12,book13,book14,book15,
book16,book17,book18,book19,book20};/** Assign the book collection to the library */
Library library = new Library(books);
/** Librarian, theGuyWhoKnowsAlot, undertakes the operation of the library */
Librarian theGuyWhoKnowsAlot = new Librarian(library);
theGuyWhoKnowsAlot.findMeAvailableBooks();
theGuyWhoKnowsAlot.findMeBook("Book3");
theGuyWhoKnowsAlot.findMeBooksFromAuthor("Ruth");
theGuyWhoKnowsAlot.findMostPopularBook();

Compare your output to the one in the next slide

Exercise 3 (end)

The expected output (format can vary between different implementations) after the running the code from the previous slide is:

The following books are available at the library for renting
Books available for renting:
    1. Book [title=Book1, author=Ruth, isbn=368777540-2, physicalCopies=10, availableCopies=2, timesRented=20]
    2. Book [title=Book2, author=Diane, isbn=963099898-2, physicalCopies=10, availableCopies=1, timesRented=22]
    3. Book [title=Book4, author=Rachel, isbn=538310208-2, physicalCopies=10, availableCopies=3, timesRented=24]
    4. Book [title=Book5, author=Joan, isbn=562448132-2, physicalCopies=10, availableCopies=4, timesRented=26]
    5. Book [title=Book6, author=Theresa, isbn=670364563-2, physicalCopies=10, availableCopies=2, timesRented=21]
    6. Book [title=Book7, author=Angela, isbn=466916869-2, physicalCopies=10, availableCopies=5, timesRented=17]
    7. Book [title=Book9, author=Lisa, isbn=052469721-2, physicalCopies=10, availableCopies=6, timesRented=17]
    8. Book [title=Book10, author=Ruth, isbn=609291817-2, physicalCopies=10, availableCopies=3, timesRented=13]
    9. Book [title=Book11, author=Diane, isbn=451378028-2, physicalCopies=10, availableCopies=8, timesRented=12]
    10. Book [title=Book12, author=Jacqueline, isbn=142352773-2, physicalCopies=10, availableCopies=6, timesRented=20]
    11. Book [title=Book14, author=Joan, isbn=631942468-2, physicalCopies=10, availableCopies=3, timesRented=20]
    12. Book [title=Book18, author=Ruth, isbn=549307784-2, physicalCopies=10, availableCopies=1, timesRented=20]
    13. Book [title=Book19, author=Ruth, isbn=368777230-2, physicalCopies=10, availableCopies=23, timesRented=20]
Book with title= 'Book3' found! Details: 
    Book [title=Book3, author=Jacqueline, isbn=005382097-2, physicalCopies=10, availableCopies=0, timesRented=23]
Book with author= 'Ruth' found! Details:
    Book [title=Book1, author=Ruth, isbn=368777540-2, physicalCopies=10, availableCopies=2, timesRented=20]
Book with author= 'Ruth' found! Details:
    Book [title=Book10, author=Ruth, isbn=609291817-2, physicalCopies=10, availableCopies=3, timesRented=13]
Book with author= 'Ruth' found! Details:
    Book [title=Book18, author=Ruth, isbn=549307784-2, physicalCopies=10, availableCopies=1, timesRented=20]
Book with author= 'Ruth' found! Details:
    Book [title=Book19, author=Ruth, isbn=368777230-2, physicalCopies=10, availableCopies=23, timesRented=20]
Book with author= 'Ruth' found! Details:
    Book [title=Book20, author=Ruth, isbn=793027213-2, physicalCopies=10, availableCopies=0, timesRented=20]
Most popular book: 
    Book [title=Book5, author=Joan, isbn=562448132-2, physicalCopies=10, availableCopies=4, timesRented=26]
Book with title:'Book0' not found
Book with author:'angor' not found

Exercise 4 (BONUS!)

Create a command-line user interface for Exercise 3, providing the user, at least, the following options:
Welcome to the Bootcamp library.
How do you want to proceed?
1. Show all available books
2. Search for a book (by book title)
3. Display books from a specific author
4. Show me the most popular book
q. Quit
>
Create (a fully detailed) class diagram for the entities described in exercise 3.

This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.