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 - Had to fix String not string is the correct syntax
        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; // Will fail here calories is a private variable 
    }
}

SnackDriver.main(null)

|           choiceTwo.calories = 150;

calories has private access in Snack

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 author;
    private int numPages;

    public Book() {
        this.title = "";
        this.author = "";
        this.numPages = 0;
    }

    public Book(String t, String a, int n) {
        this.title = t;
        this.author = a;
        this.numPages = n;
    }
}

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
    }
}

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:

  • public in 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 int gradeLevel;
    private int period;

    public Course(String name, int gradeLevel, int period) {
        this.name = name;
        this.gradeLevel = gradeLevel;
        this.period = period;
    }

    public String getName() {
        return name;
    }

    public int getGradeLevel() {
        return gradeLevel;
    }

    public int getPeriod() {
        return period;
    }

    public static void main(String[] args){
        Course course1 = new Course("AP Computer Science A", 12, 1);

        System.out.println(course1.getName());
        System.out.println(course1.getGradeLevel());
        System.out.println(course1.getPeriod());
        
    }
}

Course.main(null)

AP Computer Science A
12
1

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$17$Sport@2412f4eb

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();
    }
}

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) {
        // Set the account holder's name
        this.accountHolder = name;
    }

    // Implement the deposit method
    public void deposit(double amount) {
        // Deposit the specified amount into the account
        this.balance += amount;
    }

    // Implement the withdraw method
    public void withdraw(double amount) {
        // Withdraw the specified amount from the account
        // Ensure that the balance is never negative
        if (amount <= this.balance) {
            this.balance -= amount;
        } else {
            System.out.println("Insufficient balance.");
        }
    }

    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) {
        if (numbers == null || numbers.length == 0) {
            throw new IllegalArgumentException("Input array cannot be null or empty.");
        }
        double sum = 0;
        for (double number : numbers) {
            sum += number;
        }
        return sum / numbers.length;
    }

    // Implement the isPrime method
    public boolean isPrime(int number) {
        if (number <= 1) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(number); i++) {
            if (number % i == 0) {
                return false;
            }
        }
        return true;
    }

    // Implement the findFactors method
    public int[] findFactors(int number) {
        if (number <= 0) {
            throw new IllegalArgumentException("Input number must be positive.");
        }
        int[] factors = new int[number];
        int count = 0;
        for (int i = 1; i <= number; i++) {
            if (number % i == 0) {
                factors[count++] = i;
            }
        }
        return Arrays.copyOf(factors, count);
    }

    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: Static data is data that is associated with the class rather than with instances of the class. It is shared among all instances of the class. Static data is declared using the static keyword. Instance data is data that is associated with instances of the class and varies for each instance. Each instance has its own version of instance data. Instance data is declared without using the static keyword.

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 need to 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;

    public Assignment(String name, int pointValue) {
        this.name = name;
        this.pointValue = pointValue;
    }

    public double getGrade(int score) {
        return (double) score / pointValue;
    }

    public static void main(String[] args) {
        Assignment assignment1 = new Assignment("Assignment 1", 100);
        System.out.println(assignment1.getGrade(12));
    }
}

Assignment.main(null);

0.12

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;

    public Assignment(String name, int pointValue) {
        this.name = name;
        this.pointValue = pointValue;
        nextClassworkID++;
        nextHomeworkID++;
    }

    public static int totalAssign() {
        int totalAssignments = nextClassworkID + nextHomeworkID;
        return totalAssignments;
    }

    public static void main(String[] args){
        Assignment assignment1 = new Assignment("Assignment 1", 100);
        Assignment assignment2 = new Assignment("Assignment 2", 100);
        Assignment assignment3 = new Assignment("Assignment 3", 100);
        Assignment assignment4 = new Assignment("Assignment 4", 100);
        Assignment assignment5 = new Assignment("Assignment 5", 100);
    
        System.out.println("There are " + Assignment.totalAssign() + " total assignments");
    }
}

Assignment.main(null);

There are 12 total assignments

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? - Statement 2 is true

  1. Code segment 1 can use the variable goal but cannot use the variable current.
  2. Code segment 1 cannot use the variable goal but can use the variable current.
  3. Code segment 2 can use the variable goal but cannot use the variable current.
  4. Code segment 2 cannot use the variable goal but can use the variable current.
  5. Both code segments have access to both variables

Question: Which ones can code segment 1 (constructor) use? Code Segment one can use only static variables which is goal.

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? - Statement 3 is true

  1. Objects e1 and e2 each have a variable goal and variable current.
  2. Objects e1 and e2 share the variable goal and share the variable current.
  3. Objects e1 and e2 share the variable goal and each have a variable current.
  4. Objects e1 and e2 each have a variable goal and share the variable goal and share the variable current.
  5. The code does not compile 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
}

Which of the following is the reason this code does not compile? - Option 2 is the reason this code will not compile

  1. The reset method cannot declare a variable named factor since a variable named factor is declared in the constructor.
  2. The reset method cannot declare factor as private since factor is a local variable not an instance variable.
  3. The constructor cannot declare a variable named factor since a variable named factor is declared in the reset method.
  4. The constructor cannot access the isInstance variable current since current is private.
  5. 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

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

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
    }
}

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

public class Dog {
    public Dog(String 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
        this.breed = b;
        this.age = a;
        this.weight = w;
        this.score - s;
    }
}

HACKS

  1. what does using this() in a constructor mean in your own words
    • Using this() in a constructor refers to calling another constructor within the same class which is used to avoid code duplication when multiple constructors have similar code. By calling another constructor with this(), it allows for code reuse from that constructor and pass any additional arguments required for the current constructor. This can help to make the code more concise and easier to maintain.

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 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)

image

image