Please enable JavaScript.

Coggle requires JavaScript to display documents.

Level 2 - Coggle Diagram

- - - - Static method means that it can be accessed without creating an object of the class, unlike public, which can only be accessed by objects
        
        myStaticMethod(); // Call the static method
        
        Main myObj = new Main(); // Create an object of Main myObj.myPublicMethod(); // Call the public method on the object
  - - - // Create a Main class
        public class Main {
        int x; // Create a class attribute
        // Create a class constructor for the Main class
        public Main() {
        x = 5; // Set the initial value for the class attribute x
        }
      - Note that the constructor name must match the class name, and it cannot have a return type (like void).
        
        Also note that the constructor is called when the object is created.
        
        All classes have constructors by default: if you do not create a class constructor yourself, Java creates one for you. However, then you are not able to set initial values for object attributes.
      - Constructor Parameters
        
        Constructors can also take parameters, which is used to initialize attributes.
        
        public class Main {
        int modelYear;
        String modelName;
        public Main(int year, String name) {
        modelYear = year;
        modelName = name;
        }
        public static void main(String[] args) {
        Main myCar = new Main(1969, "Mustang");
        System.out.println(myCar.modelYear + " " + myCar.modelName);
        }
        }
        // Outputs 1969 Mustang
  - - - For classes, you can use either public or default:
        
        public
        
        The class is accessible by any other class
        
        default
        
        The class is only accessible by classes in the same package. This is used when you don't specify a modifier. You will learn more about packages in the Packages chapter
      - For attributes, methods and constructors, you can use the one of the following:
        
        public
        
        The code is accessible for all classes
        
        private
        
        The code is only accessible within the declared class
        
        default
        
        The code is only accessible in the same package. This is used when you don't specify a modifier. You will learn more about packages in the Packages chapter
        
        protected
        
        The code is accessible in the same package and subclasses. You will learn more about subclasses and superclasses in the Inheritance chapter
    - - For classes, you can use either final or abstract:
        
        final
        
        The class cannot be inherited by other classes (You will learn more about inheritance in the Inheritance chapter)
        
        abstract
        
        The class cannot be used to create objects (To access an abstract class, it must be inherited from another class. You will learn more about inheritance and abstraction in the Inheritance and Abstraction chapters)
      - For attributes and methods, you can use the one of the following:
        
        final
        
        Attributes and methods cannot be overridden/modified
        
        static
        
        Attributes and methods belongs to the class, rather than an object
        
        abstract
        
        Can only be used in an abstract class, and can only be used on methods. The method does not have a body, for example abstract void run();. The body is provided by the subclass (inherited from).
        
        transient
        
        Attributes and methods are skipped when serializing the object containing them
        
        synchronized
        
        Methods can only be accessed by one thread at a time
        
        volatile
        
        The value of an attribute is not cached thread-locally, and is always read from the "main memory"
- - - - The meaning of Encapsulation, is to make sure that "sensitive" data is hidden from users. To achieve this, you must:
        
        declare class variables/attributes as private
        
        provide public get and set methods to access and update the value of a private variable
        
        You learned from the previous chapter that private variables can only be accessed within the same class (an outside class has no access to it). However, it is possible to access them if we provide public get and set methods.
        
        The get method returns the variable value, and the set method sets the value.
        
        Syntax for both is that they start with either get or set, followed by the name of the variable, with the first letter in upper case:
        
        public class Person {
        private String name; // private = restricted access
        // Getter
        public String getName() {
        return name;
        }
        // Setter
        public void setName(String newName) {
        this.name = newName;
        }
        }
        
        3 more items...
        
        Why Encapsulation?
        
        Better control of class attributes and methods
        
        Class attributes can be made read-only (if you only use the get method), or write-only (if you only use the set method)
        
        Flexible: the programmer can change one part of the code without affecting other parts
        
        Increased security of data
  - - - Built-in Packages (packages from the Java API)
        
        The Java API is a library of prewritten classes, that are free to use, included in the Java Development Environment.
        
        The library contains components for managing input, database programming, and much much more. The complete list can be found at Oracles website: https://docs.oracle.com/javase/8/docs/api/.
        
        The library is divided into packages and classes. Meaning you can either import a single class (along with its methods and attributes), or a whole package that contain all the classes that belong to the specified package.
        
        To use a class or a package from the library, you need to use the import keyword:
        
        import package.name.Class; // Import a single class
        import package.name.*; // Import the whole package
        
        2 more items...
      - User-defined Packages (create your own packages)
        
        To create your own package, you need to understand that Java uses a file system directory to store them. Just like folders on your computer:
        
        └── root
        └── mypack
        └── MyPackageClass.java
        
        To create a package, use the package keyword:
        
        package mypack;
        class MyPackageClass {
        public static void main(String[] args) {
        System.out.println("This is my package!");
        }
        }
        
        Save the file as MyPackageClass.java, and compile it:
        
        Then compile the package:
  - - - subclass (child) - the class that inherits from another class
      - superclass (parent) - the class being inherited from
      - To inherit from a class, use the extends keyword.
        
        class Vehicle {
        ...
        }
        class Car extends Vehicle {
        ...
        }
        
        If you don't want other classes to inherit from a class, use the final keyword:
        
        final class Vehicle {
        }
    - - It is useful for code reusability: reuse attributes and methods of an existing class when you create a new class.
- - - - Like we specified in the previous chapter; Inheritance lets us inherit attributes and methods from another class. Polymorphism uses those methods to perform different tasks. This allows us to perform a single action in different ways.
        
        For example, think of a superclass called Animal that has a method called animalSound(). Subclasses of Animals could be Pigs, Cats, Dogs, Birds - And they also have their own implementation of an animal sound (the pig oinks, and the cat meows, etc.):
        
        class Animal {
        public void animalSound() {
        System.out.println("The animal makes a sound");
        }
        }
        class Pig extends Animal {
        public void animalSound() {
        System.out.println("The pig says: wee wee");
        }
        }
        class Dog extends Animal {
        public void animalSound() {
        System.out.println("The dog says: bow wow");
        }
        }
        class Main {
        public static void main(String[] args) {
        Animal myAnimal = new Animal(); // Create a Animal object
        Animal myPig = new Pig(); // Create a Pig object
        Animal myDog = new Dog(); // Create a Dog object
        myAnimal.animalSound();
        myPig.animalSound();
        myDog.animalSound();
        }
        }
  - - - To access the inner class, create an object of the outer class, and then create an object of the inner class:
        
        class OuterClass {
        int x = 10;
        class InnerClass {
        int y = 5;
        }
        }
        public class Main {
        public static void main(String[] args) {
        OuterClass myOuter = new OuterClass();
        OuterClass.InnerClass myInner = myOuter.new InnerClass();
        System.out.println(myInner.y + myOuter.x);
        }
        }
        // Outputs 15 (5 + 10)
    - - Unlike a "regular" class, an inner class can be private or protected. If you don't want outside objects to access the inner class, declare the class as private:
    - - An inner class can also be static, which means that you can access it without creating an object of the outer class:
        
        class OuterClass {
        int x = 10;
        static class InnerClass {
        int y = 5;
        }
        }
        public class Main {
        public static void main(String[] args) {
        OuterClass.InnerClass myInner = new OuterClass.InnerClass();
        System.out.println(myInner.y);
        }
        }
        // Outputs 5
        
        Note: just like static attributes and methods, a static inner class does not have access to members of the outer class.
    - - One advantage of inner classes, is that they can access attributes and methods of the outer class:
        
        class OuterClass {
        int x = 10;
        class InnerClass {
        public int myInnerMethod() {
        return x;
        }
        }
        }
        public class Main {
        public static void main(String[] args) {
        OuterClass myOuter = new OuterClass();
        OuterClass.InnerClass myInner = myOuter.new InnerClass();
        System.out.println(myInner.myInnerMethod());
        }
        }
        // Outputs 10
- - - - Object-oriented programming has several advantages over procedural programming:
        
        OOP provides a clear structure for the programs
        
        OOP is faster and easier to execute
        
        OOP helps to keep the Java code DRY "Don't Repeat Yourself", and makes the code easier to maintain, modify and debug
        
        OOP makes it possible to create full reusable applications with less code and shorter development time
    - - a class is a template for objects, and an object is an instance of a class.
        
        When the individual objects are created, they inherit all the variables and methods from the class.
        
        Car - class, Volvo - object
        
        A Class is like an object constructor, or a "blueprint" for creating objects.
        
        To create an object of Class, specify the class name, followed by the object name, and use the keyword new:
        
        Main myObj = new Main();
        
        You can also create an object of a class and access it in another class. This is often used for better organization of classes (one class has all the attributes and methods, while the other class holds the main() method (code to be executed)).
      - Java Class Attributes
        
        In the previous chapter, we used the term "variable" for x in the example (as shown below). It is actually an attribute of the class. Or you could say that class attributes are variables within a class:
        
        Another term for class attributes is fields.
        
        Accessing Attributes
        
        You can access attributes by creating an object of the class, and by using the dot syntax (.):
        
        The following example will create an object of the Main class, with the name myObj. We use the x attribute on the object to print its value:
        
        public class Main {
        int x = 5;
        public static void main(String[] args) {
        Main myObj = new Main();
        System.out.println(myObj.x);
        }
        }
        
        1 more item...