Please enable JavaScript.

Coggle requires JavaScript to display documents.

Level 1 - Coggle Diagram

- - - - Note: Java is case-sensitive: "MyClass" and "myclass" has different meaning.
        
        The name of the java file must match the class name. When saving the file, save it using the class name and add ".java" to the end of the filename.
  - - - final int myNum = 15;
        myNum = 20; // will generate an error: cannot assign a value to a final variable
  - - - A primitive data type specifies the size and type of variable values, and it has no additional methods.
        
        Byte
        
        The byte data type can store whole numbers from -128 to 127. This can be used instead of int or other integer types to save memory when you are certain that the value will be within -128 and 127:
        
        Short
        
        The short data type can store whole numbers from -32768 to 32767:
        
        Int
        
        The int data type can store whole numbers from -2147483648 to 2147483647. In general, and in our tutorial, the int data type is the preferred data type when we create variables with a numeric value.
        
        Long
        
        The long data type can store whole numbers from -9223372036854775808 to 9223372036854775807. This is used when int is not large enough to store the value. Note that you should end the value with an "L":
        
        Float
        
        The float data type can store fractional numbers from 3.4e−038 to 3.4e+038. Note that you should end the value with an "f":
        
        Float or double?
        
        The precision of a floating point value indicates how many digits the value can have after the decimal point. The precision of float is only six or seven decimal digits, while double variables have a precision of about 15 digits. Therefore it is safer to use double for most calculations.
        
        Double
        
        The double data type can store fractional numbers from 1.7e−308 to 1.7e+308. Note that you should end the value with a "d":
        
        Booleans
        
        A boolean data type is declared with the boolean keyword and can only take the values true or false:
        
        Characters
        
        The char data type is used to store a single character. The character must be surrounded by single quotes, like 'A' or 'c':
        
        Alternatively, you can use ASCII values to display certain characters:
    - - String
        
        The String data type is used to store a sequence of characters (text). String values must be surrounded by double quotes:
        
        A String in Java is actually a non-primitive data type, because it refers to an object. The String object has methods that are used to perform certain operations on strings.
      - Non-primitive data types are called reference types because they refer to objects.
        
        The main difference between primitive and non-primitive data types are:
        
        Primitive types are predefined (already defined) in Java. Non-primitive types are created by the programmer and is not defined by Java (except for String).
        
        Non-primitive types can be used to call methods to perform certain operations, while primitive types cannot.
        
        A primitive type has always a value, while non-primitive types can be null.
        
        A primitive type starts with a lowercase letter, while non-primitive types starts with an uppercase letter.
        
        The size of a primitive type depends on the data type, while non-primitive types have all the same size.
- - - - variable = (condition) ? expressionTrue : expressionFalse;
        
        String result = (time < 18) ? "Good day." : "Good evening.";
  - - - for (type variableName : arrayName)
  - - - A method must be declared within a class. It is defined with the name of the method, followed by parentheses ().
- - - - When a parameter is passed to the method, it is called an argument. So, from the example above: fname is a parameter, while Liam, Jenny and Anja are arguments.
        
        You can have as many parameters as you like:
        
        static void myMethod(String fname, int age) {
        
        Note that when you are working with multiple parameters, the method call must have the same number of arguments as there are parameters, and the arguments must be passed in the same order.
    - - The void keyword, used in the examples above, indicates that the method should not return a value. If you want the method to return a value, you can use a primitive data type (such as int, char, etc.) instead of void, and use the return keyword inside the method:
        
        static int myMethod(int x) {
        return 5 + x;
        }
  - - - int myMethod(int x)
        float myMethod(float x)
        double myMethod(double x, double y)
    - - Multiple methods can have the same name as long as the number and/or type of parameters are different.
  - - - Recursion Example
        
        public class Main {
        public static void main(String[] args) {
        int result = sum(10);
        System.out.println(result);
        }
        public static int sum(int k) {
        if (k > 0) {
        return k + sum(k - 1);
        } else {
        return 0;
        }
        }
        }
        
        Example Explained
        
        When the sum() function is called, it adds parameter k to the sum of all numbers smaller than k and returns the result. When k becomes 0, the function just returns 0. When running, the program follows these steps:
        
        10 + sum(9)
        10 + ( 9 + sum(8) )
        10 + ( 9 + ( 8 + sum(7) ) )
        ...
        10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + sum(0)
        10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + 0
        
        Since the function does not call itself when k is 0, the program stops there and returns the result.
        
        Halting Condition
        
        Just as loops can run into the problem of infinite looping, recursive functions can run into the problem of infinite recursion. Infinite recursion is when the function never stops calling itself. Every recursive function should have a halting condition, which is the condition where the function stops calling itself. In the previous example, the halting condition is when the parameter k becomes 0.
        
        The developer should be very careful with recursion as it can be quite easy to slip into writing a function which never terminates, or one that uses excess amounts of memory or processor power. However, when written correctly recursion can be a very efficient and mathematically-elegant approach to programming.
        
        It is helpful to see a variety of different examples to better understand the concept. In this example, the function adds a range of numbers between a start and an end. The halting condition for this recursive function is when end is not greater than start:
        
        public class Main {
        public static void main(String[] args) {
        int result = sum(5, 10);
        System.out.println(result);
        }
        public static int sum(int start, int end) {
        if (end > start) {
        return end + sum(start, end - 1);
        } else {
        return end;
        }
        }
        }
- - - - byte -> short -> char -> int -> long -> float -> double
    - - double -> float -> long -> int -> char -> short -> byte
        
        double myDouble = 9.78d; int myInt = (int) myDouble; // Manual casting: double to int
  - - - Because strings must be written within quotes, Java will misunderstand this string, and generate an error:
        
        The solution to avoid this problem, is to use the backslash escape character.
        
        The backslash () escape character turns special characters into string characters:
        
        String txt = "We are the so-called \"Vikings\" from the north.";