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