Young Coders: Week 3 Notes

-
Yesterday, we learned about classes and some data structures. 

Classes

A “specification” or “blueprint” that says how to construct an object. Here is the Pet class we made: 


public class Pet {
 //fields
 public String name; 
 public String color;
 public int legs; 
 public int speed; 

 private int pinNum; 

 //constructor
 public Pet (String name, String color, int legs, int speed) {
   this.name = name;
   this.color = color;
   this.legs = legs;
   this.speed = speed; 
   pinNum = 1111; 
 }

 //methods
 public int getPin() {
  return pinNum;  
 }

 public void setColor(String color) {
   this.color = color; 
 }

 public void exercise(int increase) {
   speed += increase;  
   color = "red"; 
 }

 public void sleep() {
   speed = 0; 
   color = "blue"; 
 }

 public void wakeUp() {
   speed = 5;
   color = "green"; 
 }

 public String toString() {
   return "this works"; 
 }

 public static void main(String[] args) {
   Pet myFirstPet = new Pet("Finn", "purple", 0, 5);
   myFirstPet.exercise(3); 
   
   myFirstPet.sleep(); 
   System.out.println(myFirstPet);
 }
}

Subclasses

Why use subclasses?

The Pet class already has some fields and methods that overlap with our new class, Dog. We don't want to rewrite all that code!

 Some things to know: 
  • A subclass constructor can invoke the constructor of the superclass. (Example: the Dog constructor) 
  • Declare new methods in the subclass. (Example: trainDog() method) 
  • Use the fields and methods of the superclass. A subclass inherits fields and methods from its superclass. (Example: the field, "color") 
  • Override a method in the superclass. (Example: wakeUp() method) 
  • Block the subclass from inheriting members of the superclass by using private. The subclass can access those members if you write public/protected accessor methods. (Example: our dog's pin number and the Pet class's method getPin()) 

     Here is our subclass example, Dog: 
    public class Dog extends Pet {
     //field
      public boolean sit; 
      
      //constructor
      public Dog (String name, String color, int speed, boolean sit) {
        super(name, color, 4, speed); 
        this.sit = sit; 
      }
      
      //method
      public void trainDog() {
        sit = true;  
      }
      
      public void wakeUp() {
       speed = -5;
       color = "brown"; 
      }
      
      public static void main(String[] args) {
        Dog myFirstDog = new Dog("Molly", "black", 20, false); 
        
        //myFirstDog.trainDog(); 
        //System.out.println(myFirstDog.sit);
        
        //myFirstDog.sleep(); 
        //System.out.println(myFirstDog.color); 
        
        //myFirstDog.wakeUp(); 
        //System.out.println(myFirstDog.color); 
        
        System.out.println(myFirstDog.getPin()); 
      }
    }

    Stacks

    A stack is a data structure (a collection of elements). It's LIFO, or "last in first out". Imagine a stack of dishes or papers. The last dish or paper on the stack is on the top, so it's also the first one you remove. 

    In our Stack class, two of the methods are "push" and "pop". When we add an element to a stack, we say we "push" it. When we remove an element from a stack, we "pop" that element. 

    To implement a Stack (of integers), we made a pointer that points to the top of the stack. We also used an array of integers: 



    import java.util.Arrays; 

    public class Stack {
      //fields
      private int[] array; 
      private static final int CAPACITY = 10; 
      private int topOfStack = -1; 
      
      //constructor
      public Stack() {
        array = new int[CAPACITY];  
      }
      
      //methods
      public void push(int element) {
         if(array.length == CAPACITY)
           reallocate(); 
         
         topOfStack++; 
         array[topOfStack] = element; 
      }
      
      public int pop() {
       if(empty())
         throw new RuntimeException("stack is empty - nothing to pop");
       
       int removed = array[topOfStack]; 
       topOfStack--; 
       return removed; 
      }
      
      public boolean empty() {
        if(topOfStack == -1) 
          return true; 
        else
          return false; 
      }
      
      private void reallocate() {
        int length = array.length; 
        array = Arrays.copyOf(array, 2*length); 
      }
      
      public static void main(String[] args) {
        Stack myFirstStack = new Stack(); 
        
        //myFirstStack.pop(); 
        
        myFirstStack.push(100); 
        myFirstStack.push(200); 
        myFirstStack.push(99); 
        
        int removedElement = myFirstStack.pop(); 
        System.out.println(removedElement); 
      }
    }


    ArrayList

    Arrays have a fixed length. You have to know beforehand how many elements the array will contain. On the other hand, ArrayLists have an initial size, but can grow and shrink when you add or remove objects. Here are some examples we tried yesterday: 

    import java.util.ArrayList; 

    public class ArrayListEx{
      public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<String>();
        
        System.out.println(colors.size());
        
        colors.add("brown");
        colors.add("blue");
        colors.add("magenta");
        colors.add("red");
        colors.add("pink"); 
        
        System.out.println(colors.size()); 
        
        colors.add(3, "gray"); 
        
        System.out.println(colors); 
      }
    }

    Queue

    A queue is FIFO (first in first out). We thought of a queue as a line of people waiting at Disneyland. If you are the first one to line up, you should be the first one out of the line and on the ride! 


    import java.util.ArrayList; 

    public class Queue {
      //fields
      private ArrayList<String> array; 
      
      //constructor
      public Queue () {
        array = new ArrayList<String>(); 
      }
      
      public void enq(String element) {
        array.add(element); 
      }
      
      public String deq() throws Exception {
        if(array.size() < 0) 
          throw new Exception("nothing to deq");
        
        String element = array.remove(0); 
        return element; 
      }
      
      public int size() {
        return array.size(); 
      }
      
      public static void main(String[] args) throws Exception {
        Queue animals = new Queue(); 
        
        animals.enq("Tiger");
        animals.enq("Pig");
        animals.enq("Zebra");
        animals.enq("Lion squirrel");
        animals.enq("Anteater");
        animals.enq("My brother"); 
        
        //System.out.println(animals); 
        
        System.out.println(animals.size());
        
        System.out.println(animals.deq()); 
      }
    }

    A reminder: the Candy Challenge for this week is to write a toString() method for our queue class that returns its elements! 

    Good job yesterday! Next week will be our final class. Same time, same place: Sunday, 1-3 pm. We'll be looking at sorting and searching algorithms. 

Popular posts from this blog

Building A Toy Language Interpreter in Go

-
Image
In this post, I'll be giving a high-level overview of interpreters, why they're interesting, and how they work. I'll be referencing my repo, go_interpreter , which is a simple interpreter written in Go for a toy language. The figure below shows the structure of our interpreter with an example input: What is an interpreter?  An interpreter is a language processor that seems to directly execute the source program on user input: In contrast, a compiler first takes in a source program and translates it to an executable machine code target program. Then, the user can pass in inputs to this target program and get outputs. In general, an interpreter is better at reporting errors since it's processing statements one at a time, and a compiler is faster at generating outputs from inputs. In this post, we're going to go over a simple interpreter that is capable of supporting: integers, booleans, strings, arrays, hashmaps prefix, infix operators index opera
Read more

Space Race: a simple Rust game built on the Bevy framework

-
Image
When I saw a post announcing the release of the Bevy framework  (an open source game engine written in Rust), I thought it'd be a fun way to learn Rust.  So I made Space Race , a 2 player game on top of the Bevy framework. How to Play The Astronaut moves around collecting jewels (using WASD keys). The Alien moves around trying to catch the Astronaut (using arrow keys).  The Astronaut wins if they collect at least 5 jewels and make it back to home base before the Alien catches them.  The Alien wins otherwise.  Things I learned about Rust  I had a lot of fun making & playing this game, and also got some hands on experience with Rust like working with structs enums vectors iterators traits dyn trait vs impl trait  dyn trait is used for trait objects, which are fat pointers made up of 1) a pointer to the value 2) a pointer to a vtable. A vtable is a table of methods, where each method points to its implementation, generated once at compile time. Each instance of a type that impleme
Read more

Building a Toy Language Compiler in Go

-
Image
A follow-up to my previous post about building a toy language interpreter in Go. Throughout this post, I'll be referencing my repo . We'll go over a compiler which translates source code to machine code, and then a VM to execute this machine code. What is a compiler?  A compiler takes source code and translates it to executable machine code . (See my previous post for more details.) The figure below shows the high-level architecture of a simple compiler. Like the interpreter we built previously, our compiler has a lexer and a parser which turn our source code into an AST . This is our compiler's frontend . However, that's where a compiler diverges.  The compiler may translate the AST into at least one internal representation (IR) . The IR(s) may be represented using any data structure (even another AST!), but they should follow two rules: (1) be easy to produce, (2) be easy to translate into the target machine code. The IR can also be optimized
Read more