website/content/ta/fall2017/cpsc220/sept6.md

CPSC 220 Lecture 3

Variables

Variable -- Storage of information

The type cannot change in a variable.

Examples of types include

• int
• float
• double
• String
• char
• boolean

Declaration: int num;

Initialization: num = 5;

Declaration + Initialization: int num = 5;

Possible Errors

You cannot declare a variable multiple times.

Undefined variables are when you do not declare a variable before attempting to use it.

Casting

You need to cast if you are attempting to lose data or store a larger memory type into a smaller one.

double -> float -> int (casting required)

double gpa = 3.2;
int num1 = 10 * (int)gpa // 30

Operations

The basic number operations are

• /
• % (the remainder)

Examples

0 % 2 // 0
1 % 2 // 1
2 % 2 // 0

3 % 2 // 1
4 % 2 // 0
5 % 2 // 1

3 % 5 // 3
7 % 5 // 2

You can test if something is even using modulus %

// Assuming i was initiliazed to a value earlier
if (i % 2 == 0) {
  System.out.println("i is even");
} else {
  System.out.println("i is odd");
}

System input

Here is sample code using a Scanner as input

import java.util.Scanner;
public class ScannerExample {
  public static void main(String[] args) {
    Scanner in;
    in = new Scanner(System.in);
    
    // Grab numerical values
    int num = in.nextInt();
    float gpa = in.nextFloat();
    double weight = in.nextDouble();
      
    // Grab a single character
    in.nextLine()
    char initial = in.next().charAt(0);
    
    // To get the entire line of a string
    in.nextLine();
    String name = in.nextLine();
  }
}

You need to use in.nextLine() to grab the carriage return that is left after grabbing a numeric value.

Classes and Objects

Classes are a new type that you can have multiple things of.

These classes are blueprints that are made up of primitives or more basic types.

First create a Pet.java file (Name of the class must match the name of the file)

public class Pet {
  private String name;
  private int years;
}

You can then use the Pet class in your main program. The terminology here is that you can create instances or objects of the class.

In PetTester.java

public class PetTester {
  public static void main(String[] args) {
    Pet myPet;
    myPet = new Pet();
  }
}

Both Pet.java and PetTester.java must be in the same directory/folder

Mutators/Accessors

Since the variables are private we cannot access them in the main program. To work around this, we can write what is called a mutator method.

public class Pet {
  private String name;
  private int years;
  
  // Mutators
  public void setName(String n) {
      name = n;
  }
  public void setYears(int y) {
      if (y >= 0) {
          years = y;
      } else {
          System.out.println("No one is less than 0 years old.")
      }
  }
}

Now let's use these new methods

public class PetTester {
  public static void main(String[] args) {
    Pet mypet;
    myPet = new Pet();
    myPet.setName("Fred");
    myPet.setAge(20);
  }
}

We need a method that will allow us to access the data type. Let's add accessors to our pet class.

public class Pet {
  private String name;
  private int years;
  
  // Mutators
  public void setName(String n) {
    name = n;
  }
  public void setYears(int y) {
    if (y >= 0) {
      years = y;
    } else {
      System.out.println("No one is less than 0 years old.")
    }
  }
  
  // Accessors
  public String getName() {
    return name;
  }
  public int getYears() {
    return years;
  }
}

Now let's get some information from the pet object, such as the age.

public class PetTester {
  public static void main(String[] args) {
    Pet mypet;
    myPet = new Pet();
    myPet.setName("Fred");
    myPet.setYears(20);
    
    int year = myPet.getYears();
  }
}

Constructors

Constructors lets us initialize variables in the class without having to use mutator methods.

public class Pet {
  private String name;
  private int years;
  
  // Default Constructor
  public Pet() {
    name = "";
    years = 0;
  }
  // Non-Default Constructor
  public Pet(int y, String n) {
    name = n;
    years = y;
  }
  
  // Mutator Methods
  public void setName(String n) {
    name = n;
  }
  public void setYears(int y) {
    if (y >= 0) {
      years = y;
    } else {
      System.out.println("No one is less than 0 years old.")
    }
  }
  
  // Accessor Methods
  public String getName() {
    return name;
  }
  public int getYears() {
    return years;
  }
}

Now let us see this in action.

public class PetTester {
  public static void main(String[] args) {
    Pet yourPet = new Pet(10, "Fluffy");
  }
}

You can have as many constructors as you want, but they must be different.

Example:

public class Pet {
  ...
  pet() {
    name = "";
    years = 0;
  }
  pet(int y, String n) {
    name = n;
    years = y;
  }
  pet(String n) {
    years = 1;
    name = n;
  }
  ...
}