4 and Programming

Question 1

Objects

Answer 1

Objects are the fundamental building blocks of object-oriented programming (OOP). They represent real-world entities or abstract concepts in code. An object encapsulates data (attributes) and the methods that operate on that data.

Question 2

Classes

Answer 2

A class is a template or blueprint for creating objects. It defines the attributes and methods that all objects of that type will have.

Question 3

Instantiation

Answer 3

Instantiation is creating an object.
And each object is an instance of its class.

Question 4

Encapsulation

Answer 4

Encapsulation is like creating a protective capsule around an object’s internal data, shielding it from unauthorized access and manipulation. It involves:
* Data hiding: Making an object’s internal data private
* Public interfaces: Providing controlled access to the object’s data through methods

Question 5

Association

Answer 5

This is a general relationship between objects. For example, a Student object might be associated with multiple Course objects.

Question 6

Aggregation

Answer 6

This is a “has-a” relationship where one object contains references to other objects. For instance, a University object might contain multiple Department objects.

Question 7

Composition

Answer 7

This is a stronger form of aggregation where the contained objects cannot exist independently of the container. For example, a House object might be composed of Room objects.

Question 8

Inheritance

Answer 8

This is an “is-a” relationship where one class (subclass) inherits properties and methods from another class (superclass). For example, a Car class might inherit from a Vehicle class.

Question 9

Object-Oriented Design Process

Answer 9

• Identifying the objects in the system
• Defining the attributes for each object
• Determining the methods each object should have
• Establishing the relationships between objects

Question 10

Benefits of Object-Oriented Programming

Answer 10

• Modularity: Objects can be maintained independently of other objects or code. Allowing coding teams to divide the work
• Reusability: Objects can be reused in different programs. Plus inheritance.
• Productivity: Programmers can build new programs quicker through the use of existing objects.
• Easily upgradable and scalable: Updating or adding new features becomes easier.
• Security: The encapsulation of data and functionality provides a secure programming model.
• Flexibility: Through polymorphism, objects can be treated as instances of their parent class.

Question 11

Advantages of Encapsulation

Answer 11

• Data Protection: Prevents unauthorized access to an object’s internal state.
• Flexibility: Allows changing the internal implementation without affecting the public interface.
• Maintainability: Easier to debug and maintain as data access is controlled.
• Modularity: Promotes modular design by separating internal workings from external interactions.
• Prevents accidental data editing from other classes.

Question 12

Parent-child relationship in inheritance.

Answer 12

• Parent class (superclass): The existing class being inherited from
• Child class (subclass): The new class that inherits from the parent

Question 13

Advantages of Inheritance

Answer 13

• Code Reusability: Reduces redundancy by reusing code from existing classes.
• Hierarchical Classification: Organizes classes into a logical hierarchy.
• Extensibility: Easily extend or specialize existing classes.
• Polymorphism: Enables runtime polymorphism through method overriding.

Question 14

Polymorphism

Answer 14

Polymorphism allows methods to have the same name and only be differentiated by the class they are in or the parameters they have.

Question 15

Types of Polymorphism

Answer 15

• Compile-time Polymorphism (Method Overloading): Multiple methods with the same name but different parameters in the same class.
• Runtime Polymorphism (Method Overriding): Subclass provides a specific implementation for a method defined in its superclass.

Question 16

Attributes

Answer 16

Data to create object

Question 17

Methods

Answer 17

Behaviors

Question 18

UML Diagrams

Answer 18

Unified Modeling Language (UML) diagrams are visual representations of software systems. They help in designing, documenting, and communicating about object-oriented systems.

Question 19

Recursion

Answer 19

Recursion occurs when a method calls itself within its own code. This self-referential approach allows complex problems to be solved by repeatedly applying the same solution to smaller instances of the problem.

Question 20

Key Components of Recursion

Answer 20

• Base case: The condition that stops the recursion
• Recursive case: The part where the function calls itself
• Progress towards the base case: Each recursive call should move closer to the base case

Question 21

Tracing Recursive Algorithms

Answer 21

Tracing recursive algorithms involves following the sequence of recursive calls and their return values.

Question 22

Floating-point numbers

Answer 22

Decimals (Doubles)

Question 23

Issue with doubles

Answer 23

Take more memory

Question 24

A disadvantage of using Object Oriented Design.

Answer 24

To construct an Object Oriented program is difficult and for many smaller tasks potentially unnecessary.

Question 25

Advantages of using Object Oriented Design.

Answer 25

* Allows a team to divide a job up into a number of smaller tasks. For example, each member of the team could work on an individual object (e.g. one could work on the Bus object, whilst the other works on BusRoute). * Code Reusability: OOP promotes code reusability through inheritance, where new classes can inherit properties and methods from existing classes, reducing the need for repetitive code

Question 26

How to initiate an Array?

Answer 26

DataType[] name = new DataType[x]; Where DataType can be any primitive or object class and x is the array's size.

Question 27

Parameters

Answer 27

Data entered to a method. Example: setDriver(**String Driver**)