OOP

- - OO Analysis & Design
    - Classes represent domain elements.
    - May permit reuse.
    - Other classes necessary
    - Patterns are standard ways to relate classes
    - UML is most common visual modelling technique
    - is-a vs has-a
  - Java
    - class
      - members
        - variables
          - instance
            - One "instance" per object.
            - Declared out of methods.
            - Can not be refrenced from static context
          - static / class
            - static final used for constants.
            - Relatively little use outside of constants.
            - Can have static block initializers.
            - Only one value for class
        - methods
          - instance
            - Call from out of class qualified by object.
            - Call within class implicitly this.
            - Can access all instance and static members
          - class / static
            - Call from out of class qualified by class
            - Can also be qualified by object, which is ignored.
            - Can only access static members.
            - Useful if pure computation without state.
            - Eg, Math class.
        - classes - See inner classes below
      - constructors
        - purpose
          - Define all fields in consistent state.
        - defining
          - Same as class name, no return type
          - Can be overloaded.
        - Default
          - No-param constructor created if no user-defined.
          - If any defined, no default.
        - Chaining
          - First line always calls other contructor
          - If none, a call on default super is made.
          - Explicit
            - super
            - this
        - super
          - Refers to parent class constructor.
        - this
          - Refers to other constructors in class.
        - private
          - If all constructors private, no one can construct
          - Use Factory pattern (method returns new object).
        - finalizers
          - Ignore - like C++ destrurctors, but may not be called.
      - inner classes
        - Result in .class files with $
        - Inner class instances have implict reference to an outer class instance.
        - Reference to outer class instance with Outer.this.
        - Usually created from within outer class.
        - Can create from outside with eg, new Outer().new Inner()
        - Named, inside class
          - Instances need outer instance.
          - Can reference outer instance variables.
          - Reference to outer instance is OuterClass.this.
        - Inside method
          - named
          - Anonymous
            - Defined in a method.
            - Commonly used for listeners.
            - Can reference outer class's instance members.
            - Can reference method's final local variables.
        - static nested top-level
          - declared static inside outer class
          - Only used for name scope
          - Can not reference outer classes instance variables.
          - Eg, Box.Filler
      - abstract
        - A class is abstract if it doesn't implement all methods.
        - Must be subclassed to create an object.
        - Interfaces are like completely abstract classes.
      - final
        - final classes can not be extended (eg, String)
    - interface
      - Lists methods which must be defined to implement
      - Can define public static final constants
    - operations
      - casting
        - Upcasting
          - Casting from a subclass to a superclass.
          - No explicit cast is required.
          - No run-time check required.
        - Downcasting
          - Casting from a superclass to a subclass/interface.
          - Requires explicit cast notation.
          - Run-time check performed (ClassCastException)
      - == vs equals()
      - instanceof operator.
      - Reflection
    - scope
      - private
        - Visible only in same class.
        - Should be used for data variables.
        - Write getter/setter methods if changeable.
      - public
        - Can be seen by anyone
        - Commonly used for methods.
      - protected
        - can only be seen by child class.
        - Controversial.
      - package
        - can be seen by everyone in package
        - default
    - Objects
      - Allocated on heap with new.
      - Garbage collected when no references.
    - packages
      - Used to group classes and other packages.
      - Default package if none specified.
    - Inheritance
      - Terminology
        - Superclass - subclass
        - Parent - child
        - Base - derived
        - Anscestor - descendant
      - Can extend only one parent class.
      - Can implement multiple interfaces.
      - Object is the root of class hierarchy.
      - Overriding
        - Child class can redefine methods of anscestor class.
        - toString() is commonly overridden.
          - Concatenation calls toString()
        - equals(...) is commonly overridden
      - Polymorphism
        - A variable may contain an object of its class, or any subclass.
        - A call to a method will call the correct class's method.
        - A method can call super to call overridden method.
          - Eg, paintComponent.
    - Overloading
      - Defining methods which differ in number or types of parameters.
    - Wrapper classes
      - Eg, Integer, Float, Character, ...
      - "Wrap" a primitive value.
      - Provide a home to utility functions.
      - Create immutable objects.
      - Java 5 autoboxing - automatic conversion to/from primitive/wrapper.