Deck Flashcards
What does it mean if it says “Extend” in the code?
It means it’s inheritance.
What is the general nature of an object? [2]
An object is an abstract identity;
And it’s components are data;
What are two disadvantages of OOP? [4]
OOP are larger than other programs;
Thus slower;
Unsuitable for minor/small projects;
As OOP increases complexity for little gain;
Modularity (concept)
When you break down a system into modular components, you can work on specific parts separately. This approach is known as modular development or modular programming.
Outline one advantage of modularity [2]
Faster development;
Since different programming teams can work together on different modules;
Easier to debug;
Because the smaller modules will have fewer mistakes than one big program;
Relationships between classes (definition concept)
In Object-Oriented Programming (OOP), there are several types of relationships between classes. Let’s break them down in easy terms:
Association:
Easy Explanation: Think of association as a connection between two classes. It’s like saying one class knows about another.
Example: A Person class might be associated with an Address class, meaning a person has an address.
Aggregation:
Easy Explanation: Aggregation is a special type of association where one class is part of another class.
Example: A University class may have many Student classes. The students are part of the university, but they can exist independently.
Composition:
Easy Explanation: Composition is a strong form of aggregation where the child class is so dependent on the parent class that it cannot exist independently.
Example: An Engine class is composed within a Car class. If the car is destroyed, the engine is gone too.
Inheritance:
Easy Explanation: Inheritance is like saying one class is a specialized version of another class. It allows a class to inherit attributes and behaviours from another class.
Example: A Dog class could inherit from an Animal class. The dog is a type of animal and shares some common characteristics.
Dependency:
Easy Explanation: Dependency occurs when one class relies on another class, but changes in the dependent class don’t necessarily affect the class that depends on it.
Example: A Car class might depend on a Fuel Tank class. If you change how the fuel tank works, it doesn’t necessarily change the car’s basic functionality.
Relationships in OOP (in code)
Association:
public class Person {
String name;
public Person(String name) {
this.name = name;
} }
public class Address {
String street;
String city;
public Address(String street, String city) {
this.street = street;
this.city = city;
} }
// Association
public class AssociationExample {
public static void main(String[] args) {
Person person = new Person(“John”);
Address address = new Address(“123 Main St”, “Cityville”);
person.address = address; // Person knows about Address } } Aggregation:
import java.util.ArrayList;
import java.util.List;
public class University {
String name;
List<Student> students = new ArrayList<>(); // Aggregation</Student>
public University(String name) {
this.name = name;
} }
public class Student {
int studentId;
String name;
public Student(int studentId, String name) {
this.studentId = studentId;
this.name = name;
} }
// Aggregation
public class AggregationExample {
public static void main(String[] args) {
University university = new University(“ABC University”);
Student student1 = new Student(1, “Alice”);
Student student2 = new Student(2, “Bob”);
university.students.add(student1);
university.students.add(student2);
} } Composition:
public class Engine {
public void start() {
System.out.println(“Engine started”);
}
}
public class Car {
Engine engine = new Engine(); // Composition
public void start() {
engine.start();
} }
// Composition
public class CompositionExample {
public static void main(String[] args) {
Car car = new Car();
car.start(); // Starting the car also starts its engine
}
}
Inheritance:
public class Animal {
String species;
public Animal(String species) {
this.species = species;
}
public void makeSound() {
// Abstract method
} }
public class Dog extends Animal {
public Dog(String species) {
super(species);
}
@Override
public void makeSound() {
System.out.println("Woof!");
} }
// Inheritance
public class InheritanceExample {
public static void main(String[] args) {
Dog dog = new Dog(“Canine”);
System.out.println(dog.species); // Accessing inherited attribute
dog.makeSound(); // Accessing overridden method
}
}
Dependency:
public class FuelTank {
public void refill() {
System.out.println(“Fuel tank refilled”);
}
}
public class Car {
FuelTank fuelTank; // Dependency
public Car(FuelTank fuelTank) {
this.fuelTank = fuelTank;
}
public void drive() {
System.out.println("Car is driving");
} }
// Dependency
public class DependencyExample {
public static void main(String[] args) {
FuelTank fuelTank = new FuelTank();
Car car = new Car(fuelTank);
car.drive(); // Car depends on FuelTank for driving
fuelTank.refill(); // Changes to FuelTank don’t affect Car
}
}
Outline one advantage of binary search [1]
Binary search is much faster than sequential search;
Because it halves the search range for every comparison;
Outline one disadvantage of binary search [1]
Not applicable to unsorted data;
Outline the use of data hiding as a use of a security feature in OOP [2]
Encapsulation allows making instance variables of a class private;
So that other classes can’t access accidentally;
Outline why having more than one method with the same name does not cause a conflict? [2]
Because they both have different parameters;
Allowing the compiler to choose the right one;
What is the name for this type of method: why having more than one method with the same name does not cause a conflict? [1]
Polymorphism;
Define the term method signature [2]
The method name and the type of all of its parameters;
Is the unique identifiers (concept)
Outline an advantage of using a library [2]
Convenience;
Because implementations of common tasks are available;
Reliability;
Because these implementations are fully developed, functional and robust;
Advantages and disadvantages of dynamic linked lists and static arrays.
check one note
Code that instantiates array “line” with 20 cart objects [2]
private Cart[] line = new Cart([20];
Concept:
Imagine a Shelf:
Think of your array like a shelf where you want to store some items. The type of items you want to store is like the type of things you want to put on the shelf.
Specify the Shelf:
Say out loud what type of items your shelf will hold. For example, “I want a shelf for Cart items.” In Java, this sounds like Cart[].
Name the Shelf:
Give your shelf a name. For example, “I’ll call it ‘line’.” In Java, this becomes Cart[] line.
Get a New Shelf:
Use the word “new” to ask for a brand new shelf. In Java, it’s new.
Tell the Size of the Shelf:
Specify how many items your shelf can hold. For example, “I want it to hold 20 Cart items.” In Java, this is done with square brackets, like new Cart[20].
Put the Shelf in its Place:
Finally, tell Java where to put your shelf. Connect it to the name you chose earlier. For example, “Put the ‘line’ shelf where I can access it.” In Java, this is Cart[] line = new Cart[20];.
