DEV Community: SATHISH BALAJI

React DOM

SATHISH BALAJI — Fri, 13 Jun 2025 10:21:10 +0000

1. Library vs Framework?

2. What is React DOM?

ReactDom is a core react package that provides methods to interact with the Document Object Model or DOM. This package allows developers to access and modify the DOM.

3. NPM vs NPX?

NPM: It is a package manager, you can install node.js packages using NPM

NPX: It is a tool to execute node.js packages.

It doesn't matter whether you installed that package globally or locally. NPX will temporarily install it and run it. NPM also can run packages if you configure a package.json file and include it in the script section.

4. SPA vs MPA?

SPA: Single-Page application refers to a type of application that entirely runs within the web browser and does not require the entire page to be reloaded during use. The goal is faster transitions that make the website feel more like a native mobile app.

MPA: Multi-Page application is a web application that loads a new page for each action that the user takes. A multi-page app consists of multiple static pages that load a new page for the server and then update the content of that page as needed.

5. JS vs JSX?

Reference:
https://www.geeksforgeeks.org/reactjs/reactjs-reactdom/
https://stackoverflow.com/questions/50605219/difference-between-npx-and-npm
https://www.spaceotechnologies.com/blog/single-page-application-vs-multi-page-application/
https://www.geeksforgeeks.org/reactjs/what-is-the-difference-between-a-js-and-jsx-file-in-react/
https://www.geeksforgeeks.org/software-engineering/software-framework-vs-library/

Scanner

SATHISH BALAJI — Thu, 20 Feb 2025 08:59:11 +0000

The Scanner class is used to get user input, and it is found in the java.util package.

To use the Scanner class, create an object of the class and use any of the available methods found in the Scanner class documentation.
In our example, we will use the nextLine() method, which is used to read Strings:

import java.util.Scanner;  // Import the Scanner class

class Main {
  public static void main(String[] args) {
    Scanner myObj = new Scanner(System.in);  // Create a Scanner object
    System.out.println("Enter username");

    String userName = myObj.nextLine();  // Read user input
    System.out.println("Username is: " + userName);  // Output user input
  }
}

Input Types

Reference
https://www.w3schools.com/java/java_user_input.asp

While Loop

SATHISH BALAJI — Wed, 29 Jan 2025 16:27:53 +0000

Java while loop

The while loop is also used to iterate over the number of statements multiple times. However, if we don't know the number of iterations in advance, it is recommended to use a while loop. Unlike for loop, the initialization and increment/decrement doesn't take place inside the loop statement in while loop.

It is also known as the entry-controlled loop since the condition is checked at the start of the loop. If the condition is true, then the loop body will be executed; otherwise, the statements after the loop will be executed.

Calculation .java

    public class Calculation {    
    public static void main(String[] args) {    
    // TODO Auto-generated method stub    
    int i = 0;    
    System.out.println("Printing the list of first 10 even numbers \n");    
    while(i<=10) {    
    System.out.println(i);    
    i = i + 2;    
    }    
    }    
    }

Output:

Printing the list of first 10 even numbers 

0
2
4
6
8
10

System.out.println()

SATHISH BALAJI — Tue, 07 Jan 2025 15:05:12 +0000

What is System.out.println
System.out.println is a Java statement that prints the argument passed, into the System.out which is generally stdout.

System – is a final class in java.lang package. As per javadoc, “…Among the facilities provided by the System class are standard input, standard output, and error output streams.[TBD]
out – is a static member field of System class and is of type PrintStream.
println – is a method of PrintStream class. println prints the argument passed to the standard console and a newline. There are multiple println methods with different arguments (overloading). Every println makes a call to print method and adds a newline.

Reference
https://javapapers.com/core-java/system-out-println/

Constructor

SATHISH BALAJI — Sun, 05 Jan 2025 12:31:26 +0000

1) What is a Constructor?
---> In Java, a constructor is a block of codes similar to the method. It is called when an instance of the class is created. At the time of calling constructor, memory for the object is allocated in the memory.
---> It is a special type of method which is used to initialize the object.
---> Every time an object is created using the new keyword, at least one constructor is called.
---> It calls a default constructor if there is no constructor available in the class. In such case, Java compiler provides a default constructor by default.

There are following rules for defining a constructor:

Constructor name must be the same as its class name.
A Constructor must have no explicit return type.
A Java constructor cannot be abstract, static, final, and synchronized.[TBD]

2) Types of Constructors
There are three types of constructors in Java:

Default Constructor
Parameterized Constructor
Copy Constructor

1. Default Constructor in Java

A constructor that has no parameters is known as default constructor. A default constructor is invisible. And if we write a constructor with no arguments, the compiler does not create a default constructor. It is taken out. It is being overloaded and called a parameterized constructor. The default constructor changed into the parameterized constructor. But Parameterized constructor can’t change the default constructor. The default constructor can be implicit or explicit.

Implicit Default Constructor: If no constructor is defined in a class, the Java compiler automatically provides a default constructor. This constructor doesn’t take any parameters and initializes the object with default values, such as 0 for numbers, null for objects.

Explicit Default Constructor: If we define a constructor that takes no parameters, it’s called an explicit default constructor. This constructor replaces the one the compiler would normally create automatically. Once you define any constructor (with or without parameters), the compiler no longer provides the default constructor for you.

2. Parameterized Constructor in Java
A constructor that has parameters is known as parameterized constructor. If we want to initialize fields of the class with our own values, then use a parameterized constructor.

3. Copy Constructor in Java [TBD]
Unlike other constructors copy constructor is passed with another object which copies the data available from the passed object to the newly created object.

3) What is Constructor Overloading?
The constructor overloading can be defined as the concept of having more than one constructor with different parameters so that every constructor can perform a different task.
Java supports Constructor Overloading in addition to overloading methods. In Java, overloaded constructor is called based on the parameters specified when a new is executed. Sometimes there is a need of initializing an object in different ways. This can be done using constructor overloading.

4) What is the use of "this" keyword?
The "this" keyword refers to the current object in a method or constructor.

The most common use of the "this" keyword is to eliminate the confusion between class attributes and parameters with the same name (because a class attribute is shadowed by a method or constructor parameter).

"this" can also be used to:

Invoke current class constructor
Invoke current class method
Return the current class object
Pass an argument in the method call
Pass an argument in the constructor call

Reference
https://www.javatpoint.com/java-constructor
https://www.geeksforgeeks.org/constructors-in-java/
https://www.javatpoint.com/constructor-overloading-in-java
https://www.geeksforgeeks.org/constructor-overloading-java/
https://www.w3schools.com/java/ref_keyword_this.asp

Tasks

SATHISH BALAJI — Sat, 28 Dec 2024 17:01:35 +0000

Task 1

Create a class called 'Jewellery'
Create below static variables: static int goldPrice = 7100; static int silverPrice = 150; 2.1. Create below non-static variables int making_charges, wastage;
Create main method.
Inside main method, create instance as below Jewellery jewel1 = new Jewellery(); Jewellery jewel2 = new Jewellery();
Using jewel1, assign making_charges and wastage.
Using jewel2, assign making_charges and wastage.
Call a non-static method as below. jewel1.bill(); jewel2.bill();
Save, Compile and fix the error.
Inside bill() method, print making_charges and wastage.

public class Jewellery
{
static int goldPrice = 7100; 
static int silverPrice = 150;
int making_charge;
int wastage;
public static void main (String[] args)
{
Jewellery jewel1 = new Jewellery(); 
Jewellery jewel2 = new Jewellery(); 
jewel1.making_charge = 2000;
jewel1.wastage = 1000;
jewel2.making_charge = 1000;
jewel2.wastage = 500;
jewel1.bill1();
jewel2.bill2(); 
} 
public void bill1()
{
System.out.println("Jewel 1 Bill: "+"\n"+"Gold Price = " +goldPrice+"\n"+"Making Charge = " +making_charge+"\n"+"Wastage = " +wastage+"\n"+"Total = " +(goldPrice+making_charge+wastage));
}
public void bill2()
{
System.out.println("Jewel 2 Bill: "+"\n"+"Silver Price = " +silverPrice+"\n"+"Making Charge = " +making_charge+"\n"+"Wastage = " +wastage+"\n"+"Total = " +(silverPrice+making_charge+wastage));
}
}

Output

Jewel 1 Bill: 
Gold Price = 7100
Making Charge = 2000
Wastage = 1000
Total = 10100
Jewel 2 Bill: 
Silver Price = 150
Making Charge = 1000
Wastage = 500
Total = 1650

Task 2

Create a class called 'Shop'
Create below static variables: static int doorNo = 5; static int discount = 10; 2.1. Create below non-static variables int price, weight;
Create main method.
Inside main method, create instance as below Shop product1 = new Shop(); Shop product2 = new Shop();
Using product1, assign price and weight.
Using product2, assign price and weight.
Call a non-static method as below. product1.bill(); product2.bill();
Save, Compile and fix the error.
Inside bill() method, print price and weight.
Inside main method and inside bill() method, print doorNo and discount

public class Shop
{
static int doorNo = 5; 
static int discount = 10;
int price;
int weight;
public static void main (String[] args)
{
Shop product1 = new Shop();
Shop product2 = new Shop();
product1.price = 1000;
product2.price = 2000;
product1.weight = 10;
product2.weight = 20;
System.out.println("Door No: "+doorNo);
System.out.println("Discount: "+discount);
product1.bill1();
product2.bill2();
} 
public void bill1()
{
System.out.println("Product 1"+"\n"+"Price = "+price+"\n"+"Weight = "+weight);
}
public void bill2()
{
System.out.println("Product 2"+"\n"+"Price = "+price+"\n"+"Weight = "+weight);
}
}

Output

Door No: 5
Discount: 10
Product 1
Price = 1000
Weight = 10
Product 2
Price = 2000
Weight = 20

Variables

SATHISH BALAJI — Sat, 28 Dec 2024 16:55:55 +0000

Variables are the containers for storing the data values or you can also call it a memory location name for the data. Every variable has a:

Data Type – The kind of data that it can hold. For example, int, string, float, char, etc.
Variable Name – To identify the variable uniquely within the scope.
Value – The data assigned to the variable.

Types of Java Variables
There are three types of variables in Java. They are:

Local Variables
Instance Variables
Static Variables

1. Local Variables
A variable defined within a block or method or constructor is called a local variable.
i) The Local variable is created at the time of declaration and destroyed after exiting from the block or when the call returns from the function.
ii) The scope of these variables exists only within the block in which the variables are declared, i.e., we can access these variables only within that block.
iii) Initialization of the local variable is mandatory before using it in the defined scope.

2. Instance Variables (Non-Static)
Instance variables are non-static variables and are declared in a class outside of any method, constructor, or block.

i) As instance variables are declared in a class, these variables are created when an object of the class is created and destroyed when the object is destroyed.
ii) Unlike local variables, we may use access specifiers for instance variables. If we do not specify any access specifier, then the default access specifier will be used.
iii) Initialization of an instance variable is not mandatory. Its default value is dependent on the data type of variable. For String it is null, for float it is 0.0f, for int it is 0, for Wrapper classes like Integer it is null, etc.
iv) Instance variables can be accessed only by creating objects.

3. Static Variables
Static variables are also known as class variables.

i) These variables are declared similarly to instance variables. The difference is that static variables are declared using the static keyword within a class outside of any method, constructor, or block.
ii) Unlike instance variables, we can only have one copy of a static variable per class, irrespective of how many objects we create.
iii) Static variables are created at the start of program execution and destroyed automatically when execution ends.
iv) Static variables cannot be declared locally inside an instance method.

Reference: https://www.geeksforgeeks.org/variables-in-java/

Datatypes

SATHISH BALAJI — Fri, 27 Dec 2024 12:46:20 +0000

Java is statically typed and also a strongly typed language because, in Java, each type of data (such as integer, character, hexadecimal, packed decimal, and so forth) is predefined as part of the programming language and all constants or variables defined for a given program must be described with one of the Java data types. Data types in Java are of different sizes and values that can be stored in the variable that is made as per convenience and circumstances to cover up all test cases.

Java has two categories in which data types are segregated:
1. Primitive Data Types in Java
Primitive data are only single values and have no special capabilities. There are 8 primitive data types.

2. Non-Primitive (Reference) Data Types
The Non-Primitive (Reference) Data Types will contain a memory address of variable values because the reference types won’t store the variable value directly in memory. They are strings, objects, arrays, etc.

i) Strings[TBD]
Strings are defined as an array of characters. The difference between a character array and a string in Java is, that the string is designed to hold a sequence of characters in a single variable whereas, a character array is a collection of separate char-type entities. Unlike C/C++, Java strings are not terminated with a null character.

ii) Class
A Class is a user-defined blueprint or prototype from which objects are created. It represents the set of properties or methods that are common to all objects of one type.

iii) Object
An Object is a basic unit of Object-Oriented Programming and represents real-life entities. A typical Java program creates many objects, which as you know, interact by invoking methods.

iv) Interface[TBD]
Like a class, an interface can have methods and variables, but the methods declared in an interface are by default abstract (only method signature, no body).

v) Array[TBD]
An Array is a group of like-typed variables that are referred to by a common name. Arrays in Java work differently than they do in C/C++.

Reference: https://www.geeksforgeeks.org/data-types-in-java/

Objects

SATHISH BALAJI — Fri, 27 Dec 2024 12:28:54 +0000

1. Object
An object in Java is a basic unit of Object-Oriented Programming and represents real-life entities. Objects are the instances of a class that are created to use the attributes and methods of a class. A typical Java program creates many objects, which as you know, interact by invoking methods. An object consists of :

i) State : It is represented by attributes of an object. It also reflects the properties of an object.
Eg: what the objects have, Student have a first name, last name, age, etc.
ii) Behavior : It is represented by the methods of an object. It also reflects the response of an object with other objects.
Eg: what the objects do, Student attend a course "Java for beginners".
iii) Identity : It gives a unique name to an object and enables one object to interact with other objects.
Eg: what makes them unique, Student have Student-ID-number, or an email which is unique.

2. State
State is basically of two types:
i) Statically Typed Programming Language
ii) Dynamically Typed Programming Language

3. Statically Typed Programming Language
In statically typed programming languages, type checking occurs at compile time. At compile time, source code in a specific programming language is converted to a machine-readable format. This means that before source code is compiled, the type associated with each and every single variable must be known. Some common examples of programming languages that belong to this category are Java, Haskell, C, C++, C#, Scala, Kotlin, Fortran, Go, Pascal, and Swift.

4. Dynamically Typed Programming Language
In dynamically typed languages, type checking takes place at runtime or execution time. This means that variables are checked against types only when the program is executing. Some examples of programming languages that belong to this category are Python, JavaScript, Lisp, PHP, Ruby, Perl, Lua, and Tcl.

References

Create Class and Object

SATHISH BALAJI — Thu, 26 Dec 2024 14:49:38 +0000

1. How Object is created in Java?
The object is a basic building block of an OOPs language. In Java, we cannot execute any program without creating an object.
Java provides five ways to create an object.

 -Using new Keyword
 -Using clone() method
 -Using newInstance() method of the Class class
 -Using newInstance() method of the Constructor class
 -Using Deserialization

i) Using new Keyword
Using the new keyword is the most popular way to create an object or instance of the class. When we create an instance of the class by using the new keyword, it allocates memory (heap) for the newly created object and also returns the reference of that object to that memory. The new keyword is also used to create an array.

ii) Using clone() Method[TBD]
The clone() method is the method of Object class. It creates a copy of an object and returns the same copy. The JVM creates a new object when the clone() method is invoked. It copies all the content of the previously created object into new one object. Note that it does not call any constructor.

iii) Using newInstance() Method of Class class[TBD]
The newInstance() method of the Class class is also used to create an object. It calls the default constructor to create the object. It returns a newly created instance of the class represented by the object. It internally uses the newInstance() method of the Constructor class.

iv) Using newInstance() Method of Constructor class[TBD]
t is similar to the newInstance() method of the Class class. It is known as a reflective way to create objects. The method is defined in the Constructor class which is the class of java.lang.reflect package. We can also call the parameterized constructor and private constructor by using the newInstance() method.

v) Using Deserialization[TBD]
In Java, serialization is the process of converting an object into a sequence of byte-stream. The reverse process (byte-stream to object) of serialization is called deserialization. The JVM creates a new object when we serialize or deserialize an object. It does not use constructor to create an object. While using deserialization, the Serializable interface (marker interface) must be implemented in the class.

Reference: https://www.javatpoint.com/how-to-create-object-in-java

2. How method is called in Java?
In Java, a method is a block of code that performs a specific function and runs only when it is called. Methods are also commonly known as functions. Each method has its name. You can pass data into a method via parameters. A method also has a return type defining the type of data it returns. According to the convention, the name of the method should be written in lowerCamelCase where the first letter should be small. Furthermore, a method should have a proper name, preferably a verb referring to what it does.

Reference:https://codegym.cc/groups/posts/how-to-call-a-method-in-java-

3. How method is defined in Java?

Day - 1 of Java

SATHISH BALAJI — Mon, 23 Dec 2024 16:51:53 +0000

What is sudo?
Sudo (Super User do) is a linux command that is used to temporarily execute programs as another user. It is the same as what we use in windows "run as administrator".
Reference: https://documentation.suse.com/smart/systems-management/html/sudo-run-commands-as-superuser/index.html
What is APT?
APT (Advanced Package Tool) is a collection of tools used to install, update, remove, and manage software packages on Debian and its derivative operating systems, including Ubuntu and Linux Mint.
Reference: https://www.digitalocean.com/community/tutorials/what-is-apt
What is JDK?
JDK (Java Development Kit) is a distribution of Java technology by Oracle Corporation. It is derivative of the community driven OpenJDK which Oracle stewards. It provides software for working with Java applications.
Reference: https://en.wikipedia.org/wiki/Java_Development_Kit
What happens behind the screen, after we enter Java C?
The "javac" command reads human-readable code (source files) that contain module, package and type declarations written in the Java programming language, and compiles them into bytecode (class files) that run on the Java Virtual Machine.
Reference: https://docs.oracle.com/en/java/javase/17/docs/specs/man/javac.html