IT ---> Dev and Tester

Developer ---> develop the application

Tester ---> Test the application

Tester ---> Expected result met the actual result

Expected Result ---> client

Actual Result ---> Developers

Testing ---> Manual and Automation

Manual ---> human effort --> dont need any coding knowledge --> no tools required
-->MSEXCEL(update the status)

Automation ---> We need a tool called "Selenium"

Similar Automation Tools:

* Selenium
* Selenese
* Protractor ---> update has been stopped
* cypress ---> grooming slowly
* katalon

Applications:

* Web application
* desktop application
* Mobile Application

* Web application:

* anything which we are opening in the browser

eg: selenium

eg: Whatsapp web

* Desktop Application:

* apps which is in desktop

eg: AutoIT

eg: whatsapp application

* Mobile Application:

* apps in the mobile

eg: whatsapp

Appium
------------------------------------------------------------------------

Java:
* core java(15 hours)

Selenium:

Manual Testing
----------------------------------------------------------------------

Programming languages:
c
C++
Java ---> 2nd
JS
Ruby
Python ---> 1st
C#
.Net

Java --->

1991 ---> James Gosling ---> sun microsystems ---> Oak tree ---> OAK language

1995 --> License issue ---> oak name has been revert back ---> java (paid language)

2001 ---> Oracle aquired the java(free of cost)

Features:

* java is the open source(anyone can contribute)

* java is free of cost
* java is platform independent(different machines)
* java is strictly typed lanaguage
int a = 10;
char c = 'x';
* java is easily portable
write once and access anywhere

Installation:

jdk ---> 1.8 version

latest version --> 1.18

Goto: https://www.oracle.com/java/technologies/downloads/#java8-windows

Rigth click on this pc ---> check your system type--> 64 bit

32 ---> 86 installer

create oracle account and sign in to download

Once downloaded and installed goto command prompt and enter "java -version"

set the path:

Two ways:

1) set path="C:\Program Files\Java\jdk1.8.0_333\bin"

2) Environment variables --> system variabled add new --> JAVA_HOME and var value =
"C:\Program Files\Java\jdk1.8.0_333" then click on "path" --> edit ---> %JAVA_HOME
%/bin

CMD prompt --> javac --> to verify the path has benn succesfully set

Editor:

* Eclipse
* IntelliJ
* VisualStudio
* RAD(IBM)
* Pycharm(for python)

* Eclipse:

https://www.eclipse.org/downloads/

Select Eclipse for java developers and install the eclipse

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

Variables:

* container to store the values

syntax:

datatype varName = varValue;

int a = 10; //-214C to 214C

int b = 20;

datatype:

1) Primitive data type---> ranged

2) Non Primitive data type --> there's no range

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

Notations:

* Pascal Notation
* Camel Notation

* Pascal Notation:

* First letter of each word should start with the Uppercase

* No special characters allowed
* Only the underscore(_)

special chars: !@#$%^&*()(*&

eg:

ChennaiSuperKings
LoginPage
Login_Page

* Camel Notation:
 * first letter of first word should be in Lowercase and first letter of everyother
word should be in uppercase
* no special characters allowed
* only underscore(_) is allowed

Method name, package name

eg: chennai_Super_Kings
chennai_Super
chennai
loginPage
-------------------------------------------------------------------

Project
|
package
|
Class
|
Method

* Class
Initialize the variable
Method
Main Method
object creation
using object we need to call the method

print:
system.out.println("");

package demoSession;

public class FirstJavaCode {

int var1 = 10;

int var2 = 20;

public void addNumbers() {

System.out.println(var1 + var2);

// type main and ctrl + space and click enter

public static void main(String[] args) {

// To create an object --> className obj = new ClassName();

FirstJavaCode add = new FirstJavaCode();

// call the method using the object

add.addNumbers();

}
}

----------------------------------------------
Operators:

* ArithmeticOperators
* Relational Operators
* Logical Operators
* Assignment Operators
* Conditional Operators
* shorthand operators
* Increment/decrement operators

* ArithmeticOperators:

+ ---> Addition
- ---> Subtraction
* ---> Multlipication
/ ---> division
% ---> Modulo ---> remainder value

* Realtional Operators:

it will return either true or false

* >=
* <=
* ==
* <
* >
* !=

package operatorsDemo;

public class RelaDemo {

int var1 = 10;

int var2 = 5;

public void compareNumbers() {

System.out.println(var1 > var2); // true

System.out.println(var1 < var2); // false

System.out.println(var1 <= var2); // false

System.out.println(var1 >= var2); // true

System.out.println(var1 == var2); // false

System.out.println(var1 != var2); // true

public static void main(String[] args) {

 RelaDemo demo = new RelaDemo();
demo.compareNumbers();

3) Logical Operators:

* it will also return true or false

&& ---> AND operators ---> both the condition should satisfy
|| ----> OR Operators ---> either one condition should satisfy
! ---> NOt operators

package operatorsDemo;

public class LogicalDemo {

int var1 = 10;

int var2 = 5;

public void compareNumbers() {

System.out.println((var1>var2)&&(var1<var2)); //false

System.out.println((var1>=var2)&&(var1!=var2)); // true

System.out.println((var1<var2)||(var1>var2)); // true

System.out.println((var1!=var2)||(var1<=var2)); // true
}

public static void main(String[] args) {

LogicalDemo demo = new LogicalDemo();

demo.compareNumbers();

4) Assignment Operators:

= ---> assigning one value to the variable

int a = 5;

5) Shorthand operators:

+=
-=
*=
/=
%=
var1 = var1 + var2

var1+=var2
var1 = var1 * var2

var1*=var2

package operatorsDemo;

public class ShortHand {

int var1 = 10;

int var2 = 3;

public void shortDemo() {

// var1 = var1 + var2;

// var1+=var2;

System.out.println(var1 += var2);
System.out.println(var1 -= var2);
System.out.println(var1 *= var2);
System.out.println(var1 /= var2);
System.out.println(var1 %= var2);

public static void main(String[] args) {

ShortHand demo = new ShortHand();

demo.shortDemo();

6) Inc/dec Operator:
+1 will be added -->increment
-1 will be added ---> decrement
var++ ---> post increment
var-- ----> post decrement
--var ----> pre decrement
++var ----> pre increment

package operatorsDemo;

public class indecDemo {

int var1 = 10;

public void incdecDemo() {

System.out.println(var1); //10

System.out.println(var1++); //10
 System.out.println(var1); // 11

System.out.println(var1--); //11

System.out.println(var1); //10

System.out.println(++var1); //11

System.out.println(--var1); // 10

System.out.println(var1); // 10
}

public static void main(String[] args) {

indecDemo demo = new indecDemo();

demo.incdecDemo();
}

7) Conditional Operator:

Syntax:

(condition)?statement1:statement2

package operatorsDemo;

public class ConditionOper {

int age = 18;

public void ageCheck() {

System.out.println((age>=18)?"Eligible to vote":"Not Eligible to

vote");
}

public static void main(String[] args) {

ConditionOper ope = new ConditionOper();

ope.ageCheck();

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

* Control Statements:

* Controlling the flow of the execution by giving some condtions

if
if else
nested if
if else if ....

* Jump statments
break
continue
return

* if:

if(condition){

statements;

package controlState;

public class PracticeSession {

int age = 18;

public void ageCheck() {

if (age >= 18) {

System.out.println("eligible to vote");
}

if (age <= 18) {

System.out.println("not eligible to vote");

if (age == 18)

System.out.println("Need to apply voter id");

public static void main(String[] args) {

PracticeSession op = new PracticeSession();

op.ageCheck();

2) if

else

package controlState;

public class PracticeSession {

int age = 18;

 public void ageCheck() {

if (age >= 18) {

System.out.println("eligible to vote");
}

else {

System.out.println("Not eligible to vote");

}

public static void main(String[] args) {

PracticeSession op = new PracticeSession();

op.ageCheck();

3) Nested if:

if(condition){

if(condiiton){

if(condition){

package controlState;

public class PracticeSession {

int num = 36;

public void ageCheck() {

if (num % 2 == 0) {

System.out.println(num + " is divisble by 2");

if (num % 4 == 0) {

System.out.println(num + " is divisible by 4");

if (num % 6 == 0) {

System.out.println(num + " is divisible by 6");

}
}
}
 }

public static void main(String[] args) {

PracticeSession op = new PracticeSession();

op.ageCheck();

4) if else if ladder

if(condtion)
{
statements;
}

else if(condition){
statements;
}

else{

statements;

marks = 20

81 - 100 ---> grade A

61 - 80 ---> grade B
41 - 60 ---> grade c
21- 40 --> grade d
0- 20 ---> failed

package controlState;

public class PracticeSession {

int marks = 3;

public void gradeCheck() {

if ((marks > 81) && (marks <= 100)) {

System.out.println("Grade A");
}

else if ((marks > 61) && (marks <= 80)) {

System.out.println("Grade B");
}

else if ((marks > 41) && (marks <= 60)) {

System.out.println("Grade C");
 }

else if ((marks > 21) && (marks <= 40)) {

System.out.println("Grade D");
}

else {

System.out.println("failed");
}

public static void main(String[] args) {

PracticeSession op = new PracticeSession();

op.gradeCheck();

5) Switch Statements:

Switch(condition)

case value:
statements;
break;
package controlState;

public class SwitchDemo {

String proof = "Aadhar";

public void voteCheck() {

switch (proof) {
case "Pan":

System.out.println(proof + " is not valid to vote");

break;
case "License":
System.out.println(proof + " is not valid to vote");
break;
case "RationCard":
System.out.println(proof + " is not valid to vote");
break;

case "Aadhar":
System.out.println(proof + " is not the valid proof");
break;
default:
System.out.println("he is not elgible to vote");
break;
}
 }

public static void main(String[] args) {

SwitchDemo demo = new SwitchDemo();
demo.voteCheck();

}
-----------------------------------------------------------------------------
OOPS:

Object Oriented Programming Lanaguage

99% ---> oops

* Class
* Object
* Inheritance
* Polymorphism
* Encapsulation
* Abstraction
* Interface

* Inheritance:

* process of acquring the properties of the parent class to the child class

Keyword: "extends"

parent class ---> base class ---> super class

child class --> sub class ---> derived class

* Single Inheritance ---> one parent --> one child

* Multilevel Inheritance ---> one parent ---> one child --> form that child to
another child
* Multiple Inheritance ---> more than one parent for one child ---> java doesnot
support multiple inheritance, with the help of interface we can acheive
* Hierarchical Inheritance ----> one parent ---> multiple child
* Hybrid Inheritance ---> all combinations

Advantages:

* code reusability

* Single Inheritance ---> one parent --> one child

package InheritanceDemo;

public class FatherHouse {

public void activaBike() {

System.out.println("this is my fathers bike");

}
 public void Cycle() {

System.out.println("This is my father's cycle");

}

package InheritanceDemo;

public class SonHouse extends FatherHouse {

public void ktmBike() {

System.out.println("this is son's ktm bike");

}

public void pulsarBike() {

System.out.println("this is son's pulsar bike");

}

public static void main(String[] args) {

SonHouse son = new SonHouse();

son.ktmBike();
son.pulsarBike();
son.activaBike();
son.Cycle();
}

}
------------------------------------------------------

2) Multilvel inheritance --->one parent ---> one child --> form that child to
another child

grandparent ---> parent ---> child

package InheritanceDemo;

public class GrandParent {

public void Cycle() {

System.out.println("this is my grandparent cycle");

}

public void scooter() {

System.out.println("this is my grandparent scooter");

}

package InheritanceDemo;

public class FatherHouse extends GrandParent{

 public void activaBike() {

System.out.println("this is my fathers bike");

}

public void heroHonda() {

System.out.println("This is my father's cycle");

}

package InheritanceDemo;

public class SonHouse extends FatherHouse {

public void ktmBike() {

System.out.println("this is son's ktm bike");

}

public void pulsarBike() {

System.out.println("this is son's pulsar bike");

}

public static void main(String[] args) {

SonHouse son = new SonHouse();

son.ktmBike();
son.pulsarBike();
son.activaBike();
son.Cycle();
son.scooter();
son.heroHonda();
}

--------------------------------------------------------------------
3) Hierarchical inheritance:

package InheritanceDemo;

public class FatherHouse{

public void activaBike() {

System.out.println("this is my fathers bike");

}

public void heroHonda() {

System.out.println("This is my father's cycle");

}

}
package InheritanceDemo;

public class SonHouse extends FatherHouse {

public void ktmBike() {

System.out.println("this is son's ktm bike");

}

public void pulsarBike() {

System.out.println("this is son's pulsar bike");

}

public static void main(String[] args) {

SonHouse son = new SonHouse();

DaughterHouse daughter = new DaughterHouse();

son.ktmBike();
son.pulsarBike();
son.activaBike();
son.heroHonda();
daughter.scooty();
daughter.vespaBike();

package InheritanceDemo;

public class DaughterHouse extends FatherHouse {

public void scooty() {

System.out.println("this is my daughter's scooty");

}

public void vespaBike() {

System.out.println("this is my daughter's vespa bike");

}

}
---------------------------------------------------------------------------

Polymorphism:

* poly means many

* morphism ---> different types

performing the action in different ways

* Method overloading ---> compile time polymorphism

* Method overriding----> run time polymorphism
* different class , same method, same parameters
---
* Method overloading ---> compile time polymorphism
* same class name, same method name, but different parameters/arguments

* add the datatypes

* chnage the order of the data type
* increase the datatype

package PolymorDemoi;

public class MethodOverDemo {

public void addNumbers() {

System.out.println("addition is " + (20 + 30));

}

public void addNumbers(int a, int b) {

System.out.println(a + b);

public void addNumbers(int a, double b) {

System.out.println(a + b);

public void addNumbers(double b, int a) {

System.out.println(a + b);
}

public void addNumbers(int a, double b, int c) {

System.out.println(a + b + c);

public static void main(String[] args) {

MethodOverDemo demo = new MethodOverDemo();

demo.addNumbers();
demo.addNumbers(10, 10);
demo.addNumbers(20, 10.0);
demo.addNumbers(20.0, 30);
demo.addNumbers(40, 10.0, 50);
}

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

* Method Overiding or run time polymorphism:

* different class , same method, same parameters

package PolymorDemoi;
public class MaryAmmanBank {

public void CurrentAccount() {

System.out.println(" 10% interest");

}

public void SavingsAccount() {

System.out.println(" 6% Interest");
}

package PolymorDemoi;

public class MuruganBank extends MaryAmmanBank{

@Override
public void CurrentAccount() {

System.out.println(" 12% interest");

}

public void SavingsAccount() {

System.out.println(" 6% interest");
}

public static void main(String[] args) {

MuruganBank bank = new MuruganBank();

bank.CurrentAccount();
bank.SavingsAccount();

MaryAmmanBank bank1 = new MaryAmmanBank();

bank1.CurrentAccount();
bank1.SavingsAccount();
}

}
-------------------------------------------------------
Encapsulation:

* binding/wrapping/capsulating the data and the method together into the single
unit

* for securing our code

How to achieve the encapsulation:

* we can use of private access modifier

* we need to generate the getter and setter method

source--->generate getters and setters

package encapDemo;

public class BankDataBase {

 private String password = "icici123@$$";

public String getPassword() {

return password;
}

public void setPassword(String password) {

this.password = password;
}

package encapDemo;

public class HackerClass {

public static void main(String[] args) {

BankDataBase data = new BankDataBase();

System.out.println(data.getPassword());

data.setPassword("Hacker123");

System.out.println(data.getPassword());

}
----------------------------------------------------------------------
Constructor:

* it is used to intialize the object

* whenever the object is created, the constructor is automatically invoked
* constructor name should be same as class name
* doesnot have any return type

ClassName name = new ClassName();

package construcDemo;

public class CalcDemo {

int var1;
int var2;

// non paramterized constructor

CalcDemo() {
var1 = 20;
var2 = 30;
System.out.println("Addition value is : " + (var1 + var2));

}
 CalcDemo(int a, int b) {

System.out.println("Addition of a+b " + (a + b));

// constructor overloading
CalcDemo(int a, double b) {

System.out.println("inta and double b " + (a + b));

CalcDemo(int a, double b, int c) {

System.out.println("inta and double b and int c " + (a + b + c));

public static void main(String[] args) {

CalcDemo demo = new CalcDemo();

CalcDemo demo1 = new CalcDemo(40, 50);
CalcDemo demo2 = new CalcDemo(10, 40.0);
CalcDemo demo3 = new CalcDemo(20, 50.0, 10);

}
}
------------------------------------------------------------
this():

* it is used to call the current class constructor/method

* it should be the first line inside the constructor

package construcDemo;

public class CalcDemo {

int var1;
int var2;

// non paramterized constructor

CalcDemo() {
this(20, 50);
var1 = 20;
var2 = 30;
System.out.println("Addition value is : " + (var1 + var2));

CalcDemo(int a, int b) {
this(10, 20.0);
System.out.println("Addition of a+b " + (a + b));

// constructor overloading
CalcDemo(int a, double b) {
this(10, 30.0, 40);
 System.out.println("inta and double b " + (a + b));

CalcDemo(int a, double b, int c) {

System.out.println("inta and double b and int c " + (a + b + c));

public static void main(String[] args) {

CalcDemo demo = new CalcDemo();

CalcDemo demo1 = new CalcDemo(40, 50);
CalcDemo demo2 = new CalcDemo(10, 40.0);
CalcDemo demo3 = new CalcDemo(20, 50.0, 10);

}
}
------------------------------------------

* super:

* it is used to call the parent class constructor

package construcDemo;

public class HomePage {

HomePage() {

System.out.println("this is my home page");

}

package construcDemo;

public class LoginPage extends HomePage{

LoginPage(){
super();
System.out.println("this is my login page");
}

public static void main(String[] args) {

LoginPage page = new LoginPage();

----------------------------------------------------------------
Constructor chaining:
* using the one object calling multiple constructors

package construcDemo;

public class CalcDemo {

int var1;
int var2;

// non paramterized constructor

CalcDemo() {
this(20, 40);
var1 = 20;
var2 = 30;
System.out.println("Addition value is : " + (var1 + var2));

CalcDemo(int a, int b) {
this(20, 50.0);
System.out.println("Addition of a+b " + (a + b));

// constructor overloading
CalcDemo(int a, double b) {
this(20, 40.0, 60);
System.out.println("inta and double b " + (a + b));

CalcDemo(int a, double b, int c) {

System.out.println("inta and double b and int c " + (a + b + c));

public static void main(String[] args) {

CalcDemo demo = new CalcDemo();

}
}

------------------------------------------------
this and super keyword should not be used at the same place

package construcDemo;

public class LoginPage extends HomePage {

LoginPage() {
//super(); keyword is hidden here
this("ramesh");
System.out.println("this is my login page");
}
 LoginPage(String username) {
System.out.println(username);
}

public static void main(String[] args) {

LoginPage page = new LoginPage();

}
------------------------------------------------------------
Access modifier:

* public
* private
* Protected
* default

public:

* within the class

* within the package
* outside the package by subclass
* outside the package

package accessModDemo;

public class LoginPage {

public void msg() {

System.out.println("hello i am in facebook login page");

}

package accessModDemo;

public class HomePage {

public static void main(String[] args) {

LoginPage page = new LoginPage();

page.msg();
}

2) Private:

* access only within the class

package accessModDemo;

public class PaymentPage {

 private int amount = 2000;

private void msg() {

System.out.println("My order amount is " + amount);

}

3) Default:

* within the class

* within the package

package accessModDemo;

class A {

void msg() {

System.out.println("this is the default access modifier");

}

package accessModDemo;

public class B {

public static void main(String[] args) {

A a = new A();

a.msg();

4) Protected:

* within the class

* within the package
* outside the package with the subclass
* will not support outside the package

package accessModDemo;

public class A {

protected void msg() {

System.out.println("this is the default access modifier");

}

package construcDemo;
import accessModDemo.*;
public class B extends A {

public static void main(String[] args) {

B b = new B();
b.msg();

}
-----------------------------------------------------------------------

String:

* it is the collection of characters

char c = 's';

String s = "sdfghgerfdsd";

String str = "my name is ramesh";

String is mutable or immutable?

mutable ---> any modifications can be done once it has been declared
immutable --> modifications cannot be done

Why string is immutable?

String is immutable ---> once it has been declared we cannot modify or do any
changes to the string

Can we make the string as mutable?

* yes we can make the string as mutable but with the help of StringBuffer and
StringBuilder