CSC 216: Object-Oriented Programming Concepts

A programming entity with state (internal data) and behavior (actions).

A blueprint for creating objects. It defines the object's structure and actions.

A special method that initializes an object when created.

The process of creating an object and associating it with a reference.

The internal data of an object; what an object knows.

The actions performed by an object; what an object can do.

A constructor with no parameters that is automatically available if you haven't created any.

A way of thinking about how to design and structure code. Object-Oriented Programming is one of them.

A reference variable that holds a reference to a Recipe object. This variable is declared to have a type of 'Recipe'.

This code creates a new Recipe object and assigns it to the reference variable 'r'. The object's name is set to "Chili" and the number of servings is set to 4.

Values passed into the constructor method when creating a new object. These parameters determine the object's initial values.

The new keyword creates a new object, and then the object is linked to the reference variable using the assignment operator (=).

A concept where variables don't directly store data but refer to the data's location in memory.

They don't store the entire object directly. They store a reference to the object's memory location.

1. Efficiency: Copying large objects takes less time. 2. Sharing: Different variables can share information by referring to the same object in memory.

Variables directly store and hold the data. Changes to one variable don't affect others.

Primitive variables use value semantics. Each variable holds its own copy of the data.

Accessing the object's data or methods using the dot (.) notation.

It dereferences the object 'r' and accesses its 'getName()' method to retrieve its name.

A special value indicating that a variable doesn't refer to any object.

1. Initialize an object variable. 2. Check if an object exists. 3. Pass a parameter when the type is unknown.

It can cause an exception.

It refers to the current object within a method.

To ensure that the method modifies the name property of the current object, not a different object.

Both variables point to the same object in memory. Changes to one object will affect the other.

Any changes made to the object's state within the method will be reflected in the original object because they refer to the same memory location.

Sharing information between different parts of the program without creating copies of large objects.

A special value that represents the absence of a meaningful object reference. It indicates that a reference variable does not point to any actual data.

An error that occurs when you try to access a member (data or method) of an object through a reference variable that holds null. Since null represents nothing, you can't call methods on it.

Returning null from a method often signals failure or that the method couldn't find what it was looking for. It informs the calling code that nothing meaningful was found.

Building a new class using instances of existing classes as members (fields). This allows you to reuse existing functionality and create more complex objects.

Reusing functionality from an existing class by calling methods on its objects. You delegate tasks to those objects within your new class.

Focusing on the essential concepts of an object, hiding its complex internal implementation details. Users only need to know what the object does, not how it does it.

Protecting an object's internal data and implementation from unauthorized access. It ensures that data is modified only through controlled methods.

A statement that must always be true for any instance of a class. It defines the valid states an object can be in throughout its lifespan.

Plain Old Java Object. A simple Java class that encapsulates data without complex logic or inheritance.

A Java class representing a complete stew recipe with ingredients like Stock, Proteins, Vegetables, and Seasonings.

A relationship where one class contains instances of other classes as its fields, like a StewRecipe containing Stock, Proteins, Vegetables, and Seasonings.

A constructor that takes arguments to initialize the object's fields with specific values.

Variables within a class that store an object's data, representing its state.

A variable that holds a reference to an object, enabling access to that object's data and methods.

A method that provides a string representation of an object, commonly used for displaying information about the object.

A class whose objects cannot be modified after creation. Their state remains constant throughout their lifetime.

A class whose objects can be modified after creation. Their state can be changed by methods.

The extent to which a class represents a single, focused abstraction (idea).

When a class's toString() method calls the toString() methods of its objects to build a string representation.

Mutators (methods that change state) can make classes harder to understand and maintain, leading to potential errors. Only include them if absolutely necessary.

Ideally, objects should be created solely via the constructor, preventing direct state manipulation.

A cohesive class, focused on a single abstraction, can be used in different programs, making it reusable.

To verify your development environment setup is ready for CSC 216. Ensure you have all the necessary tools and software.