U5 | Classes
5.1 Anatomy of a Class & 5.2 Constructors
Methods vs Constructors
-
Methods: functions defined within a class that preforms specific actions for objects of that class
-
Constructors: special methods in a class that are responsible for initializing the object’s state when an instance of the class is created
// EXAMPLE CLASS
public class Snack {
// Instance Variables
private String name;
private int calories;
// Default Constructor
public Snack() {
name = "";
calories = 0;
}
// Overloaded Constructor
public Snack (string n, int c) {
name = n;
calories = c;
}
// Accessor method 1
public String getName() {
return name;
}
// Access method 2
public int getCalories() {
return calories;
}
// Mutator method 1
public void setName(String n) {
name = n;
}
// Mutator method 2
public void setCalories(int c) {
calories = c;
}
private boolean canEat() {
return (calories < 150);
}
}
private vs public
-
public: allows access from classes outside the declaring class (classes, constructors)
-
private: restricts access to the declaring class (instance variables)
methods can be either public or private
Popcorn Hack: Which of the following lines will cause an error?
public class SnackDriver {
public static void main(String[] args) {
Snack choiceOne = new Snack("cookies", 100);
Snack choiceTwo = new Snack();
System.out.println(choiceOne.getName());
System.out.println(choiceOne.getCalories());
choiceTwo.setName("chips");
choiceTwo.calories = 150;
}
}
// choiceTwo.calories = 150; will cause an error because its private so it can't be defined
Key term: Encapsulation
- A fundmanetal concept of OOP
- Wraps the data (variable) and code that acts on the data (methods) in one unit (class)
- In AP CSA we do this by:
- Writing a class
- Declaring the instance variables as private –> enforce constraints and ensure integrity of data
- Providing accessor (get) methods and modifier (set) methods to view and modify variables outside of the class
public class Sport {
private String name;
private int numAthletes;
public Sport () {
name = "";
numAthletes = 0;
}
// Parameters in contructors are local variables
public Sport (String n, int numAth) {
name = n;
numAthletes = numAth;
}
// What if not all instance variables are set through parameters?
public Sport (String n) {
name = n;
numAthletes = 0;
}
}
Sport tbd = new Sport();
Sport wp = new Sport("Water Polo", 14);
Sport wp = new Sport("Volleyball");
- if no constructor provided, Java provides default constructor: int (0), double (0.0), strings and other objects (null)
Hacks
Create a Book class where each book has a title, genre, author, and number of pages. Include a default and overloaded constructor.
public class Book {
private String title;
private String genre;
private String author;
private int numberOfPages;
// Example of Default Constructor
public Book() {
this.title = "Untitled";
this.genre = "Unknown";
this.author = "Unknown Author";
this.numberOfPages = 0;
}
// Example of Overloaded Constructor
public Book(String title, String genre, String author, int numberOfPages) {
this.title = title;
this.genre = genre;
this.author = author;
this.numberOfPages = numberOfPages;
}
// Setters and Getters
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getGenre() {
return genre;
}
public void setGenre(String genre) {
this.genre = genre;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public int getNumberOfPages() {
return numberOfPages;
}
public void setNumberOfPages(int numberOfPages) {
this.numberOfPages = numberOfPages;
}
// Display Information About the Book
@Override
public String toString() {
return "Title: " + title + "\nGenre: " + genre + "\nAuthor: " + author + "\nNumber of Pages: " + numberOfPages;
}
public static void main(String[] args) {
// You can create Book instances and test them here
Book book1 = new Book("Sample Title", "Fiction", "John Doe", 200);
Book book2 = new Book();
System.out.println(book1);
System.out.println();
System.out.println(book2);
}
}
Book.main(null);
Title: Sample Title
Genre: Fiction
Author: John Doe
Number of Pages: 200
Title: Untitled
Genre: Unknown
Author: Unknown Author
Number of Pages: 0
5.3 Documentation with Comments
REMEMBER: comments are ignored by the compiler and anything written in them won’t execute
- they’re used for people to make code more readable.. allows them to understand what’s happening without having to go further into the code
- improves communication between TEAMS
- allows code to be maintained over years
- prevents execution when testing alternative code
You are NOT required to write comments of AP Exam FRQs, but it is always a good habit
The types of comments:
1) Single line: // 2) Multiline: /* */ 3) Java Doc: /** * * */
/*
Programmer:
Date:
Purpose
*/
public class Main {
public static void main(String[] args) {
// variables
double length = 2.5;
double width = 4;
//.. and so on
}
}
/**
* javadoc comments:
* jkafhjdajhf
*
* @author
* @version
*/
Javadoc is a tool that pulls any comments written in this format to make a documentation of the class in the form of a webpage
Javadoc also has tags (as shown above)
Preconditions: conditions that must be met before the execution of a code in order for it to run correctly
- Will be written in comments for a method for most APCSA questions
- it is assumed that these preconditions are true, we do not need to check!
Postconditions: conditions that must be met after the conditions has been executed (outcome, state of variables, ect)
- Will be written in comments for a method for most APCSA questions
- we do have to check to make sure these have been met
- good way to get a summary of what you need to be doing
// EXAMPLE FROM AP CLASSROOM:
public class SecretWord {
private String word;
public SecretWord(String w) {
word = w;
}
/**
* Precondition: parameter num is less than the length of word
* Postcondition: Returns the string of the characters of word from the index hum to the end of the word followed by the characters of word from index 0 to num, not including index num. The state of word has not changed
*/
public String newWord(int num)
{
//implementation not shown
}
}
| {
| //implementation not shown
| }
missing return statement
5.4 Accessor Method
OUR GOAL: to define behaviors of an object through non-void methods NOT using parameters written in a class
REMEMBER: an accessor method allows other objects to access static variables
What is the purpose of an accessor method?
It allows us to safely access variables without other people being able to. Also called get methods or getters.
They’re necessary whenever another class needs to access a variable outside of that class.
// Example class
public class Movie {
// private instance variables
private String name;
private int runtime;
// default constructor
public Movie() {
name = "";
runtime = 0;
}
// overloaded constructor:
public Movie(String n, int c) {
name = n;
runtime = c;
}
// added ACCESSOR METHOD for each variable
public String getName() { // header
return name; // returning a COPY of the private instance variables
}
public int getRuntime() {
return runtime
}
}
An accessor method must be:
publicin order to be accessible- the return type must match the instance variable type
- usually name of method is getNameOfVariable
- should be NO PARAMETERS
POPCORN HACKS: write an accessor method for each of the instance variables:
public class Course {
private String name;
private String gradeLevel;
private int period;
public Course() {
name = "";
gradeLevel = "";
period = 0;
}
public Course(String n, String g, int p) {
name = n;
gradeLevel = g;
period = p;
}
public String getName() {
return name;
}
public String getGradeLevel() {
return gradeLevel;
}
public int getPeriod() { // Corrected the return type to int
return period;
}
public static void main(String[] args) {
Course a = new Course();
Course b = new Course("Tim", "Sophomore", 4);
System.out.println(a.getName());
System.out.println(a.getGradeLevel());
System.out.println(a.getPeriod());
System.out.println(b.getName());
System.out.println(b.getGradeLevel());
System.out.println(b.getPeriod());
}
}
Course.main(null);
0
Tim
Sophomore
4
Let’s look at another example:
public class Sport {
private String name;
private int numAthletes;
public Sport(String n, int num) {
name = n;
numAthletes = sum;
}
public String getName() {
return name;
}
public int getNumAthletes () {
return numAthletes;
}
}
Can we print out information about an instance of this object?
public class Sport {
private String name;
private int numAthletes;
public Sport(String n, int num) {
name = n;
numAthletes = num;
}
public String getName() {
return name;
}
public int getNumAthletes() {
return numAthletes;
}
public static void main(String[] args) {
Sport volleyball = new Sport("volleyball", 12);
System.out.println(volleyball);
}
}
Sport.main(null);
REPL.$JShell$20B$Sport@1fd2fdd7
What output did we get?
The code outputs the Object class in the form of classname@HashCode in hexadecimal
Let’s try using the toString method:
- returns a string when System.out.println(object) is called
- no parameters
public class Sport {
private String name;
private int numAthletes;
public Sport(String n, int num) {
name = n;
numAthletes = num;
}
public String getName() {
return name;
}
public int getNumAthletes() {
return numAthletes;
}
public String toString() { // toString method.. HEADER MUST BE WRITTEN IN THIS WAY
return "Sport: " + name +"\nNumber of Athletes: " + numAthletes;
}
public static void main(String[] args) {
Sport volleyball = new Sport("volleyball", 12);
System.out.println(volleyball);
}
}
Sport.main(null);
Sport: volleyball
Number of Athletes: 12
5.5. Mutators / Setters
Purpose: Mutators are used to change the values of the fields (attributes) of an object.
Access Control: Mutators are typically defined as public methods to allow external code to modify the object’s state.
Naming Convention: The method names for mutators usually start with “set” followed by the name of the field they modify.
Parameterized: Mutators take one or more parameters that represent the new values for the fields.
Return Type: Mutators are usually of type void, as they don’t return a value, but they modify the object’s state.
Encapsulation: Mutators are an essential part of encapsulation, which helps to protect the object’s state by controlling access through methods.
Validation: Mutators often include validation logic to ensure that the new values being set are within acceptable bounds or meet specific criteria.
Example Usage: Mutator for setting the age of a Person object might look like: public void setAge(int newAge) {…}.
Chaining: Mutators can be chained together in a single line for more fluent and concise code, e.g., person.setName(“John”).setAge(30);.
Immutable Objects: In some cases, mutators are not used, and instead, a new object with modified values is created. This approach is common in creating immutable objects in Java.
Example
public class UserAccount {
private String username;
private String password;
private boolean isLoggedIn;
public UserAccount(String username, String password) {
this.username = username;
this.password = password;
this.isLoggedIn = false;
}
// Mutator for setting the username
public void setUsername(String newUsername) {
this.username = newUsername;
}
// Mutator for setting the password
public void setPassword(String newPassword) {
this.password = newPassword;
}
// Mutator for logging in
public void login(String enteredUsername, String enteredPassword) {
if (enteredUsername.equals(username) && enteredPassword.equals(password)) {
isLoggedIn = true;
System.out.println("Login successful. Welcome, " + username + "!");
} else {
System.out.println("Login failed. Please check your username and password.");
}
}
// Mutator for logging out
public void logout() {
isLoggedIn = false;
System.out.println("Logged out successfully.");
}
// Accessor for checking if the user is logged in
public boolean isLoggedIn() {
return isLoggedIn;
}
public static void main(String[] args) {
// Create a UserAccount
UserAccount userAccount = new UserAccount("alice", "password123");
// Attempt to log in
userAccount.login("alice", "password123");
// Check if the user is logged in
if (userAccount.isLoggedIn()) {
// Access the Scrum board or other features here
System.out.println("Accessing Scrum boards...");
} else {
System.out.println("Access denied. Please log in.");
}
// Log out
userAccount.logout();
}
}
UserAccount.main(null);
Login successful. Welcome, alice!
Accessing Scrum boards...
Logged out successfully.
Hacks
Create a Java class BankAccount to represent a simple bank account. This class should have the following attributes:
-
accountHolder (String): The name of the account holder. balance (double): The current balance in the account. Implement the following mutator (setter) methods for the BankAccount class:
- setAccountHolder(String name): Sets the name of the account holder.
- deposit(double amount): Deposits a given amount into the account.
- withdraw(double amount): Withdraws a given amount from the account, but only if the withdrawal amount is less than or equal to the current balance.
Ensure that the balance is never negative.
public class BankAccount {
private String accountHolder;
private double balance;
// Constructor
public BankAccount(String accountHolder, double balance) {
// Initialize the account holder and balance attributes
this.accountHolder = accountHolder;
this.balance = balance;
}
// Implement the setAccountHolder method
public void setAccountHolder(String name) {
this.accountHolder = name;
}
// Implement the deposit method
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
// Implement the withdraw method
public void withdraw(double amount) {
if (amount > 0 && amount <= balance) {
balance -= amount;
}
}
public static void main(String[] args) {
// Test the BankAccount class with sample operations
// Create an instance of BankAccount
BankAccount account = new BankAccount("John Doe", 1000.0);
// Test the mutator methods
account.setAccountHolder("Jane Doe");
account.deposit(500.0);
account.withdraw(200.0);
// Print the updated account details
System.out.println("Account holder: " + account.accountHolder);
System.out.println("Current balance: " + account.balance);
}
}
BankAccount.main(null);
Account holder: Jane Doe
Current balance: 1300.0
5.6 Writing Methods
- Method Declaration: Define methods using the method keyword, specifying return type, method name, and parameters.
- Method Parameters: Methods can take input parameters.
- Return Statement: Use the return statement to return a value from a method.
- Method Overloading: You can have multiple methods with the same name but different parameter lists.
- Static Methods: Static methods are associated with the class rather than instances.
- Instance Methods: Instance methods are associated with an object of the class.
- Access Modifiers: Use access modifiers like public, private, or protected to control visibility.
- Method Invocation: Call methods using the dot notation on objects or classes (for static methods).
- Recursive Methods: Methods can call themselves, creating recursive functions.
- Varargs (Variable-Length Argument Lists): Use varargs to pass a variable number of arguments to a method.
Example
public class Calculator {
public int add(int operand1, int operand2) {
return operand1 + operand2;
}
public int subtract(int operand1, int operand2) {
return operand1 - operand2;
}
public int multiply(int operand1, int operand2) {
return operand1 * operand2;
}
public int divide(int dividend, int divisor) {
if (divisor != 0) {
return dividend / divisor;
} else {
throw new ArithmeticException("Division by zero is not allowed.");
}
}
public static void main(String[] args) {
Calculator calculator = new Calculator();
int resultAdd = calculator.add(5, 3);
int resultSubtract = calculator.subtract(10, 7);
int resultMultiply = calculator.multiply(4, 6);
int resultDivide = calculator.divide(8, 2);
System.out.println("Addition: " + resultAdd);
System.out.println("Subtraction: " + resultSubtract);
System.out.println("Multiplication: " + resultMultiply);
System.out.println("Division: " + resultDivide);
}
}
Hacks
Create a Java class MathUtility with a set of utility methods for mathematical operations. Implement the following methods:
- calculateAverage(double[] numbers): Calculate the average of an array of numbers.
- isPrime(int number): Check if a given integer is prime.
- findFactors(int number): Find and return an array of factors for a given integer. Include proper error handling for edge cases and invalid input.
public class MathUtility {
// Implement the calculateAverage method
public double calculateAverage(double[] numbers) {
// Calculate the average of the numbers
if (numbers == null || numbers.length == 0) {
throw new IllegalArgumentException("The input array is empty or null.");
}
double sum = 0;
for (double number : numbers) {
sum += number;
}
return sum / numbers.length;
}
// Implement the isPrime method
public boolean isPrime(int number) {
// Check if the given number is prime
if (number <= 1) {
return false;
}
if (number <= 3) {
return true;
}
if (number % 2 == 0 || number % 3 == 0) {
return false;
}
for (int i = 5; i * i <= number; i += 6) {
if (number % i == 0 || number % (i + 2) == 0) {
return false;
}
}
return true;
}
// Implement the findFactors method
public int[] findFactors(int number) {
// Find and return the factors of the given number
if (number <= 0) {
throw new IllegalArgumentException("The input number must be positive.");
}
List<Integer> factorsList = new ArrayList<>();
for (int i = 1; i <= number; i++) {
if (number % i == 0) {
factorsList.add(i);
}
}
int[] factorsArray = new int[factorsList.size()];
for (int i = 0; i < factorsList.size(); i++) {
factorsArray[i] = factorsList.get(i);
}
return factorsArray;
}
public static void main(String[] args) {
// Test the MathUtility class with sample mathematical operations
MathUtility mathUtility = new MathUtility();
// Test the utility methods
double[] numbers = {1, 2, 3, 4, 5, 6};
double average = mathUtility.calculateAverage(numbers);
System.out.println("Average of the numbers: " + average);
int numberToCheck = 17;
boolean isPrime = mathUtility.isPrime(numberToCheck);
System.out.println(numberToCheck + " is prime: " + isPrime);
int numberToFactor = 12;
int[] factors = mathUtility.findFactors(numberToFactor);
System.out.print("Factors of " + numberToFactor + ": ");
for (int factor : factors) {
System.out.print(factor + " ");
}
}
}
MathUtility.main(null);
Average of the numbers: 3.5
17 is prime: true
Factors of 12: 1 2 3 4 6 12
5.7 Static Variables and Methods
Static Methods
- Define behaviors of a class (belong to class, NOT object)
- Keyword static in header before method name
- Can only: access/change static variables
- Can’t: access/change instance variables or the class’ instance variables, no this reference
Practice
Should we use a static or non-static method?
public class Assignment{
// next classwork/homework ID is NEXT number of classwork/homework that will be created
private static int nextClassworkID = 1;
private static int nextHomeworkID = 1;
private String name;
private int pointValue;
// constructors and methods not shown
}
Question: What is the static data and what is the instance data?
Answer: nextClassworkID and nextHomeworkID are static data while name and pointValue are instance data.
Question: A method getGrade is given an int score earned on the assignment and returns the percentage (as a decimal) earned by that score. Would this be implemented as a static or non-static method?
- Think: What data does it need access to? If needs access to instance data, needs to be non-static. If only need access to static data, it can be static.
Answer: non-static since the method would access pointValue which is an instance variable.
Popcorn Hacks: write getGrade method
public class Assignment{
// next classwork/homework ID is NEXT number of classwork/homework that will be created
private static int nextClassworkID = 1;
private static int nextHomeworkID = 1;
private String name;
private int pointValue;
// method here
public Assignment(String name, int pointValue) {
this.name = name;
this.pointValue = pointValue;
}
// method here
public double getGrade() {
return (double) pointValue / 100;
}
public static void main(String[] args) {
Assignment person = new Assignment("Brody", 98);
System.out.println(person.getGrade());
}
}
Assignment.main(null);
0.98
Question: Would a method that reports the total number of assignments be static or non-static?
Answer: static, since the method would only need to access static data
Popcorn Hacks: write this method totalAssign
public class Assignment{
// next classwork/homework ID is NEXT number of classwork/homework that will be created
private static int nextClassworkID = 1;
private static int nextHomeworkID = 1;
private String name;
private int pointValue;
// method here
public Assignment(String name, int pointValue) {
this.name = name;
this.pointValue = pointValue;
}
// method here
public static int totalAssign() {
return nextClassworkID + nextHomeworkID;
}
public static void main(String[] args) {
Assignment rand = new Assignment("Sam", 88);
System.out.println(rand.totalAssign());
}
}
Assignment.main(null);
2
Multiple Choice Question
public class Example{
private static int goal = 125;
private int current;
public Example (int c) {
// code segment 1
}
public static void resetGoal (int g) {
// code segment 2
}
// other methods not shown
}
Which of the following statements is true?
- Code segment 1 can use the variable goal but cannot use the variable current.
- Code segment 1 cannot use the variable goal but can use the variable current.
- (TRUE) Code segment 2 can use the variable goal but cannot use the variable current.
- Code segment 2 cannot use the variable goal but can use the variable current.
- Both code segments have access to both variables
Question: Which ones can code segment 1 (constructor) use?
- It can use both because it is a non static method.
Static Variables
- Define static variables that belong to the class, all object of the class sharing that single static variable (associated with class, NOT objects of class)
- Either public or private
- static keyword before variable type
- used with class name and dot operator
Multiple Choice Question
public class Example{
private static int goal = 125;
private int current;
public Example (int c) {
// code segment 1
}
public static void resetGoal (int g) {
// code segment 2
}
// other methods not shown
}
Which of the following statements is true?
- Objects e1 and e2 each have a variable goal and variable current.
- Objects e1 and e2 share the variable goal and share the variable current.
- Objects e1 and e2 share the variable goal and each have a variable current.
- (TRUE) Objects e1 and e2 each have a variable goal and share the variable goal and share the variable current.
- The code does not complie because static variables must be public.
5.8 Scope and Access
- Local variables: variables declared in body of constructors and methods, only use within constructor or method, can’t be declaed public or private
- If local variable named same as instance variable, within that method the local variable will be referred to
public class Bowler{
private int totalPins;
private int games;
public Bowler(int pins){
totalPins = pins;
games = 3;
}
public void update (int game1, int game2, int game3) {
// local variable here is newPins
int newPins = game1 + game2 + game3;
totalPins += newPins;
games += 3;
}
}
Multiple Choice Question
public class Example{
private int current;
public Example(int c){
double factor = Math.random();
current = (int)(c * factor);
}
public void rest (int num) {
private double factor = Math.random();
current += (int)(num * factor)
}
// other methods not shown
}
| private double factor = Math.random();
illegal start of expression
| current += (int)(num * factor)
<identifier> expected
| current += (int)(num * factor)
<identifier> expected
| current += (int)(num * factor)
<identifier> expected
| current += (int)(num * factor)
<identifier> expected
Which of the following is the reason this code does not compile?
- The reset method cannot declare a variable named factor since a vriable named factor is declared in the constructor.
- (TRUE) The reset method cannot declare factor as private since factor is a local variable not an instance variable.
- The constructor cannot declare a variable named factor since a variable named factor is declared in the reset method.
- The constructor cannot access the isntance variable current since current is private.
- There is no syntax error in this code and it would compile.
5.9 this Keyword
this keyword
a keyword that essentially refers to the object that is calling the method or the object that the constructor is trying to make</detail>
### Can be used 3 Ways:
1. **refer to instance variable** > This will solve the problem of having duplicate variable names. To distinguish the instance and local variables, we use this.variableName for the instance variable and simply variableName for the local variable.
2. **parameter** > Sometimes, we can also use the object as a parameter in its own method call to use itself in the method by using objectName.methodName(this).
3. **constructor or method call** > Sometimes, we can also use the object as a parameter in its own method call to use itself in the method by using objectName.methodName(this).
Using **this()** in a constructor >> Calls the no-arg constructor or the constructor without any parameters of the current class, can also call other constructor that hav parameters by passing correct numb and type of args between parenthesis
^^ using **this()** can help you reuse code from one constructor in another
**this** in Java >> is limited to current object = only be used to access instance variables and invoke non-static methods
```Java
public class Dog {
private String breed;
public String getBreed(){
return breed;
}
public boolean isSameBreed(Dog otherDog){
return
// breed.equals(otherDog.breed);
this.breed.equals(otherDog.breed);
// **this** makes the code more readable/clear but is not required
}
}
```
```Java
public class DogCompetition {
public boolean doBreedMatch (Dog dog1, Dog dog2){
return this.getBreed().equals(dog2.getBreed());
// **this** refers to object which was used to call doBreedsMatch and is a DogCompetition object, not dog object (CANNOT CALL getBreed())
// this.dog1
// dog1 is not data member (parameter) so incorrect
// doBreedMatch doesn't use any data from DogCompetition class no way to use this
}
}
```
### Local vs Instance
Make the code a little clearer by using the **this** keyword
b,a,w,and s aren't meaningful parameters change them into breed, age, weight, and score
distinguish the local and instance variables using the **this** keyword
```Java
public class Dog {
private String breed;
private int age;
private double weight;
private double score;
public Dog(sting b, int a, double w, double s){
// 1. make this code a little clearer by using the **this** keyword
// 2. change the parameters into something more meaningful
// 3. distinguish local vs instance variables using **this** keyword
breed = b;
age = a;
weight = w;
score - s;
}
}
```
### HACKS
1. what does using **this()** in a constructor mean in your own words
Using the this() keyword in a constructor invokes another constructor within the same class. This constructor may either have no parameters or take specific parameters. When invoking constructors with parameters, it's essential to provide the appropriate arguments. Utilizing this() facilitates the reusability of code across constructors, particularly in scenarios where there are numerous constructors that might otherwise complicate code readability.
## 5.10 Ethical and Social Implications of Computing Systems
### Impacts
Programming affects the world in many ways, such as socially, economically, and culturally. For instance, not everyone has the same access to technology and computer programs, which creates social inequalities. Some people can use technology, while others can't. **Digital Divide**
The global economy relies heavily on technology and computer programs, especially in areas like stock trading and economic predictions. Programming and technology have also made the world more connected, allowing different cultures to mix and making it easier for people to communicate globally. However, this has also created a gap between generations, with younger people having more exposure to digital technology than older generations.
**These impacts on society, the economy, and culture can be both good and bad.**
### System Reliability
When programmers create software, they need to consider how reliable the system is. Different devices can perform the same task at varying speeds and in different ways. Each system may have security issues that hackers can exploit.
To make systems more reliable, programmers need to fix any bugs as soon as they find them. These fixes are then released to users as updates or patches to ensure that computers can be used safely and correctly.
### Intellectual Property
Usually, when people create programs on the internet, they own them. However, open source programs blur this line. In open source programs, anyone can make improvements to the code if the program owner allows it.
Licensing and access also play a role in letting others adapt and build on existing code to create their own programs. There are different types of licenses, like Creative Commons and MIT License, each serving different purposes.
Here is an [article](https://docs.github.com/en/communities/setting-up-your-project-for-healthy-contributions/adding-a-license-to-a-repository) on how to add a license on your Repository
### HACKS
As a team decide what license you want and add it to your repository (add a screenshot of it in your team ticket)