Java Basics and Core

After one month of break and returning from holiday it is time to start writing again. As a returning topic, I chose Java basics and core features, since it is easy to forget simple things after a long period of time and there is a huge four weeks of doing not much about technical stuff, it would be good to start with a refreshing topic.

In order not to make it very tedious, I will not cover all the simple things. Also, I will make a brief list of gists with no-specific order of topics. Without further ado, let’s get started.

1. Java is a platform-independent language. (write once run anywhere)

2. JVM is an environment to run compiled java classes.

3. Java doesn’t support multiple inheritances.

4. Local variables are declared in blocks, instance variables(null by default) are defined in classes.

5. Local variables are not initialized to any default value while fields are initialized to the default value.

6. Field, member variable, instance variable implies the same thing. Class variables are the ones that declared static.

7. Declaring a variable is just deciding the type of it, defining is both declaration and initialization.

8. Local variables are stored in a stack along with function calls, while instantiated objects are stored in heap.

9. Variable stored in stack visible to owner Thread while object stored in heap visible to all threads.

10. Accessing stack memory is faster than accessing heap memory.

11. Reference for an object is stored in a stack whereas actual objects are stored in heap.

12. private classes are not accessed outside of the package.

13. Only methods and fields can be declared as protected. Fields and methods in interfaces are public by default.

14. final fields can’t be updated, final methods can’t be overridden, final classes can’t be inherited.

15. static(class) variables declared at the class level and all instances of the class will refer to the same variable. static methods can be accessed and executed before the creation of the object.

16. abstract keyword is used with methods and classes. Abstract classes can’t be instantiated and don’t have to have an abstract method in order to be abstract.

17. Interfaces can’t implement another interface but can inherit more than one interface with the extends keyword.

18. Classes can’t extend more than one class, but can implements more than one interface.

19. All methods in the interface have to be implemented in class. (not after Java 8, see default methods)

20. If there are no access modifiers for class, it will be package-private.

21. If there is no constructor, compile will provide the default constructor.

22. In order to call the constructor of the parent class super(), the constructor of the current class this() methods are used.

23. Whereas abstract classes can have default methods with implementation, interfaces can’t (A caveat: with Java 8 interfaces have default methods)

24. In java all variables passed by value. When it is a primitive it is passed by actual value, when it is an object it is passed by the value of reference for that object (but still passed by value? confusing right!).

    Copy 
    1public static void main(String[] args) {
    2    Person a = new Person("A");
    3    // name = A
    4    foo(a); 
    5    // name = A
    6    bar(a);
    7    // name = B
    8}
    9
    10static void foo(Person p) {
    11    p = new Person("B");
    12    p.setName("C");
    13}
    14
    15static void bar(Person p) {
    16    p.setName("C");
    17}

    Let’s say a is a reference in the memory denoted by 100. Firstly, we pass the value of the reference(100) to foo method. Local p variable is 100 in foo method. When we create a new Person object and set its value to local value p it changes to a value other than 100, so we no longer have a connection to actual object, therefore we can’t modify it. After returning from foo method and passing reference value of a(which is still 100), we again create a local copy of reference as p(100). When we set it to “C” in bar method, we are modifying object referenced by 100 which is our actual object.