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?
choiceTwo.calories = 150; because the value is private
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;
}
}
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;
// base constructor (default)
public Book() {
this.title = "None";
this.genre = "None";
this.author = "Unknown Author";
this.numberOfPages = 0;
}
// overloaded constructor
public Book(String title, String genre, String author, int numberOfPages) {
this.title = title;
this.genre = genre;
this.author = author;
this.numberOfPages = numberOfPages;
}
public String toString() {
return "Title: " + title + "\nGenre: " + genre + "\nAuthor: " + author + "\nNumber of Pages: " + numberOfPages;
}
public static void main(String[] args) {
Book defaultBook = new Book();
System.out.println("Default Book Information:\n" + defaultBook);
Book myBook = new Book("The Great Gatsby", "Fiction", "F. Scott Fitzgerald", 180);
System.out.println("\nMy Book Information:\n" + myBook);
}
}
Book.main(null)
Default Book Information:
Title: None
Genre: None
Author: Unknown Author
Number of Pages: 0
My Book Information:
Title: The Great Gatsby
Genre: Fiction
Author: F. Scott Fitzgerald
Number of Pages: 180
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:
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(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() {
return period;
}
}
Course CSACourse = new Course("AP Computer Science A", "10, 11, 12", 1);
System.out.println("Name: " + CSACourse.getName());
System.out.println("Grade Level(s): " + CSACourse.getGradeLevel());
System.out.println("My Period: " + CSACourse.getPeriod());
Name: AP Computer Science A
Grade Level(s): 10, 11, 12
My Period: 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?
Yes we can!
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.getName()); // Name
System.out.println(volleyball.getNumAthletes()); // Number of Athletes
}
}
Sport.main(null);
volleyball
12
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) {
this.accountHolder = accountHolder;
this.balance = balance;
}
// Mutator method to set the account holder's name
public void setAccountHolder(String name) {
this.accountHolder = name;
}
// Mutator method to deposit the specified amount into the account
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
// Mutator method to withdraw the specified amount from the account
// Ensure that the balance is never negative
public void withdraw(double amount) {
if (amount > 0 && balance >= amount) {
balance -= amount;
} else {
System.out.println("Withdrawal amount is invalid or exceeds the balance.");
}
}
public static void main(String[] args) {
// Test the BankAccount class with sample operations
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 {
// Calculate the average of an array of numbers
public double calculateAverage(double[] numbers) {
if (numbers == null || numbers.length == 0) {
return 0.0; // Return a default value, or you can choose another appropriate behavior.
}
double sum = 0.0;
for (double number : numbers) {
sum += number;
}
return sum / numbers.length;
}
// Check if a given integer is prime
public boolean isPrime(int number) {
if (number <= 1) {
return false;
}
for (int i = 2; i * i <= number; i++) {
if (number % i == 0) {
return false;
}
}
return true;
}
// Find and return an array of factors for a given integer
public int[] findFactors(int number) {
if (number <= 0) {
return new int[0]; // Return an empty array, or choose another appropriate behavior.
}
int count = 0;
for (int i = 1; i <= number; i++) {
if (number % i == 0) {
count++;
}
}
int[] factors = new int[count];
int index = 0;
for (int i = 1; i <= number; i++) {
if (number % i == 0) {
factors[index] = i;
index++;
}
}
return factors;
}
public static void main(String[] args) {
MathUtility mathUtility = new MathUtility();
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: The data is the nextClassworkID and nextHomeworkID. The instance data are name and pointValue.
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 getGrade() {
return pointValue;
}
}
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 static int totalAssign() {
return (nextClassworkID + nextHomeworkID) -2;
}
}
new Assignment().totalAssign()
0
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.
- 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
3. Code segment 2 can use the variable goal but cannot use the variable current.
Question: Which ones can code segment 1 (constructor) use?
current, since it’s a nonstatic variable unlike 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?
- 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.
- 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.
Skipped this one because lecturers said it doesn’t make sense/work
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?
- The reset method cannot declare a variable named factor since a vriable named factor is declared in the constructor.
- 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.
2. The reset method cannot declare factor as private since factor is a local variable not an instance variable.
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:
-
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.
-
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).
-
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) {
// Use the 'this' keyword to distinguish instance variables from parameters
this.breed = breed;
this.age = age;
this.weight = weight;
this.score = score;
}
}
HACKS
- what does using this() in a constructor mean in your own words
You are calling another constructor of the same class from the current constructor and by doing this we get rid of redundancy
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)