CS61B: Lecture 2

Dogs

• Below is an example of a Dog class, and a launcher class that invokes methods from the Dog class.
• However, not all dogs are created equal, dogs may have different behaviors.

public class Dog {
    public static void makeNoise() {
        System.out.println("bark");
    }
}

public class DogLauncher {
    public static void main(String[] args) {
        Dog.makeNoise();
    }
}

DogLauncher.main(null);

bark

Object Instantiation

• Classes can contain not just functions, but also different data.
  • For example, we may update the Dog class to contain additional data.
• Using a class, we may instantiate a method.
• There are static (instance) and non-static (class) attributes and methods.
  • If an instance needs to access a method, that method must be non static.
• New instance variables cannot be added to a class or object. It must obey the blueprints.
• If a created object is not assigned, in Java it is garbage collected, meaning it is destroyed.

public class Dog {
    public int weightInPounds; // This is an instance variable. It is not static

    // This is a constructor that is ran when the object is created.
    public Dog(int s) {
        weightInPounds = s;
    }

    // This is an instance method
    public void makeNoise() {
        if (weightInPounds > 20) {
            System.out.println("aroooooo!");
        } else if (weightInPounds > 10) {
            System.out.println("bark");
        } else {
            System.out.println("yipyipyip");
        }
        
    }
}

public class DogLauncher {
    public static void main(String[] args) {
        Dog maya = new Dog(25); // Declaration, Instantiation, and Assignment
        maya.makeNoise();
    }
}

DogLauncher.main(null);

aroooooo!

Array of Objects

• To create an array, we use the new keyword.
  • To add objects to the array, we use new for each object that we want to add into the array.

Dog[] dogArray = new Dog[5];
dogArray[0] = new Dog(20);
System.out.println(dogArray.toString());

[LREPL.$JShell$12I$Dog;@64052435

Static vs Non-static

• The key differences between static and non-static (instance) methods:
  • Static methods are invoked using the class name: (i.e. Dog.makeNoise();)
  • Instance methods are invoked using an instnace name (i.e. maya,makeNoise();)
  • Static methods cannot access any instance variables as it doesn’t know which instance to access.
  • Non-static memebrs cannot be invoked using class name.
• We have static methods because some classes are never instantiated like Math.

Math.round(5.6);

6

• We now add a static method to our dog class.

public class Dog {
    public int weightInPounds; // This is an instance variable. It is not static

    // This is a constructor that is ran when the object is created.
    public Dog(int s) {
        weightInPounds = s;
    }

    // This is an instance method
    public void makeNoise() {
        if (weightInPounds > 20) {
            System.out.println("aroooooo!");
        } else if (weightInPounds > 10) {
            System.out.println("bark");
        } else {
            System.out.println("yipyipyip");
        }
        
    }

    public static Dog maxDog(Dog d1, Dog d2) {
        if (d1.weightInPounds > d2.weightInPounds) {
            return d1;
        }
        return d2;
    }
}

public class DogLauncher {
    public static void main(String[] args) {
        Dog maya = new Dog(25); // Declaration, Instantiation, and Assignment
        Dog hugeGreg = new Dog(1500);
        Dog largerDog = Dog.maxDog(maya, hugeGreg);
        largerDog.makeNoise();
    }
}

DogLauncher.main(null);

aroooooo!

Static Variables are Dangerous

• Do not have a static variable that changes.

Static vs Final

• static: It is universal.
• final: it doesn’t change.

public class Dog {
    public int weightInPounds; // This is an instance variable. It is not static
    public static String binomen = "Canis familiaris"; // This is a static variable. It is shared across all dogs.

    // This is a constructor that is ran when the object is created.
    public Dog(int s) {
        weightInPounds = s;
    }

    // This is an instance method
    public void makeNoise() {
        if (weightInPounds > 20) {
            System.out.println("aroooooo!");
        } else if (weightInPounds > 10) {
            System.out.println("bark");
        } else {
            System.out.println("yipyipyip");
        }
        
    }

    public static Dog maxDog(Dog d1, Dog d2) {
        if (d1.weightInPounds > d2.weightInPounds) {
            return d1;
        }
        return d2;
    }
}

public class DogLauncher {
    public static void main(String[] args) {
        Dog maya = new Dog(25); // Declaration, Instantiation, and Assignment
        Dog hugeGreg = new Dog(1500);
        Dog largerDog = Dog.maxDog(maya, hugeGreg);
        largerDog.makeNoise();
    }
}

DogLauncher.main(null);

List

• A list is an ordered sequence of objects represented by comma-separated values in-between brackets.
  • Ex: [3,6,9,12,15]
• Lists support many operations that are detailed by the programming language itself.
  • Adding (appending) to a list.
  • Inserting to a list.
  • Removing from a list.
  • Retrieving from a list.
  • etc.
• Using a list in Java:
  • The List class is abstract, so it may not be instantiated. We must use an Array-based list or someting else.

import java.util.List;
import java.util.ArrayList;

public class ListDemo {

    public static void main(String[] args) {
        List L = new ArrayList();
        L.add("a");
        L.add("b");
        L.add("c");
        System.out.println(L);
    }
}

ListDemo.main(null);

[a, b, c]

• We may also use a linked list

import java.util.List;
import java.util.LinkedList;

public class ListDemo {

    public static void main(String[] args) {
        List L = new LinkedList();
        L.add("a");
        L.add("b");
        L.add("c");
        System.out.println(L.get(0));
    }
}

ListDemo.main(null);

a

• Java has a lot of lists, and a programmer must decide what list they want to use.

Abstract Data Types vs Concrete Data Types

• In Java, a List is an abstract class, meaning that all lists share the properties of List.
• We have many different concrete Data Types because different lists have different properties that make them better at certain things.
  • Ex: A stack based list has “push” and “pop” operations.

Specified Data Types for Collections.

• We may specify what type our list stores using the angled-bracket syntax.

import java.util.List;
import java.util.LinkedList;

public class ListDemo {

    public static void main(String[] args) {
        List L = new LinkedList();
        L.add("a");
        L.add("b");
        L.add("c");
        String a = L.get(0); // This fails
    }
}

ListDemo.main(null);

|           L.add("a");

unchecked call to add(E) as a member of the raw type java.util.List



|           L.add("b");

unchecked call to add(E) as a member of the raw type java.util.List



|           L.add("c");

unchecked call to add(E) as a member of the raw type java.util.List



|           String a = L.get(0); // This fails

incompatible types: java.lang.Object cannot be converted to java.lang.String

import java.util.List;
import java.util.LinkedList;

public class ListDemo {

    public static void main(String[] args) {
        List<String> L = new LinkedList();
        L.add("a");
        L.add("b");
        L.add("c");
        String a = L.get(0); // This works
    }
}

ListDemo.main(null);

• Thus, this syntax constrains list to only have one certain type instead of many.

Arrays

• Java has a special collection called an srray that is a restricted version of the list.
  • The size must be declared at the time the array is created.
  • Size cannot change
  • All items muste of the same type.
  • No methods.
• No python equivalent.
• Arrays are typically more performany than lists.

Maps

• A map is a collection of key-value pairs. Each key is guaranteed to be unique.
• Ex: Java

import java.util.Map;
import java.util.TreeMap;

public class MapDemo {
    public static void main(String[] args) {
        Map<String, String> L = new TreeMap<>();
        L.put("dog", "woof");
        L.put("cat", "meow");
        String sound = L.get("cat");
    }
}

MapDemo.main(null);