Share
Explore

Kotlin Object Design Study Guide

The Genie → code repository:

⁠
https://github.com/ProfessorBrownBear/KotlinProgramming/blob/main/TheGenie
⁠
⁠

This study guide presents an instructional overview of object-oriented programming concepts using the Kotlin language, specifically focusing on how to design and structure programs.
It explains that a program is built from classes, which act as blueprints for system components and contain both data (variables) and actions (methods).
The two primary methods by which these classes interact:

through method calls, where one class requests help from another, and

through Shared Field Composition, where one class contains an instance of another class, forming a "has-a" relationship.

Furthermore, the material introduces IntelliJ and PlantUML as essential tools for both writing Kotlin code and visually understanding the structural relationships and logic of the program through diagramming.

The overall goal is to teach the conceptual foundation for translating business requirements into a functional, cooperating system of code objects.


Answer the following questions in 2-3 sentences, drawing exclusively from the provided source materials.
According to the documentation, what is the fundamental purpose of a class in object-oriented programming?
Identify the two main types of "things" that are contained within a class and provide an example of each from the Player class.
What are the two primary ways that classes are connected and work together in the provided Kotlin program?
Explain the concept of "Shared Field Composition" and identify which two classes in the Mischievous Genie Game demonstrate this relationship.
Describe the relationship between the Genie class and the Character class. What keyword in the code indicates this relationship is possible?
What is the responsibility of the GuessingGame class, and how does this demonstrate the principle of encapsulation?
What is the role of the main() function in the Mischievous Genie Game application?
Based on the source context, what is PlantUML and how is its purpose analogous to the purpose of Postman?
According to the Method Interaction Diagram, what two distinct actions occur immediately after the Genie's playGame(player) method calls the GuessingGame's start() method and it returns true?
In the playGame method, how does the program handle a situation where the player guesses incorrectly but wants to try again?
--------------------------------------------------------------------------------

Answer Key

A class represents one piece of the business requirement realized in code. It acts as a blueprint for one job of work or one "thing" in the system, serving as a "box" to hold related data and actions.
Every class contains "data things" (variables/fields) that describe what the class knows, and "action things" (methods) that describe what it does. In the Player class, val name: String is a data thing, and fun introduceYourself() is an action thing.
Classes are connected in two main ways. The first is by writing methods that call methods in other classes, coordinating actions between them. The second is through Shared Field Composition, where one class is put inside another as a field.
Shared Field Composition is a "has-a" relationship where one class contains another class as a field, and their lifespans are often shared. In the game, the Genie class demonstrates this by containing an instance of the GuessingGame class as a private field (private val game = GuessingGame()).
The Genie class inherits from the Character class, meaning it is a specialized type of Character. The open keyword on the Character class declaration (open class Character) makes it possible for other classes, like Genie, to inherit from it.
The GuessingGame class is responsible for the logic and randomization of the number guessing game. This demonstrates encapsulation by bundling the game's specific logic—generating a random number and comparing it to a user's guess—into a self-contained unit.
The main() function is the entry point of the Kotlin program. It is responsible for orchestrating the overall program flow, which includes creating the Player and Genie objects and initiating the dialogue and gameplay sequence.
PlantUML is a plugin for IntelliJ IDEA that generates UML diagrams directly from code to help visualize the structure and logic of a program. Its purpose is analogous to Postman, which helps visualize network communication (URLs, POST/GET requests), whereas PlantUML helps visualize code connections at a conceptual level.
After start() returns true, the Genie object first calls the speak() method (inherited from Character) to output the message "Bravo, [player.name]! You guessed correctly!". It then makes a second call to speak() to deliver the prize-related message, "As for your fabulous prize...".
If the player guesses incorrectly, the Genie asks if they would like to try again. If the user's response is "Y" or "YES", the playGame(player) method calls itself again to restart the game sequence. This is described as a recursive retry.
--------------------------------------------------------------------------------

Essay Questions

Using the concepts of "data things" and "action things," compare and contrast the responsibilities of the Player, Genie, and GuessingGame classes as defined in the source code.
Explain the flow of method calls that occurs when a user runs the program, agrees to play the game, and guesses the number incorrectly, declining to play again. Reference the Method Interaction Diagram and the provided code to trace the path of execution from main() to the end of the program.
Discuss the two types of class relationships present in the Mischievous Genie Game: inheritance and composition. Use the Character, Genie, and GuessingGame classes to illustrate the differences and explain why each relationship was chosen for its specific purpose in the program's design.
The source material states that PlantUML helps developers understand programs "not just at the mechanical level (syntax), but at the conceptual level of meaning and design." How do the provided UML and Method Interaction Diagrams achieve this for the Mischievous Genie Game?
Analyze the playGame method within the Genie class. Describe its logic, including how it determines a win or loss, the different dialogue paths it can take, and its use of recursion.
--------------------------------------------------------------------------------

Glossary of Key Terms

Table 1
Term
Definition
Action things
A term for methods (functions inside a class). They describe what a class does. Example: fun playGame().
Character
An open base class responsible for representing a character. It holds a characterName and provides a speak() method for outputting messages.
Class
A blueprint for one job of work or one “thing” in a system. It is described as a "box" that holds data things (what it knows) and action things (what it can do).
Composition
A relationship where one class contains another class as a field. This represents a "has-a" relationship (e.g., The Genie has a GuessingGame).
Data things
A term for variables (fields or properties) within a class. They describe what a class knows. Example: val name: String.
Encapsulation
The principle of bundling logic into a self-contained unit. The GuessingGame class demonstrates this by containing all logic for the number game.
Field
A variable inside a class. Also referred to as a property or "data thing."
Genie
A class that inherits from Character. It is responsible for the main game logic and interactions, and it contains a GuessingGame object via composition.
GuessingGame
A class that encapsulates the logic and randomization for the number guessing game. Its primary method is start(), which returns a Boolean indicating if the user won.
Inheritance
A relationship where one class derives from a base class. In the program, the Genie class inherits from the Character class.
main()
The entry point of any Kotlin program. It controls the high-level flow, such as creating objects and starting the interaction.
Method
A function inside a class. Also referred to as an "action thing."
Method Call
One of the primary ways classes connect, where one class's method invokes a method on another class's object to coordinate actions.
PlantUML
A powerful tool and IntelliJ IDEA plugin that can generate UML diagrams directly from code to visualize the structure, logic, and connections within a program.
Player
A class responsible for holding user information, specifically their name and age. It has a method to introduceYourself().
Shared Field Composition
The specific term used to describe when one class contains a field that is an instance of another class. The Genie and GuessingGame classes have this relationship.
UML Diagram
A Unified Modeling Language diagram. In the context provided, it is a visual representation of the classes, their fields, methods, and relationships (like inheritance and composition).
There are no rows in this table
⁠
Want to print your doc?
This is not the way.
Try clicking the ⋯ next to your doc name or using a keyboard shortcut (
CtrlP
) instead.