OOP Concepts Quiz

Chapter 3 OOP Main Concepts

• Chapter 3 focuses on Object-Oriented Programming (OOP) core concepts.
• The chapter covers objects versus classes, identifying objects, distinguishing between states and behaviors.

In Chapter 2, we have learned

• Using different input statements
• Basic concepts of memory (variables)
• Arithmetic operators
• Compound assignment operator
• Increment and decrement operators
• Java's primitive data types
• Logical operators
• Selection statements (if, if...else, switch)
• Repetition statements (for, while, do...while, break, continue)

In Chapter 3, you will learn

• Declaring classes and creating objects
• Defining class behaviors as methods
• Implementing class attributes as instance variables/properties
• Calling object methods
• Understanding instance variables and local variables within methods
• Using constructors to initialize object data
• Employing set and get methods for accessing object data.
• The differences between primitive and reference types

Chapter 3 Content

• Introduction to OOP
• Declaring classes with methods.
• Instantiating objects from classes
• Declaring methods that take parameters
• Instance variables and get/set methods
• Initializing objects with constructors

Introduction

• Covered topics in this chapter include:
  • Objects
  • Classes
  • Instance variables
  • Methods
  • Parameters
  • Primitive data types (like double)

Graphical Example of OOP

• Depicts a "CLASS" as a box with "State/Attribute" and "Behaviors/Methods" compartments.
• Arrows from CLASS to individual "OBJECTS" (Object 1, Object 2, and Object 3).

Introduction - Examples

• Object: Car
• Class: Design of a Prius
• Class: Account.java
• Class: GradeBook.java
• Object Instance: My Prius
• Field Example: Engine, Color
• Method Example: Drive, Park, Brake
• Parameter: How hard you press the brake
• Object Related Value: Amount to deposit

Introduction to Object Technology

• Objects are reusable software components
• Represent items like date objects
• Represent behaviors such as calculating or communicating
• Modern software development benefits from modular object-oriented designs.

Introduction to Object Technology (Cont.)

• Explains how Objects work in everyday life using a car analogy
• Introduces OOP concepts analogous to mechanical systems
• Describes how parts of a car (like accelerator) hide complex inner mechanisms from the user.

Introduction to Object Technology (Cont.)

• Clearly outlines the role of objects in supporting simpler interaction with complex systems.
• Re-emphasizes object construction as a required precursor to usage.

Methods and Classes

• Methods are crucial for performing tasks within a program.
• Methods encapsulate instructions and hide implementation details from the user.
• Java organizes method collections into classes, similar to engineering diagrams representing a car.

Instantiation

• Building an object from its class definition
• An object is a class instance (similar to creating a car from its diagram).
• Need to create an object before running the program

Reuse

• Reusable software components (classes) are essential for software development efficiency
• Reusing existing components saves time
• Efficient reuse, with comprehensive testing, leads to robust systems

Software Engineering Observation 1.1

• Encourage the reuse of existing program components (classes) whenever possible.
• Using existing components avoids reinventing solutions and leads to more reliable software.

Introduction to Object Technology (Cont.) - Messages and Methods Calls

• Messages (e.g., pressing accelerator) are sent to objects to trigger actions.
• Method calls implement these messages to instruct objects accordingly.

Introduction to Object Technology (Cont.) - Attributes and Instance Variables

• Objects have attributes (properties) like color, speed.
• Attributes are also known as instance variables and are part of the object's design.
• Each object has its own attributes, distinct from attributes of other objects of the same class,

Introduction to Object Technology (Cont.)

• Objects have associated attributes (instance variables) that define their characteristics
• Attributes are crucial as they define the object's qualities, stored within the class's structure.
• Information is kept in each object itself.

Declaring a Class with a Method and Instantiating an Object of a Class

• New class definition: requires keyword 'public' in declaration, and must be stored in a file with the same name that ends with '.java'.
• Creating an object requires the 'new' keyword

Declaring a Class with a Method and Instantiating an Object of a Class (Cont.)

• Method naming conventions: utilize lowercase first letter and subsequent words with capital letters
• Empty parentheses indicate methods that don't need additional information to function.
• Methods and parameters are grouped inside curly brackets{}

Declaring a Class with a Method and Instantiating an Object of a Class (Cont.)

• A class without a 'main' method is not an application (it can't run directly); instead a 'main' method needs to be in a separate driver class to run the program.

Declaring a Class with a Method and Instantiating an Object of a Class (Cont.) -Instantiation

• Creating an object of a class before running the program is necessary.
• Objects are considered instances of their associated classes.

Declaring a Class with a Method and Instantiating an Object of a Class (Reuse)

• Reusability of classes to make many objects
• Reusable classes avoid excessive work and create more reliable programs

Declaring a Class with a Method and Instantiating an Object of a Class (Compiling an Application)

• Compile Java files using a 'javac' command

Declaring a Class with a Method and Instantiating an Object of a Class (UML)

• Uses a standardized diagram to represent classes and their attributes
• Classes are represented as boxes, divided into compartments for their name, attributes, and operations

Declaring a Method with a Parameter

• Methods can accept parameters—additional information for tasks
• Parameters provide needed data during object method calls; this is similar to how pressing a car's gas pedal applies more or less force to change acceleration

Declaring a Method with a Parameter (Cont.)

• Methods can need multiple, comma-separated parameters
• Method parameters need a type definition and identifier
• A method's call uses the argument values corresponding to the method parameters

Declaring a Method with a Parameter (Scanner)

• nextLine() : reads characters until a newline is entered
• next(): reads up to and excluding a white-space character

Declaring a Method with a Parameter (Cont.)—Arguments and Parameters

• Matching argument counts and data types with parameters is essential
• Errors result from inconsistent data type and count matches

Instance Variables, set Methods and get Methods

• Local variables only exist within a method. Local variables disappear when the method ends.
• An object's attributes (instance variables) are persistent across the program's run.

Instance Variables, set Methods and get Methods (Cont.)

• Methods are part of a class to manipulate object attributes
• Attributes act like fields stored inside the class; they are declared outside methods
• Methods often manipulate private fields through public methods (set, get methods)

Instance Variables, set Methods and get Methods (Cont.)—private

• Access modifiers like "private" hide information to prevent unintended access from outside the class.

Instance Variables, set Methods and get Methods (Cont.)—set/get methods

• 'set' methods change data; 'get' methods retrieve data.

Instance Variables, set Methods and get Methods (Cont.)

• Methods specifying a non-void return type will return a specific value.
• Methods can call other methods of the same class using only the method name.

Instance Variables, set Methods and get Methods (Cont.)—Initial Values

• Instance variables have default values. (e.g., String values are null)
• Developers must provide initial values if default values aren't suitable

Initializing Objects with Constructors

• Instance variables initialized when an object is created; often to default values
• Constructors allow for customizing object initialization
• Constructors must have the same name as the class

Initializing Objects with Constructors (Cont.)

• Constructors can contain parameters to specify initialization values
• Constructors, unlike methods, are not called directly; the 'new' keyword implicitly calls the corresponding constructor when creating an object

Primitive Types vs. Reference Types

• Primitive types (e.g., int, float) store single values directly.
• Reference types (e.g., objects) store memory locations, which can point to objects in memory that hold data that is not primitive.

Thank You

• Reading list provided (book title, author with ISBN information)