Object-Oriented Programming Basics

Java Classes and Objects

• Java uses classes to organize program units.
• Classes contain methods that perform tasks.
• Methods hold program statements that carry out tasks.
• Methods hide underlying statements from the user.
• An example of a class is Account.
• Examples of methods include withdraw() and deposit().

Object Instantiation

• Objects (instances) of a class are needed for tasks.
• Before using an object, it must be built from its class's design.
• An object is an instance of its class.
• An example of instantiating an Account object: Account account1 = new Account();

Reusability

• Classes can be reused to build multiple objects, similar to using design drawings to build multiple cars.
• Reusing existing classes saves time and effort in program development.
• Reusing classes contributes to more reliable and effective systems through thorough testing, debugging, and tuning prior developments.

Attributes and Instance Variables

• A car has characteristics (attributes) like color, door count, fuel level, speed, and odometer readings.
• Attributes are part of an object's design.
• Each object has its own attributes.
• An object's attributes are its instance variables.
• An Account object has a balance attribute.
• Each account knows only its own balance, not the balances of other accounts.

Encapsulation

• Classes (and their objects) encapsulate attributes and methods, enclosing them within the class.
• Objects can communicate; implementation details are hidden within each object.
• Information hiding is vital for good software design.

Inheritance

• Creating a new class from an existing class is called inheritance.
• The new class (subclass) inherits characteristics from the existing class (superclass).
• The new class can then add or modify characteristics of its own.
• An example is a "convertible" being a type of "automobile."

Interfaces

• Interfaces are collections of related methods, similar to functions.
• Programmers can use tools and objects with similar functionality using interfaces.
• An object's implementation details are hidden.
• A class can implement multiple interfaces.
• An example is a car implementing different interfaces for various functions.

Object-Oriented Analysis and Design (OOAD)

• Developers determine the requirements (what the program must do) using a structured analysis process.
• The design defines how the program will meet the requirements.
• The design must be reviewed by experts and specialists before coding.
• This entire process is called object-oriented analysis and design (OOAD).
• The language Java is object-oriented.

Unified Modeling Language (UML)

• UML is a graphical language for system modeling in an object-oriented way.
• It's used before the programming language is chosen.

Primitive Types vs. Reference Types

• Java's types are divided into primitive and reference types.
• Primitive types (e.g., int, double) directly hold values.
• Reference types (classes, String) hold memory addresses pointing to objects.
• A reference type variable refers to an object in memory.
• Variables of different types are used to invoke different methods.

Instance Variables, Methods, and Access Modifiers

• Each class in Java becomes a new data type, used to declare variables and create objects.
• Instance variables store the object's characteristics.
• Declaring instance variables as private (e.g. as in private String name) hides implementation details of the object.
• Access modifiers like public make methods accessible outside the class.
• Private variables are only accessible within the same class.
• Public methods are visible and accessible from outside the class.

Class Declarations

• Every class begins with the keyword class.
• Class names start with a capital letter.
• Method and variable names start with a lowercase letter.
• File names match class names and end with .java.

Instance Variables (Continued)

• Objects have attributes; these are instance variables.
• Instance variables are variables within a class declared outside the class's methods.
• Each object has its own copy of instance variables.

Constructors

• Class constructors prepare and initialize objects.
• The compiler creates default constructors if none is defined.
• Constructors are invoked using the new keyword.
• They initialize the object's instance variables when the object is created.

Default and No-Argument Constructors

• If classes contain constructors, the default constructor is not created implicitly.

• If default initialization is needed, a no-argument constructor must be declared.

• No-argument constructors are invoked without parameter lists.

• Class Time1 represents time in a 24-hour format

• Time2 can also represent time with constructors for handling different parameters/values

Overloaded Constructors

• Multiple versions of a constructor can be offered within a class, handling different arguments/values.

• The compiler distinguishes constructors by their parameters/signature.

Package Access

• If no access modifier is used with a method or variable in a class, it's considered package-access.
• Package-access members are directly accessible from other classes in the same package.

Compiling and Executing Multiple Classes

• javac can compile multiple classes simultaneously using a list and or the wildcard *.
• If all classes belong to the same project, the wildcard *.java can be used.

Account UML Class Diagram

• UML diagrams are used to show the attributes and operations of a class.

• These diagrams help describe the class's structure in a visual manner that's language-independent.

•   UML class diagrams use three components:

  • The top compartment specifies the class name.
  • The middle compartment lists attributes (variables).
  • The bottom compartment describes operations (methods).