core java interview questions

Can we Override static methods in java? - NO
If a derived class defines a static method with same signature as a static method in base class, the method in the derived class hides the method in the base class

Can we overload static methods? - Yes
We can have two ore more static methods with same name, but differences in input parameters.

what is factory design pattern?
Pattern provides one of the best ways to create an object - We create object without exposing the creation logic to the client and refer to newly created object using a common interface.

https://www.tutorialspoint.com/design_pattern/factory_pattern.htm

how you initialize Page factory object
https://www.seleniumeasy.com/selenium-tutorials/page-factory-pattern-in-selenium-webdriver

what is POM design pattern?
https://www.guru99.com/page-object-model-pom-page-factory-in-selenium-ultimate-guide.html


is java pure object oriented?  - NO
- because it supports primitive data type [Non Object types] like byte,short,int,long,float,double,char,boolean,which are not objects.
- evrything in java is class, except primitive datatypes.still wrapper classess are there..for this reason we can say java is not fully object oriented language
-The main difference between primitive and reference type is that primitive type always has a value, it can never be null but reference type can be null, which denotes the absence of value
-the main difference between two types is that primitive types store actual values but reference type stores handle to object in the heap
-modification on one primitive variable doesn't affect the copy but it does in the case of the reference variable

int i = 20; int j = i; j++; // will not affect i, j will be 21 but i will still be 20
List<String> list = new ArrayList(2);
List<String> copy = list;
copy.add("EUR");
// adding a new element into list, it would be visible to both list and copy
System.out.printf("value of list and copy after modification list: %s, copy: %s %n", list, copy);




staic class :
Static classes are basically a way of grouping classes together in Java. Java doesn't allow you to create top-level static classes; only nested (inner) static classes.
 public class CarParts {
 
    public static class Wheel {
        public Wheel() {
            System.out.println("Wheel created!");
        }
    }

    public CarParts() {
        System.out.println("Car Parts object created!");
    }
}

wrapper class:
Each Java primitive has a corresponding wrapper:
boolean, byte, short, char, int, long, float, double
Boolean, Byte, Short, Character, Integer, Long, Float, Double
These are all defined in the java.lang package, hence we don't need to import them manually.

Basically, generic classes (Collection Framework)only work with objects and don't support primitives. As a result, if we want to work with them, we have to convert primitive values into wrapper objects.

heap memory vs stack memory:
stack memory is used to store local variables and function call
heap memory is used to store objects in Java
Each Thread in Java has their own stack which can be specified using
If there is no memory left in the stack for storing function call or local variable, JVM will throw java.lang.StackOverFlowError, while if there is no more heap space for creating an object, JVM will throw java.lang.OutOfMemoryError:
If you are using Recursion, on which method calls itself, You can quickly fill up stack memory. Another difference between stack and heap is that size of stack memory is a lot lesser than the size of  heap memory in Java.
ariables stored in stacks are only visible to the owner Thread while objects created in the heap are visible to all thread. In other words, stack memory is kind of private memory of Java Threads while heap memory is shared among all threads.

== vs equals
We can use == operators for reference comparison (address comparison) and .equals() method for content comparison. In simple words, == checks if both objects point to the same memory location whereas .equals() evaluates to the comparison of values in the objects.
String s1 = new String("HELLO");
String s2 = new String("HELLO");
System.out.println(s1 == s2); //false
System.out.println(s1.equals(s2)); //True