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; // this line causes the error
    }
}

|           choiceTwo.calories = 150; // this line causes the error

calories has private access in Snack

Correction to SnackDriver Code Segment

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.setCalories(150); // correction
        System.out.println(choiceTwo.getName());
        System.out.println(choiceTwo.getCalories());
    }
}

SnackDriver.main(null);

cookies


100
chips
150

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 pages;


    public Book() {
        title = "";
        genre = "";
        author = "";
        pages = 0;
        
    }

    public Book (String t, String g, String a, int p) {
        title = t;
        genre = g;
        author = a;
        pages = p;
    }


    // getter and setter methods
    public String getTitle() {
        return title;
    }

    public String getGenre() {
        return genre;
    }

    public String getAuthor() {
        return author;
    }

    public int getPages() {
        return pages;
    }

    public void setTitle(String t) {
        title = t;
    }

    public void setGenre(String g) {
        genre = g;
    }

    public void setAuthor(String a) {
        author = a;
    }

    public void setPages(int p) {
        pages = p;
    }
}
    


public class Main {
    public static void main(String [] args){

        Book b = new Book("Internment", "Dystopian Fiction", "Samira Ahmed", 400);
        Book b1 = new Book("American Street", "Young Adult Fiction", "Ibi Ziboi",  352);
        
        System.out.println(b.getAuthor());
        System.out.println(b.getPages());
        
    }
}

Main.main(null);

Samira Ahmed
400

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

Call to Movie Class

public class Main {
    public static void main(String [] args){
        Movie m1 = new Movie("Endgame", 182);

        System.out.println(m1.getName());
        System.out.println(m1.getRuntime());
    }
}
Main.main(null);

Endgame
182

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 String gradeLevel;
    private int period;

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

    public String getName(){
        return name;
    }

    public String getGradeLevel(){
        return gradeLevel;
    }

    public int getPeriod(){
        return period;
    }
}

Call to Course Class

public class Main {

    public static void main(String [] args){

        Course c1 = new Course("AP CSA", "High School", 1);
        

        System.out.println(c1.getName());
        System.out.println(c1.getPeriod());
    

    }

}

Main.main(null);


AP CSA
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$18B$Sport@2e384f12

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 accountHolder) {
        this.accountHolder = accountHolder;
    }

    // Implement the deposit method
    public void deposit(double amount) {
        if(amount > 0){
            balance += amount;
        }
    }

    public String getAccountHolder(){
        return accountHolder;
    }

    public double getBalance(){
        return balance;
    }

    // Implement the withdraw method
    public void withdraw(double amount) {
        if(amount > 0 && balance-amount > 0){
            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);
    }
}

Calculator.main(null);


Addition: 8
Subtraction: 3
Multiplication: 24
Division: 4

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) {
        double sum = 0;
        double average = 0;
        for(int i = 0; i < numbers.length; i++){
            sum += numbers[i];
        }

        average = sum / numbers.length;

        return average;
    }

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

        return true;



    }

    // Implement the findFactors method
    public int[] findFactors(int number) {

        List<Integer> factors = new ArrayList<>();
        for(int i = 1; i <= number; i++){
            if(number % i == 0){
                factors.add(i);
            }
        }

        int[] factorsArray = new int[factors.size()];
        for(int i = 0; i < factors.size(); i++){
            factorsArray[i] = factors.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: In the above code segment, the variables nextClassworkID and nextHomeworkID would be the static data, as both variables are associated with the class and not the specific instance itself (shared across all instances of the class). On the other hand, the variables name and pointValue would be the instance data, as each object of the Assignment class will have its own name and pointValue. Each object will be unique to each instance for the name and pointValue variables.

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){
        this.name = name;
    }


    public double getGrade(int score){
        if(pointValue == 0){
            return score / 100.0;
        } else {
            return score / (double) pointValue;
        }
    }

    public static void main(String [] args){
        Assignment assignment = new Assignment("Unit 5 Homework");
        int score = 90;
        System.out.println(assignment.getGrade(score));

    }

}
Assignment.main(null);

0.9

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 static int totalPoints = 0;
    private String name;
    private int pointValue;
    
    public Assignment(String name, int pointValue, boolean isHomework) {
        this.name = name;
        this.pointValue = pointValue;
        Assignment.totalPoints += pointValue;

        if (isHomework) {
            this.nextHomeworkID++;
        } else {
            this.nextClassworkID++;
        }
    }

    public static int totalAssign() {
        return (nextClassworkID - 1) + (nextHomeworkID - 1);
    }

    public static int getTotalPoints() { // method that returns total number of points
        return totalPoints;
    }



    public static void main(String[] args) {
        // Create assignments
        new Assignment("Math Homework", 100, true);
        new Assignment("Science Classwork", 100, false);

        // Output the total number of assignments
        System.out.println("Total number of assignments: " + Assignment.totalAssign());
        System.out.println("Total number of points: " + Assignment.getTotalPoints());

    }
}

Assignment.main(null)

Total number of assignments: 2
Total number of points: 200

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? (correct answer in bold)

  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

Explanation for first MCQ:

Code segment 2 is a static method, so it can only access static variables. Static methods belong to the class itself instead of a certain instance, so the variable current cannot be used since it is an instance variable. However, because goal is a static variable, code segment 2 can therefore access the variable goal.

Question: Which ones can code segment 1 (constructor) use?

Code segment 1 can use both the variable current and the variable 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?

  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 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; // this keyword
        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?

  1. The reset method cannot declare a variable named factor since a vriable 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 isntance 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 {
    private String breed;
    private int age;
    private double weight;
    private double score;

    public Dog(String breed, int age, double weight, double score){
        // 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 = breed;
        this.age = age;
        this.weight = weight;
        this.score = score;
    }

    public String getBreed() {
        return breed;
    }

    public int getAge() {
        return age;
    }

    public double getWeight() {
        return weight;
    }

    public double getScore() {
        return score;
    }
}

public class Main {
    public static void main(String [] args){
        Dog dog = new Dog("German Shepherd", 8, 96.3, 100.0);

        System.out.println("Breed: " + dog.getBreed());
        System.out.println("Age: " + dog.getAge() + " years old");
        System.out.println("Weight: " + dog.getWeight() + " pounds");
        System.out.println("Score: " + dog.getScore());

    }
}

Main.main(null);

Breed: German Shepherd
Age: 8 years old
Weight: 96.3 pounds
Score: 100.0

HACKS

  1. what does using this() in a constructor mean in your own words

The this keyword in Java points to the current object in a method or constructor. In constructors, the this() keyword calls another constructor in the same class.

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)

Extra Stuff

I created a calculator in java that involves using user input to create an array of numbers. Not only does the program give the sorted list of numbers, it also gives the mean, median, and mode of the list as well.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;

public class DataSetCalculator {

    public static void main(String[] args) {
        ArrayList<Double> data_set = getData();
        System.out.println("Unsorted List: " + data_set);
        ArrayList<Double> sorted_data_set = sort(data_set);
        System.out.println("Sorted List: " + sorted_data_set);
        System.out.println("The mean of your data set is " + mean(data_set));
        System.out.println("The median of your data set is " + median(data_set));
        System.out.println("The mode of your data set is " + mode(data_set));
    }

    public static ArrayList<Double> getData() {
        ArrayList<Double> data_set = new ArrayList<>();
        System.out.println("Welcome to the data set calculator! Here you can input a set of data and find out all sorts of information about it!");

        boolean complete = false;
        Scanner scanner = new Scanner(System.in);

        while (!complete) {
            try {
                System.out.print("Enter a data point: \n");
                double data = Double.parseDouble(scanner.nextLine());
                data_set.add(data);
            } catch (NumberFormatException e) {
                System.out.println("Invalid input. Please input a number.");
            }

            System.out.print("Would you like to keep entering points? (y/n) \n");
            String answer = scanner.nextLine();
            if (answer.equalsIgnoreCase("n")) {
                complete = true;
            }
        }

        return data_set;
    }

    public static double mean(ArrayList<Double> data_set) {
        double sum = 0;
        for (double num : data_set) {
            sum += num;
        }
        return sum / data_set.size();
    }

    public static double median(ArrayList<Double> data_set) {
        int length = data_set.size();
        int middleIndex = length / 2;

        if (length % 2 == 1) {
            return data_set.get(middleIndex);
        } else {
            double middleValue1 = data_set.get(middleIndex - 1);
            double middleValue2 = data_set.get(middleIndex);
            return (middleValue1 + middleValue2) / 2;
        }
    }

    public static double mode(ArrayList<Double> data_set) {
        HashMap<Double, Integer> occurrences = new HashMap<>();
        double mode = 0;
        int most_times = 0;

        for (double num : data_set) {
            occurrences.put(num, occurrences.getOrDefault(num, 0) + 1);
            int count = occurrences.get(num);
            if (count > most_times) {
                most_times = count;
                mode = num;
            }
        }

        return mode;
    }

    public static ArrayList<Double> sort(ArrayList<Double> data_set) {
        int length = data_set.size();

        for (int i = 0; i < length; i++) {
            for (int j = 0; j < length - i - 1; j++) {
                if (data_set.get(j) > data_set.get(j + 1)) {
                    double temp = data_set.get(j);
                    data_set.set(j, data_set.get(j + 1));
                    data_set.set(j + 1, temp);
                }
            }
        }

        return data_set;
    }
}

DataSetCalculator.main(null)

Welcome to the data set calculator! Here you can input a set of data and find out all sorts of information about it!
Enter a data point: 
Would you like to keep entering points? (y/n) 
Enter a data point: 
Would you like to keep entering points? (y/n) 
Enter a data point: 
Would you like to keep entering points? (y/n) 
Enter a data point: 
Would you like to keep entering points? (y/n) 
Enter a data point: 
Would you like to keep entering points? (y/n) 
Enter a data point: 
Would you like to keep entering points? (y/n) 
Enter a data point: 
Would you like to keep entering points? (y/n) 
Enter a data point: 
Would you like to keep entering points? (y/n) 
Enter a data point: 
Would you like to keep entering points? (y/n) 
Enter a data point: 
Would you like to keep entering points? (y/n) 
Unsorted List: [19.0, 201.0, 423.0, 756.0, 2015.0, 19.0, 20.0, 20.0, 20.0, 68.0]
Sorted List: [19.0, 19.0, 20.0, 20.0, 20.0, 68.0, 201.0, 423.0, 756.0, 2015.0]
The mean of your data set is 356.1
The median of your data set is 44.0
The mode of your data set is 20.0