Please enable JavaScript.

Coggle requires JavaScript to display documents.

Java OOP (Java (Classes - Object Blueprints, abstract entity in software…

- - - - Variables (State)
      - Behaviors (functions)
      - Name of Class
    - - Syntax is Capitalize: SoccerPlayer
      - Declare 1st: SoccerPlayer conor;
      - Construct (Create a place in Memory):
        conor = new SoccerPlayer();
      - member variables and methods
        
        Use . to access a specific instances methods or behaviors
    - - Overloading
        
        Multiple amounts of parameters for different behaviors
    - - Public
      - Private - only within this class
        
        no sublclasses
      - Protected
        
        subclasses can touch it
        
        also its own package
    - - refers to this class, not function like JS
    - - May or may not include abstract methods
      - cannot be instantiated, but can be subclassed
      - if a subclass doesn't acknowlege abstract methods, it must also be declared abstract
      - Can fill in methods and vars
  - - - Defining a real world object as a software class
    - - class Horse extends Animal {}
      - is a
      - Multiple inheritance
        
        java doesn't allow it
        
        Interfaces
        
        Classes can implement multiple interfaces
    - - Method Overloading (compile time - static binding) - Using different parameters, we can imply different behaviors and still have the same method be used.
      - Merthod Overriding (run time - dynamic bind) - If we want all animals in our animal army to bite, we can tell them all at once as they are all sub classes of animal, but each method is overloaded to do each unique bite without us having to acknowlege it.
    - - private vars
    - - Association - interacting but no ownership, a relationship between some amount of classes - Student.teacher
        
        Aggregation - has a - A team has a player, but if there's no team, the player is not gone. - weak association - players are added to the team, not created there
        
        Composition - death relationshipt - strong aggregation - part of - a house has many rooms, but if there's no rooms, its not a house. - strong association - rooms are created in the constructor, and cant be taken out. private
        
        Aggregation vs composition
        
        has a vs part of
        
        Aggregation - independent - players, team - deleteing team wont. delete players
        Composition - House Rooms - Deleting House, deletes rooms
  - - - Can be used as a type
        
        polymorphism baby
        
        multiple inheritance jazz
    - - implicitly abstract methods, no need to say abstract
      - all fields are automatically public, static, and final,
    - - also allows not to fuck up other interfaces
    - - all fields are automatically public, static, and final,
  - - - You want to share code among several closely related classes.
      - You expect that classes that extend your abstract class have many common methods or fields, or require access modifiers other than public (such as protected and private).
      - You want to declare non-static or non-final fields. This enables you to define methods that can access and modify the state of the object to which they belong.
    - - You expect that unrelated classes would implement your interface. For example, the interfaces Comparable and Cloneable are implemented by many unrelated classes.
      - You want to specify the behavior of a particular data type, but not concerned about who implements its behavior.
      - You want to take advantage of multiple inheritance of type.
- - - - Ease of design - able to think like a person not a computer
      - Ease of maintenance
      - Reusable