Java – Interesting Bits – Static and Dynamic Checking…

String str = "Hello";  //statically typed as string
str = 5;               //would throw an error since java is statically typed

str = "Hello" # it is a string
str = 5       # now it is an integer; perfectly OK

str = 5 + "hello" 
# would throw an error since it does not want to cast one type to the other implicitly. 

$str = 5 + "hello"; // equals 5 because "hello" is implicitly casted to 0 
// PHP is weakly typed, thus is a very forgiving language.

Logic Structures in Algorithms

There are 3 main logic structures which form the building blocks for algorithms, sequence, selection and iteration.

• Sequence – the specific order in which instructions are performed.
• Selection – decision which allows for branching, a different action dependent upon a question/condition.
• Iteration – the process of repeating the steps / also referred to as a loop.

More info: http://www.bbc.co.uk/education/topics/z7d634j

Switch Statement

Each case of switch is supposed to be an integer or String since Java 7, a condition returns a boolean so that results in an incompatible type.   Consider the strings to be similar to labels, compared as if String.equals were being used.  Switch / case statements do not allow conditionals, but how about this beautiful and minimalist approach?  Worth looking into.

age > 79 ? first_case_method() 
          : age < 50 ? second_case_method() 
          : age < 40 ? third_case_method() 
          : age < 30 ? fourth_case_method() 
          : age < 20 ? fifth_case_method()
          : ... 
          : default_case_method();

Interfaces and Polymorphism

An interface is akin to an agreement/contract for a class, if a class implements an interface it is agreeing to implement all the methods specified in the interface definition.    Interfaces can contain abstract methods and fields, but typically contain no implementation code.  All methods in an interface need to be implemented in the class which implements the interface else the class will not compile. Interface fields are treated the same as static variables in the class.

Interfaces can extend multiple other interfaces, and inherits all fields and methods of the super interfaces, which could also be overridden in the base interface.   The class implementing the interface needs to implement all methods.

Since Java 8, provision has been made for default methods to alleviate the problem of developers adding to an API and existing classes no longer implementing all required methods.  A class can override the default implementation.  If a class implements multiple interfaces with matching default methods, complications arise.

Classes cannot extend multiple super classes owing to the Deadly Diamond of Death, however they can implement multiple interfaces.If a class implements multiple interfaces, there is a chance that method signatures may overlap (same name and parameters), which is not permitted in java.

Interfaces enable you to treat an object by the role it plays rather than by the class type from which it was instantiated. Once a class implements an interface you can use an instance of that class as an instance of that interface. Variables can be declared to be of the interface type.   If several objects implement an interface, then interface types can be used instead of class types in parameter declarations.  This provides flexibility.

Generally polymorphism is the provision of a single interface to different types.  It can be used at different levels, for example overloading methods so that they behave differently depending on the argument to which they are applied.  There can also be polymorphic data types, when a data type appears to be of a generalised type, specifically generics in Java.

Interfaces are a way to achieve polymorphism, it enables methods to be accessed by several classes, for example if you want one method to store various objects (from different class hierarchies) in a database, implement an interface called Storable.  When each class implements these methods, then they can be called to store the objects in a database without considering which particular type of object they are, all they need to be is Storable.

More info: http://tutorials.jenkov.com/java/interfaces.html

Equality

The equals method is defined in class Object, and since all objects in Java implicitly or explicitly inherit from this class, they too will inherit the equals() method as implemented by Object. The default implementation in Object will simply return true if the objects pass the “==” condition.

However, you are free to override the equals() method in your own class and specify the criteria which must be checked to see if two objects are meaningfully equal. For example, you might say that two instances are only equal if each of its attributes contain the same values as another object, or you might instead want to simply check a few attributes which make up the objects “business key” and ignore the others.

The equality of String classes follow the same rules as any other class in Java; “==” will be true if they do refer to the same instance, and equals() will be true if they contain the same values.

Nested Classes

Nested classes enable you to logically group classes that are only used in one place, increasing the use of encapsulation.  Nested classes include local classes (introduce a new named type), anonymous classes (don’t need to refer to it, e.g. inline ActionListeners for menus), lambda expression, inner class (similar to local class but more widely available and don’t need access to local context). Event handlers are a common use of inner classes. https://docs.oracle.com/javase/tutorial/java/javaOO/whentouse.html

InnerClass cannot have static members because it belongs to an instance (of OuterClass). If you declare InnerClass as static to detach it from the instance, your code will compile.

class OuterClass {
    static class InnerClass {
        static int i = 100; // no compile error
        static void f() { } // no compile error
    }
}

BTW: You’ll still be able to create instances of InnerClass.   static in this context allows that to happen without an enclosing instance of OuterClass.

You can use the same modifiers for inner classes that you use for other members of the outer class. For example, you can use the access specifiers private, public, and protected to restrict access to inner classes, just as you use them to restrict access do to other class members.  But you can’t use access modifiers when declaring a class within a method.

Primitives and Objects

Objects : defined in a class, instantiated, constructed and assigned to an identifier.  The have state, behaviour and identity.  They are stored on the heap.

Data types : Primitive types are special data types built into the language; they are not objects created from a class.  Primitives are stored on the stack.

Literal : A Literal is the source code representation of a fixed value; literals are represented directly in your code without requiring computation.  A literal can be a value of a primitive type [like 1, true, 't'or 1.2f], the String type [like "" or Something], or the null type [null].

boolean result = true;  // boolean - is data type
                        // true - is literal

Control Flow Structures

break terminates the loop (jumps to the code below it). continue terminates the rest of the processing of the code within the loop for the current iteration, but continues the loop.

int sum = 0;
for(int i = 1; i <= 100 ; i++){
    if(i % 2 == 0)
         continue;
    sum += i;
}

This would get the sum of only odd numbers from 1 to 100

More Info / Reading List

• https://www3.ntu.edu.sg/home/ehchua/programming/index.html#Java