Java: Classes, Objects, and Methods

Chapter 1: Review of Classes, Objects, and Methods

• A class combines multiple variables (potentially of different types) into a new type.
• Attributes/instance variables/fields are variables of a class.

Classes and Objects

• Instances are objects of a class, created explicitly using "new".
• Variables of class types are actually pointers/references to objects.
• Instance variables are accessed using "Dot-Notation".

Class Methods

• Data typically has associated operations (methods) in Object-Oriented Programming.
• A class defines the data and its associated methods.
• Methods are typically invoked via an object/object variable with "Dot-Notation".
• Methods can have or not have a return value
• Methods can have formal/actual parameters and use call-by-value

Data Encapsulation

• Modifiers are used in Java to control access rights to instance variables and methods.
  • private: Accessible only from within the class definition.
  • protected: Accessible from all subclasses and classes within the declaring package.
  • No modifier: Accessible from all classes within the declaring package.
  • public: Accessible from any class.
• Data encapsulation involves declaring instance variables as private.
• Access to the data is provided through public methods.
• Public parts of a class are referred to as the interface

Constructors and Static Methods

• Constructors are special methods invoked during object creation using new.
• Static methods and variables belong to the class itself, not to any specific object.
• Overloading methods (multiple methods with the same name) is allowed, differentiated by parameter lists.

Inheritance

• Inheritance is the mechanism for creating a class hierarchy

Superclasses & Subclasses

• Subclasses are built from existing classes through specialization/generalization.
• A subclass (child class) inherits properties from the superclass (base class).
  • Subclasses can add new instance variables and methods.
  • Subclasses can override existing methods to modify behavior

Polymorphism in Java

• Polymorphism means "many forms".
• Multiple types are allowed in the same context
  • With potentially different results.
• Java includes two types of Polymorphism

Polymorphism: Type Families

• If B is a subclass of A, a B object can be used wherever an A object is expected such as assignment or a parameter.
• The principle of type families works because B objects have all the properties of A objects.

Polymorphism: Method Invocation and Dynamic Binding

• If B is a subclass of A and B overrides method m from A then when calling method r.m(...) the version of the method to be executed is decided on the class of referenced object by r, not the type of r
• Dynamic Binding: Specific method implementation determined at runtime

Abstract Classes

• Methods without implementation, i.e., without a body are called abstract methods
• Abstact Classes: if any method in a class is abstract the class is considered an abstract class.
• No objects can be created from abstract classes.
• Subclasses should implement all abstract methods.
• Abstract class defines "interface" and has an abstract type

Chapter 2: Interfaces

• Motivation for interfaces example:
  • Calculating average balance of bank accounts
  • Calculating average area of simple graphic objects
  • The base algorithm is the same but the objects are different

Common operations

• The base algorithm remains the same and needs to be implemented
• A common type from bank account and graphic object is needed such as "something measureable: a measure"
• Should be implemented across all classes e.g. getMeasure()

Interface Declaration

• Define an interface if different classes have the same properties
• public interface Measurable { double getMeasure(); }
• Interfaces:
  • Contain abstract methods such as functions which are automatically public
  • Can declare static constants
  • Can contain the static and default methods in Java 8 or later
  • Are implemented in each class

Implementing Interfaces

• Interfaces do not create class hierarchy
• Classes implement the declared interface
• Classes implement interfaces such as: public class Account implements Measurable{... public double getMeasure(){ return balance; }...}
• Any class can implement an interface

Interface type

• The concept of interfaces define a type
• i.e. an interface defines all the properties of implemented objects
• No objects of an interface can be generated, however references to implementing classes can be create
• References of a type using an implementing interface can only access defined properties in the interface

Chapter 3: Generic Classes and Types

• Motivation: Container class to manage data or a list needs to perform several operations like add, get, isEmpty etc.
• To avoid having to rewrite container classes the question arises is it possible to implement the essential operations once and use them for distinct types or classes?
• This is possible through data structures for upper class objects for specific Java, or can be accomplished using generic classes or types

ArrayList Example

• The ArrayList<E> class is used to manage data in the form of a list
• Has a type parameter E that is used to apply to this class
• The class definition placeholder is E
• A list is made by specifying the type in angled brackets e.g. ArrayList<String> strList =new ArrayList<String>();

Creating a Generic Class

• To create generic classes create class to save and call object of any given type with a class called GenericBox
• Create a generic class with the type E, K, V, T in angular brackets such as public class GenericBox<T> { private T content; public GenericBox() {content = null; } public void set(T e) { content = e; } public T get() { return content; }}

Generic Type Creation

• Create particular types by defining <String> or <Integer> e.g. GenericBox new GenericBox<String>();

Properties

• With a Typparameter is generic
• Types are implemented in the compiler with concrete types
• Types need to be reference types, not primitive
• Generic types are defined for both classes and interfaces
• A concrete type must be defines, and implement all proper compile-time properties
• Classes can be built with multiple type parameters

Generic and Limited Types

• Generic typparameters can be implemented with with Generics, to only perform generic methods
• The operation or method will be implemented one time
• Method findMax will find the element in the array
  • Use integers by comparing < or >
  • Use Strings to compare with alphanumeric methods with compareTo
  • Use circles to compare area
• Ensure each class has consistent comparable types

Restricted Types (2)

• It is possible to use specific interfaces for implementations by comparing comparable types from Java API such as compareTo
• Using the previous pattern enables comparing different elements by declaring if comparable must be followed, such as whether x is smaller, larger, or the same as y. Where a class implementing the interface belongs to the correct type.

Restricted Types (3)

• Generic methods have restricted types that will only use findMax based on the parameters
• Generci methods will specify a parametric front, and return the void type
• Limited typparameters implement classes such that any type is inspected to ensure any requirements have been followed

Chapter 4: Dynamic Data Structures and Inner Classes

• A disadvantage to arrays or container classes with dynamic ArrayList is that the capacity is typically fixed, such that any extension is time consuming
• Objects being handled by reference or by pointers
• Objects being loaded at runtime with "new"
• The object itself can be loaded as subsequent or child nodes
• Generation at runtime allows for shrinkage and growth, limited by only total memory
• Data size is not set in the forefront
• These aspects describe a dynamic data structure

Dynamic Data Structures and Nodes

• Objects within a dynamic structure, are typically called "nodes"
• Data such as lists, trees and graphs are data structures
• Lists use a pointer or linkers to the next node
• Tree connections enable several child nodes with a max number of predecessors
• Graphs allow many child or previous values

Node Chains

• For value list node links, any list contains an arbitrary number of data that must be extracted.
• Nodes must contain data and a pointer to the next node, linked through public class Node { int data; Node next; public Node (int d) { data = d; next = null; data = } }

Verifying Chain Links

• Create two nodes and chain by setting X to a node with a value such as Node x = new Node(7); , and the subsequent equal to next node such as x.next = y;
• Where any remaining nodes can also return a null value

Linked Principles

• The first pointed node is created as pointer to first values
• All nodes are accessible through the head value and can be used to implement functions

Class For int Lists

• General structures store data, but the type is irrelevant.
• For values the Integer data the intList needs to be the Node Object that performs the functions such as public
• intList() {head = null;}

Insertion in Lists

• New nodes are linked and added at the begin of the list inserted with insert(4)
• Declared as = new Node
• The list is then checked to avoid duplicate type
• Total fall (2). Inserts at both variable versions by checking list

List Elements

• Elements are searched by comparing to data through contains()
• Loops will scan each node through the list beginning to end looking to see list is organized by checking next node

List Elements Search (2)

• Blank lists require no fall to function
• If element is in the chain its set to equal anything besides null
• If not list has value, function returns statement returning null
• To make this work compare elements with equals or !=

Element Deletion

• Deleting with delete looks for the 1st node
• Look for the note to be cleared
• reassign the next value through loop (previous) to avoid corrupting the order of list

Element Deletion (2)

• Head pointer shifted so next operation will function properly
• Node and perv pointers can be shifted in function of the node to be cleared so list remains intact

Element Deletion (3)

• The method delete() provides all the functionality for clearing or shifting the list
• Blank nodes, rearanged loops are addressed
• Additional functions such as isEmpty, or size of list can be implemented

Inner Classes

• Enclose or group particular data
• Class is private, but may not be
• Inner class can be specified by start or the end
• Private classes can used inside outer classes
• This will impact access to values

Inner Classes (2)

• Internally nodes and loops are specified to ensure class node is properly extracted for access to values without causing error Inner is usually a loop