CS 241 lecture

Lightning review of Java

The big three of Object Oriented Programming
- Inheritance
- Encapsulation
- Polymorphism
Some facts
- Almost all processing is Java is accomplished by sending messages to objects
- Objects are instances of classes; they are references (i.e. addresses, or pointers)
- The other two simple statements are return and assignment, details here.
Class definitions
- Class definitions include variables and methods, both are referred to as members
- There are two types of methods, ordinary methods and constructors; initialization is (typically) done in constructors
- Once a class is defined, you may instantiate it (i.e. create an instance of it), by saying new ClassName()
- Instantiation has 3 steps (there are times when you must understand this sequence, or you can encounter extremely elusive bugs!):
  1. Allocate space for the variables (instance and class)
  2. Initialize the variables, either using the assignment, or to zero by default
  3. Execute the matching constructor
- Members may belong to classes (if they are preceded by static) or instances (by default)
  1. Methods - the actions the class (or its instances) can perform
    - In the body of an instance method, there is a hidden parameter called this, it is a reference to the object which received the message
    - The syntax of a method definition is: <type> <name> ([<parameters>]) <body>, unless the method is a constructor; constructors share the name of their class and have no return type.
    - If a method returns nothing then the type is void, otherwise it must end with return <expression>;, where <expression> has a type compatible with the return type.
  2. Variables - where information is stored
    1. Every variable has a type and a name. Common types include:
      1. primitive
        
        int (also, byte(1), short(2), and long(8) for different numbers of bytes and thus ranges)
        
        double (also float, but nobody uses that anymore)
        
        char
        
        boolean
      2. built in
        
        Data structures! arrays, ArrayList<T>
        
        JFrame, JDialog, and all the rest of the Components
        
        Graphics, Color, etc
        
        Math, Integer, Character, etc
        
        etc!!
      3. user defined - every class applications programmers write!
    2. there are 5 different kinds of variables
      1. instance
      2. class
      3. method
      4. parameter
      5. loop
      6. Danger! The most local variable with a particular name is used; i.e. you can shadow a variable by accidently giving another variable (including parameters) the same name (although NetBeans will put up a yellow warning if you do).
Inheritance
- Which method gets invoked?
- Chains of super()
Creating objects (instances)
- Every object must be created by sending new to the appropriate class
- new Foo(), is really Foo.Foo(), i.e. the Foo() message is sent to the Foo class (classes are in fact objects).
- Special syntax for invoking other constructors from a constructor
  1. must come first
  2. use super(), for the superclass; or this(), for the default constructor for this class
- If you forget to initialize an object, you will get a null pointer exception when you try to send it a message.

Exceptions -- another debugging tool (or bug prevention device).

    int getInt(JTextField aTF) {
        try {
            int n = Integer.parseInt(aTF.getText());
            return n;
        } catch (NumberFormatException e) {
            return INPUT_ERROR;
        }
    }

Arrays in Java
- A number of variables, all of the same type -- called elements
- Fixed length: a) cannot change size! b) if not full, need to keep track of how many elements
- First index is 0
- int[] list = new int[10]; // 10 int variables, all 0 initially
  ...or int[] list = {1, 4, 9, 16} // 4 int variables with values 1, 4, 9, 16
- To print the values in an array:
```
                        for (int i=0; i<list.length; i++)
                             sout(list[i]);

                        or
                        for (int nextInt: list)
                             sout(nextInt);
```
- Oh! Wait... google: java tutorial array