Java Program Keywords and structure explanation

1)How to create a project in eclipse?

step1) Launch the eclipse

step2)click on File menu-->new-->java project

step3)Enter a project name:JavaTraining

Step4)select your JRE

Step5)Click on Finish Button

Step6)Created Java ProjectName will be displayed under package explorer

(or) second way to create project

Step1) Click on file menu-->new-->project

step2)Type java in select wizard

Step3)Select Java Project under Java folder--->Click on Next button

 

Step4)Enter the project name: JavaTraining

Step5)select your JRE

Step6)Click on Finish Button

Step7)Created Java ProjectName will be displayed under package explorer

2)How to create a package in eclipse?

• A java package is a group of similar types of classes, interfaces and sub-packages.
• Package in java can be categorized in two form, built-in package and user-defined package.
• There are many built-in packages such as java, lang, awt, javax, swing, net, io, util, sql etc.
• Here, we will have the detailed learning of creating and using user-defined packages.

Advantage of Java Package :

1) Java package is used to categorize the classes and interfaces so that they can be easily maintained.

2) Java package provides access protection.

3) Java package removes naming collision.

Built in Packages:

How to access package from another package?

There are three ways to access the package from outside the package.

1. import package.*;
2. import package.classname;
3. fully qualified name.

step1)First create a java project 

Step2)Expand the project name under package explorer by clicking the arrow mark before projectname <projectname

Step3)Under project name there will be src and JRESystem Library folders

Step4)Select src folder-->right-click on src folder under project

step4)select new-->click on package

step5)provide the package name: basicprograms/anyname in small letters

step6)click on finish

step7)package is created successfully under src folder

NOTE: if you want to create new package under src folder, everytime you need to follow step4 to step6 

3)How to create a class in eclipse?

step1)select the package under src folder of the java project

step2)right click on the package name-->new-->class

step3)Enter the class name -HelloWorld

step 4)choose the main() checkbox

Step5)click on finish

Step6)Created class name will be shown under the package

First Java Program:

Java "Hello, World!" Program

// Your First Program

class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!"); 
    }
}

Output

Hello, World!

---

How Java "Hello, World!" Program Works?

1. // Your First Program
   
   In Java, any line starting with // is a comment. Comments are intended for users reading the code to understand the intent and functionality of the program. It is completely ignored by the Java compiler (an application that translates Java program to Java bytecode that computer can execute). To learn more, visit Java comments.
2. class HelloWorld { ... }
   
   In Java, every application begins with a class definition. In the program, HelloWorld is the name of the class, and the class definition is:

   class HelloWorld {
   ... .. ...
   }

   
   For now, just remember that every Java application has a class definition, and the name of the class should match the filename in Java.
3. public static void main(String[] args) { ... }
   
   This is the main method. Every application in Java must contain the main method. The Java compiler starts executing the code from the main method.
   

"Knowing a couple of principles can replace knowledge of many facts."

"Here’s the first principle."

"In the Java programming language, each command is written on its own line. A semicolon must be placed at the end of a command."

"Suppose we want to display 'Humans and robots are friends forever' on the screen three times. This is how it would look:"

"Imagine a room in an apartment. A room can’t exist on its own. It’s part of some apartment. An apartment also can’t exist on its own. It’s part of some building."

"On the other hand, we can say that the building is divided into apartments and an apartment is divided into rooms."

"Programs in Java consist of classes. There might be tens of thousands of classes. A minimal program is one class. For each class, a separate file is created. The name of the file matches the name of the class."

"Suppose you decide to create a class that describes a home. You’ll need to create a Home class that will be saved in the file Home.java."

"If you want to describe a cat in the program, then you’ll have to create a file Cat.java and declare the Cat class in it, etc."

"The files contain code (text) written in the Java programing language. Usually a class’s code consists of the 'class name' and 'class body'. The class body is written in curly brackets. This is how the Home class (file Home.java) should look:"

public class Home
{
    

CLASS BODY



}

 The class body may contain variables (also known as data) and methods ('functions')."

public class Home
{
    VARIABLE A


    VARIABLE Z


    
METHOD 1



    
METHOD N


}

public class Home
{
    int a;
    int b;

    public static void main(String[] args)
    {
        System.out.print("1");
    }

    public static double pi()
    {
        return 3.14;
    }
}

"Are int a and int b variables, and main and pi methods?"

"Yep."

"Can classes exist without variables?"

"Yes."

"And without methods?"

"Yes. But a minimal program must contain at least one class that must include at least one method/function to get the program running. This method must be named 'main'. A minimal program looks like this:"

public class Home
{
    public static void main (String[] args)
    {
    }
}

Look at the screen:"

public class Home
{
    public static void main(String[] args)
    {
        System.out.print("Amigo ");
        System.out.print("Is The ");
        System.out.print("Best");
    }
}

Here is your first task?

Write a program that displays: "I think being a programmer is cool".

=====================================================================

JAVA PROGRAM STRUCTURE:

PACKAGE NAME
package com.futujava.lesson2;
import java.io.IOException;
/**
 * User: General
 * Date: 12/21/12
 * Time: 11:59
 */
             CLASS NAME
public class Task1
{
                                                              ⎤
   private static String TEXT = "Kiss my metal rear actuator";⎥ CLASS VARIABLE
                                                              ⎦
                                                                ⎤
   public static void main(String[] args) throws IOException     ⎥
   {                                                            ⎥
      SCREEN OUTPUT                    SINGLE-LINE COMMENT      ⎥
      System.out.println(TEXT); //Display a single string       ⎥
        MULTILINE COMMENT                                       ⎥
      /*                                                        ⎥
        This is a multiline comment.                            ⎥
        The code below will display three identical strings.    ⎥ main() METHOD
       */                                                       ⎥
      VARIABLE DECLARATION                                      ⎥
      String s = "Ho-ho-ho!";                                   ⎥
      METHOD CALL                                               ⎥
      printTextMoreTimes(s, 3);                                 ⎥
   }                                                            ⎥
                                                                ⎦
                                          METHOD PARAMETERS   ⎤
   public static void printTextMoreTimes(String s, int count) ⎥ METHOD SIGNATURE
                                                              ⎦
                                                                ⎤
   {                                                            ⎥
      LOOP                                                      ⎥
      for (int i = 0; i < count; i++)                           ⎥
      LOOP BODY                                                 ⎥ METHOD BODY/CODE
      {                                                         ⎥
         System.out.println(s);                                 ⎥
      }                                                         ⎥
   }                                                            ⎥
                                                                ⎦
}

========================================================

Java Class

A class is a blueprint for the object. Before we create an object, we first need to define the class.

We can think of the class as a sketch (prototype) of a house. It contains all the details about the floors, doors, windows, etc. Based on these descriptions we build the house. House is the object.

Since many houses can be made from the same description, we can create many objects from a class.

Class contains many members variables, methods, constructors and blocks.

Class is a logical entity

class syntax 

accessmodifier class classname{

fields/variables

methods

constructors

blocks

}

Create a class in Java

We can create a class in Java using the class keyword. For example,

class ClassName {
  // fields
  // methods
}

Here, fields (variables) and methods represent the state and behavior of the object respectively.

• fields are used to store data
• methods are used to perform some operations

For our bicycle object, we can create the class as

class Bicycle {

  // state or field
  private int gear = 5;

  // behavior or method
  public void braking() {
    System.out.println("Working of Braking");
  }
}

In the above example, we have created a class named Bicycle. It contains a field named gear and a method named braking().

Here, Bicycle is a prototype. Now, we can create any number of bicycles using the prototype. And, all the bicycles will share the fields and methods of the prototype

public clsss example:

public class Sample{

variables;

methods(){}

constructors(){}

blocks{}

}

default class example

class Test{

variables;

methods(){}

constructors(){}

blocks{}

}

class:it tells that it is a java class

classname:it is defined by us.

naming conventions of java class:

rule1)if a class name contains one word first letter should be in uppercase & remaining letters are in lower case

public class Sample{

variables;

methods(){}

constructors(){}

blocks{}

}

rule2)if a class name contains more than one word every word first letter should be in uppercase & remaining all letters should be in 

lowercase& shouldnot provide spaces between words

class SeleniumWebDriver{

variables;

methods(){}

constructors(){}

blocks{}

}

Rule3)class name is followed by { curly braces  it tells that its class beginning AND SHOULD END WITH A } and should have atleast one member

Rule 4) File name should be same as classname.

========================================================================

Modifiers:

Modifiers are keywords that are added to change meaning of a definition.

Two types of modifiers are available in java

1)Non Access modifier:do not control access level, but provides other functionality

Non Access Modifiers:

final, static, abstract, volatile &transient

What are Access Modifiers?

In Java, access modifiers are used to set the accessibility (visibility) of classes, interfaces, variables, methods, constructors, data members, and the setter methods. For example,

class Animal {
    public void method1() {...}

   private void method2() {...}
}

In the above example, we have declared 2 methods: method1() and method2(). Here,

• method1 is public - This means it can be accessed by other classes.
• method2 is private - This means it can not be accessed by other classes.

 There are four types of access modifiers available in java: 

1. Default – No keyword required
2. Private
3. Protected
4. Public

There are four access modifiers keywords in Java and they are:

Modifier	Description
Default	declarations are visible only within the package (package private)
Private	declarations are visible within the class only
Protected	declarations are visible within the package or all subclasses
Public	declarations are visible everywhere

Public Access Modifier

When methods, variables, classes, and Constructors are declared public, then we can access them from anywhere. The public access modifier has no scope restriction. For example,

When you update your Facebook Status, it gives you 4 options

1. If you make this status visible for Public, anyone can see this status on Internet (Anyone On or Off Facebook). [Public Access Specifiers]

// Animal.java file
// public class
public class Animal {
    // public variable
    public int legCount;

    // public method
    public void display() {
        System.out.println("This is an animal class - display()");
        System.out.println("Animal have " + legCount + " legs.");
    }
}

// Main.java
public class Main {
    public static void main( String[] args ) {
        // accessing the public class
        Animal animal = new Animal();

        // accessing the public variable
        animal.legCount = 4;
        // accessing the public method
        animal.display();
    }
}

Output:

This is an animal class - display().
Animal have 4 legs.

Here,

• The public class Animal is accessed from the Main class.
• The public variable legCount is accessed from the Main class.
• The public method display() is accessed from the Main class.

Default Access Modifier

If we do not explicitly specify any access modifier for classes, methods, variables, and Constructors then by default the default access modifier is considered.

If you make this status visible for "Friends", then your status will be only visible for your Friends. Not your friends friends or everyone presents on Facebook. [Default Access Specifiers]






 For example,

package defaultPackage;
class Logger {
    void message(){
        System.out.println("This is a message");
    }
}
• Here, the Logger class has the default access modifier. And the class is visible to all the classes that belong to the defaultPackage package. However, if we try to use the Logger class in another class outside of defaultPackage, we will get a compilation error.
• NOTE: default accessmodifiers are accessible only within the same package, but not outside the package.

class Test{

//default accessmodifier variables

//accessmodifier static datatype variablename=value;

static int i=5;

//accessmodifier datatype variablename=value;

float f=3.4F;

//default static method

//accessmodifier static void methodname(){l+s}

static void m2(){l+s}

}

Private Access Modifier

When variables, Constructors, and methods are declared private, they cannot be accessed outside of the class. class can't be declared private.

If you make this status visible "only for me". No one can see this status except you. [Private Access Specifiers]

For example,

class Data {
    // private variable
    private String name;
}

public class Main {
    public static void main(String[] main){

        // create an object of Data
        Data d = new Data();

        // access private variable and field from another class
        d.name = "qaautomation";
    }
}

In the above example, we have declared a private variable named name. When we run the program, we will get the following error:

Main.java:18: error: name has private access in Data
        d.name = "qaautomation";
         ^

The error is generated because we are trying to access the private variable of the Data class from the Main class.

public class Test1{

//variable

private static int i=10;

private static void m2(){l+s}

}

Protected Access Modifier

When methods, Constructors, and data members are declared- protected, we can access them within the same package as well as from subclasses. 

If you make this status visible for Friends or Friends of friends, then your status will be only visible for your friends and your friends friends. Not everyone presents on Facebook or Internet. [Protected Access Specifiers]

For example,

class Animal {
    // protected method
    protected void display() {
        System.out.println("This is an animal class method -display");
    }
}

class Dog extends Animal {
    public static void main(String[] args) {

        // create an object of Dog class
        Dog dog = new Dog();
         // access protected method
        dog.display();
    }
}

• In the above example, we have a protected method named display() inside the Animal class. The Animal class is inherited by the Dog class. To learn more about inheritance.

  We then created an object dog of the Dog class. Using the object we tried to access the protected method of the parent class.

  Since protected methods can be accessed from the child classes, we are able to access the method of Animal class from the Dog class.

  Note: We cannot declare classes or interfaces protected in Java

Access modifiers are mainly used for encapsulation. It can help us to control what part of a program can access the members of a class. So that misuse of data can be prevented.

==============================================================

========================================================================

main method signature:

public static void main(String[] args){executable logics+statements}

Static: It is a nonaccess modifier keyword. In Java, it is possible to use the static keyword with methods, blocks, variables, as well as nested classes. 

In order to create a static member (block, variable, method, nested class), you need to precede its declaration with the keyword static.

if some property is common to all objects, then make that property static, then it won't occupy more memory.

Static variables have to be declared at class level and cannot be declared at method level.

 static class members are shareable across all instances of the same class

a static variable is a class-level variable, shared among all the instances of the class

static variable can be used to refer to the common property of all objects

only one copy of the static variable will be available for static variables across all objects.

If one object changes the value of the static variable, it will reflect in other objects too.

We can also access the static variables without creating an object for that class. Static variables are the first ones which are loaded into the memory when a class is loaded.

In Java, static keyword is mainly used for memory management.

f you consider the methods inside the “Math” class in Java, you will find that most of its methods are static. You can simply access them using the class name. For example, “Math.abs()”, “Math.pow()”, “Math.PI”, etc

Why declare any variable as static?

Example 1:

Suppose, you are working in say, A company. Certainly, a number of employees are working there too. All these employees have a different identity(name,age,address etc) but all share the same company name.

Here, if you do not declare the company name as static then all objects take it as an instance variable and allocate some memory. if there are n number of objects then memory space allocated=no_of_object*space allocated by one instance variable(company name).

So, make it static then it is shared by all objects from the same memory location and it helps to reduce memory also.

Example 2:

To illustrate, consider a class that models a Car. Cars have engines. But no two cars share the same engine (simultaneously). This means that each car has an engine that belongs to it exclusively. Therefore, an engine in a Car class would be a non-static attribute of the class. HOWEVER, the brand name of a car is shared across all instances of a class. In this case, brandName (i.e. Chevrolet) should be shared across all Car instances. Now, here’s the WHY you want to do this. Suppose tomorrow Chevrolet is bought by Ford. By making the brandName shareable (static) across all instances of Car, every instance of Car can be rebranded to Ford by making a single change. Because this is a shareable attribute, all instances receive the change without having to go to each individual instance to make the same change.

Example 3:

let's see through an example

Suppose there are 500 students in my college, now all instance data members will get memory each time when object is created.All student have its unique rollno and name so instance data member is good.Here, college refers to the common property of all objects.If we make it static,this field will get memory only once.

class Student{

int rollno;

String name;

static String college ="ITS”;

Student(int r,String n){

rollno = r;

name = n;

}

void display (){System.out.println(rollno+" "+name+" "+college);}

public static void main(String args[]){

Student s1 = new Student8(111,"Karan");

Student s2 = new Student8(222,"Aryan");

s1.display();

s2.display();

}

}

---------------------------------------------------------------------------------------------------------------------

Static method syntax without parameters:

accessmodifier static void methodName(){method body}

example:

public class StaticDemo{

private static void m1(){method body}

static void m2(){method body}

protected static void m3(){method body}

public static void m4(){method body}

}

static method syntax with parameters

accessmodifier static void methodName(datatype p1,datatype p2,datatype p3...){method body}

example:

public static void m5(int a,float b,char c){method body}

static variable syntax:

accessmodifier static datatype variablename=variablevalue;

1)static String s="selenium";

2)public static String collegeName="JNU";

3)private static int i=10;

4)protected static float x=25.5F;

=  -->assignment operator

== -->comparision operator

public static boolean b2=(i==x);

The first one is a constant variable such as PI, application name, or label. In example, you can see that Math.PI is a static variable provided by Java. In this case, we need to declare it with the “final” keyword.

public class Math { 
  public static final float PI = 3.14; 
} 

The second one is a variable that can be changed but it is the only one in your application. Normally, it is a counter which is used to count something like clicked times or the total number of transactions.

public class Bank { 
  public static long NUMBER_OF_TRANSACTIONS = 0; 
} 

Static Blocks in Java

Generally, static blocks in Java are used to initialize static variables. They are executed only once when the class is loaded and hence, are perfect for this job. Also, you can include more than one static block in the class. Static blocks can only access static variables. Let’s understand static blocks using the below example.

class Test{

   static int i = 10;

   static int j;

   static{

       System.out.println("Initializing the Static Variable using Static Block ...");

       j = i * 5;

   }

}

 class Main{

   public static void main(String args[]){

       System.out.println("Value of i is: " + Test.i);

       System.out.println("Value of j is: " + Test.j);

   }

Here, you saw the creation of two static variables called i and j inside the Test class. It went on to initialize variable j using a static block. In the main method, you must use the class name to print the values of i and j static variables. You can see that the static block gets executed before the execution of the main method. When the static block is executed, it prints the first line regarding the initialization and then initializes the variable j. Then, the main method gets executed which prints the values of both variables.

static {logic}

static{

System.out.println("integer value from 1 to 10");

int res=5+4;

System.out.println("result of 5+4 is-->"+res);

}

Why main() made it static??

Also, often you will notice that the main method in Java is defined as static. This is so because you don’t need an object to call the main method in Java. If you have defined the main method in Java as non-static, then the Java Virtual Machine (JVM) would have first created an instance for the main class and then called the main method using that instance which would lead to unnecessary memory usage. Moreover, there are tons of static methods defined in the Wrapper Classes and Utility Classes in Java.

public static void main(String[] args)

Each part of this method signature has a specific role:

• public: The method is accessible from anywhere.
• static: The method can be called without creating an instance of the class.
• void: The method does not return any value.
• main: The name of the method that Java looks for as the starting point of the application.
• String[] args: The parameter that allows the method to accept command-line arguments.

What Happens If static Is Removed?

If you remove the static keyword from the main method, like this:

java
public void main(String[] args)

The following issues occur:

1. No Entry Point: The Java Virtual Machine (JVM) expects to find a main method with the exact signature public static void main(String[] args). Without static, the method is not recognized as the entry point for the application. Consequently, the JVM will not be able to start the application and will throw an error.

2. Instance Method: The method becomes an instance method. This means you would need an instance of the class to invoke it. However, since the JVM requires a static main method to initiate the program, it will never reach the point of creating an instance to call this non-static method.

3. Error Message: When you try to run a Java application with a non-static main method, you will encounter an error like this:

   plaintext
   Error: Main method not found in class <YourClass>, please define the main method as:
      public static void main(String[] args)

-----------------------------------------------------------------------

void: it is a return type keyword. it will be applied in the method signature line.

if you declare void keyword in the method signature that method doesn't return any value

static method syntax with void:

accessmodifier static void methodName(){calculations+logical statements;}

nonstatic/instance method with void syntax:

accessmodifier void methodName(){calculations+logical statements;}

if you don't write the void in method signature line, then that method will return some value

static method syntax without void:

accessmodifier static datatype methodName(){

calculations+logical statements;

return value;

}

nonstatic method syntax without void:

accessmodifier datatype methodName(){

calculations+logical statements;

return value;

}

main():it is a builtin method in java. the program execution begins from this line onwords only.

method naming conventions:

rule1)if a method name contains one word all letters should be in lowercase

Examples:

public static void click(locator){}

private void type(locator,value){}

rule2)if a method name contains more than one word first word all letters should be in lowercase from second word onwards 

each word first letter should be in uppercase and dont provide spaces between words

Example:

protected static void clickAndWait(locator){}

rule3)method name is followed by () paranthesis and then '{' and end with '}'

Naming Method:

Method name should be verb because it represents action.

Use lowerCamelCase for naming methods

Example: setFirstName(), getFirstName(), getLastName().

()--this is paranthesis

i)this will be used after the method name

ii)this will be used in object creation for a class

classname refvar=new classname();

iii)controlstructures

if()

while()

for()

switch()

iv)typecasting time also we will use ()

datatype s1=(leftsidedatatype)s2;

-------------------

i)String[] args :these are command line arguments. it accepts many values.

(or)

ii)String args[]

(or)

iii)String...c

method Body {}:after the paranthesis method body will start.inside the method body should be written "logic+statements"

The body of a method consists of commands. We could even say that a method is a group of commands that has been given a name (method name). Both statements would be true."

method body inside we can write below things:

accessmodifier static void methodname(){

calculations

method calls

printstatement

}

System.out.println("text");:this is print statement in java.

System:it is built in class in java. it is available in java.lang package

. operator is used to access the field/method of the class

out:it is static variable in System class of datatype PrintStream

System.out ---is used to output any value

System.in --is used to take the input from keyboard

System.err: it throws the error

System.exit()--will exit the enire program

Keep this in mind: println doesn't start printing text from a new line. It prints text on the current line, but makes it so the next text will be printed on a new line."

"The println() command prints the text on the screen and adds a special unseen 'newline character'. This is what makes the next text start on a new line."

System.out.print() command, the text is displayed on the same line.

Commands		What will be displayed on the screen
1	System.out.println("Amigo"); System.out.println("Is The"); System.out.println("Best");	Amigo Is The Best
2	System.out.print("Amigo"); System.out.println("Is The"); System.out.print("Best");	AmigoIs The Best
3	System.out.print("Amigo"); System.out.print("Is The"); System.out.print("Best");	AmigoIs TheBest

The program is made up of three commands:

System.out.println("Humans and robots are friends forever");
System.out.println("Humans and robots are friends forever");
System.out.println("Humans and robots are friends forever");

"The second principle."

"A program can’t consist of nothing but commands."

Command	Description (what it does)
System.out.println(1);	Displays the number 1 on the screen
System.out.println("Amigo");	Displays "Amigo" on the screen
System.out.println("Rishi & Amigo");	Displays "Rishi & Amigo" on the screen

===============================================================

JAVA Interview Questions & Concepts test?

1)What is a class & give class structure?

2)What is the naming conventions of a clsss?

3)Which accessmodifier keywords are applicable for class?

4)what is Modifier?

5)What are different types of Modifiers?

6)What  is AccessModifier? And what are different types of accessmodifiers and explain in detail?

7)what is main() structure?

8)what is meant by static keyword?explain in detail?

9) what is static variable syntax?

10)what is static method syntax without parameters?

11)what is static block syntax?

12)what is void? Explain different type of method syntaxes?

13)why main() made it as static?

14)what is the naming conventions of a method?

15)What are different types of main() arguments?

16)Explain each word in System.out.println() in detail?

17)what is the difference between println() and print()?

18)what are different types of System class variables?

19)Guess the output

package basics;

public class Test {

public static void main(String[] args) {

int Integer=20;

char String = 'C';

System.out.print(Integer);

System.out.println(String);

}

}

i)20C

ii)Exception

-------------------

package basics;

public class Test2 {

public static void main(String...args) {

System.out.println("var args");

}

public static void main(String[] args) {

System.out.println("array");

}

}

a)var args

b)array

c)Exception

----------------------------------------