DEV Community: Supriya Kolhe

C : Jump Statements

Supriya Kolhe — Mon, 15 Mar 2021 18:06:21 +0000

What are jump statements?
Types (Break, Continue, GoTo, Return)

1.What are jump statements :- Jump statements are used to interrupt the normal flow of program. They makes the control jump to another section of the program when encountered. It is usually used to terminate the loop or switch-case instantly. It is also used to escape the execution of a section of the program.

2.Break :
->Terminates the loop or switch statement and transfers execution to the statement immediately following the loop or switch.

break;

->The break statement is also used with if...else statement inside the loop.

#include <stdio.h>
int main() 
{
int num = 5;
while (num > 0) 
  {
  if (num == 3)
    break;
  printf("%d\n", num);
  num--;
}
}

Continue : The continue statement skips the current iteration of the loop and continues with the next iteration. Its syntax is:

continue;

->The continue statement is almost always used with the if...else statement.

#include <stdio.h>
int main() 
{
int nb = 7;
while (nb > 0) 
{
  nb--;
  if (nb == 5)
    continue;
 printf("%d\n", nb);
}
}

Go to: ->Transfers control to the labeled statement. ->The label is an identifier. When the goto statement is encountered, the control of the program jumps to label: and starts executing the code. ->Here label can be any plain text except C keyword and it can be set anywhere in the C program above or below to goto statement.

goto label;
... .. ...
... .. ...
label: 
statement;

/*Example:*/
#include <stdio.h>

int main () {

   int a = 10;
   LOOP:do 
       {
         if( a == 15) 
         {
             a = a + 1;
             goto LOOP;
         }
         printf("value of a: %d\n", a);
         a++;
       }while( a < 20 );
   return 0;
}

NOTE : Use of the goto statement is highly discouraged in any programming language because it makes it difficult to trace the control flow of a program, making the program hard to understand and hard to modify. Any program that uses a goto can be rewritten to avoid them.

Return : ->usually used at the end of a function to end or terminate it with or without a value. ->It takes the control from the calling function back to the main function(main function itself can also have a return). ->return can only be used in functions that is declared with a return type such as int, float, double, char, etc. ->The functions declared with void type does not return any value. Also, the function returns the value that belongs to the same data type as it is declared.

return [value/variable];

/*Example:*/
#include <stdio.h>
char func(int ascii) 
{
  return ((char) ascii);
}
int main() 
{
  int ascii;
  char ch;
  printf("Enter any ascii value in decimal: \n");
  scanf("%d", & ascii);
  ch = func(ascii);
  printf("The character is : %c", ch);
  return 0;
}

->In this program, we have two functions that have a return type but only one function is returning a value[func()] and the other is just used to terminate the function[main()].

The function func() is returning the character value of the given number(here 110). We also see that the return type of func() is char because it is returning a character value.

The return in main() function returns zero because it is necessary to have a return value here because main has been given the return type int.

C : Loops and Control Statements

Supriya Kolhe — Mon, 15 Mar 2021 17:53:17 +0000

What are loops?
Types (entry and exit controlled loop)
What is infinite/endless loop?
Types of loop constructs (while, do...while, for)
For loop in more detail
Nested loop
What are Loop Control Statements
Types (break, continue, goto)

1.Loops : Loop executes the sequence of statements many times until the stated condition becomes false. A loop consists of two parts, a body of a loop and a control statement. The control statement is a combination of some conditions that direct the body of the loop to execute until the specified condition becomes false. The purpose of the loop is to repeat the same code a number of times.

2.Types: Depending upon the position of a control statement in a program, looping in C is classified into two types:
2.1 Entry controlled loop : also called as pre-checking loop. A condition is checked before executing the body of a loop.
2.2 Exit controlled loop : also called as post-checking loop. A condition is checked after executing the body of a loop.

3. what is infinite/endless loop?
->The loop that does not stop executing and processes the statements number of times is called as an "infinite loop". An infinite loop is also called as an "Endless loop".
->some characteristics of an infinite loop:
** No termination condition is specified. **
** The specified conditions never meet. **

->Thus, to avoid this situation the control conditions must be well defined and specified otherwise the loop will execute an infinite number of times.
->The for loop is traditionally used for this purpose. Since none of the three expressions that form the 'for' loop is required, you can make an endless loop by leaving the conditional expression empty.

#include <stdio.h>

int main () 
{
   for( ; ; ) 
   {
      printf("This loop will run forever.\n");
   }

   return 0;
}

4. Types of loop constructs:-
4.1 while:
->It is an entry-controlled loop. In while loop, a condition is evaluated before processing a body of the loop. If a condition is true then and only then the body of a loop is executed. After the body of a loop is executed then control again goes back at the beginning, and the condition is checked if it is true, the same process is executed until the condition becomes false. Once the condition becomes false, the control goes out of the loop.
->In while loop, if the condition is not true, then the body of a loop will not be executed, not even once.

while (testExpression) 
{
    // the body of the loop 
}

/*Example: */
#include <stdio.h>
int main()
{
    int i = 1;

    while (i <= 5)
    {
        printf("%d\n", i);
        ++i;
    }

    return 0;
}

4.2 Do while:
->It is more like a while statement, except that it tests the condition at the end of the loop body.
->it terminates with a semi-colon (;)
->The body of do...while loop is executed at least once.
->After the body is executed, then it checks the condition. If the condition is true, then it will again execute the body of a loop otherwise control is transferred out of the loop.

do
{
   // the body of the loop
}
while (testExpression);

/*Example: */
#include<stdio.h>
#include<conio.h>
int main()
{
    int num=1;  
    do  
    {
        printf("%d\n",2*num);
        num++;      
    }while(num<=10);
    return 0;
}

4.3 For:
->step1: In this initialization, statement is executed only once.
->step2: The condition is a Boolean expression that tests and compares the counter to a fixed value after each iteration, stopping the for loop when false is returned.
->step3: The incrementation/decrementation increases (or decreases) the counter by a set value and again the test expression is evaluated.
->step4: This process goes on until the test expression is false. When the test expression is false, the loop terminates.

for (initial value; condition; incrementation or decrementation ) 
{
  statements;
}

/*Example:*/
#include<stdio.h>
int main()
{
    int number;
    for(number=1;number<=10;number++)   
    {
        printf("%d\n",number);      
    }
    return 0;
}

5.For loop in more detail:
->for loop can have multiple expressions separated by commas in each part.

for (x = 0, y = num; x < y; i++, y--) { 
  statements; 
}

->we can skip the initial value expression, condition and/or increment by adding a semicolon.

int i=0;
int max = 10;
for (; i < max; i++) {
  printf("%d\n", i);
}

6.Nested Loop:-using one loop inside another loop.
->nested for loop:

for ( init; condition; increment ) {

   for ( init; condition; increment ) {
      statement(s);
   }
   statement(s);
}

->nested while loop:

while(condition) {

   while(condition) {
      statement(s);
   }
   statement(s);
}

->nested do while loop:

do {
   statement(s);

   do {
      statement(s);
   }while( condition );

}while( condition );

->you can put any type of loop inside any other type of loop. For example, a 'while' loop can be inside a 'for' loop or vice versa.

#include <stdio.h>
int main() {
int i, j;
int table = 2;
int max = 5;
for (i = 1; i <= table; i++) 
{
  for (j = 0; j <= max; j++) 
  { 
    printf("%d x %d = %d\n", i, j, i*j);
  }
  printf("\n");
}
}//main end

NOTE : In some versions of 'C,' the nesting is limited up to 15 loops, but some provide more.

7.Loop Control Statements :change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed.

8.1 Break :
->Terminates the loop or switch statement and transfers execution to the statement immediately following the loop or switch.

break;

->The break statement is almost always used with if...else statement inside the loop.

#include <stdio.h>
int main() 
{
int num = 5;
while (num > 0) 
  {
  if (num == 3)
    break;
  printf("%d\n", num);
  num--;
}
}

8.2 Continue : The continue statement skips the current iteration of the loop and continues with the next iteration. Its syntax is:

continue;

->The continue statement is almost always used with the if...else statement.

#include <stdio.h>
int main() 
{
int nb = 7;
while (nb > 0) 
{
  nb--;
  if (nb == 5)
    continue;
 printf("%d\n", nb);
}
}

8.3 Go to:
->Transfers control to the labeled statement.
->The label is an identifier. When the goto statement is encountered, the control of the program jumps to label: and starts executing the code.
->Here label can be any plain text except C keyword and it can be set anywhere in the C program above or below to goto statement.

goto label;
... .. ...
... .. ...
label: 
statement;

/*Example:*/
#include <stdio.h>

int main () {

   int a = 10;
   LOOP:do 
       {
         if( a == 15) 
         {
             a = a + 1;
             goto LOOP;
         }
         printf("value of a: %d\n", a);
         a++;
       }while( a < 20 );
   return 0;
}

C : Decision Making

Supriya Kolhe — Mon, 15 Mar 2021 16:22:06 +0000

What is decision making?
Types (if, if else, Nested if....else, else if ladder, switch , Nested switch, ?:, goto)

1.Decision making: It is about deciding the order of execution of statements based on certain conditions or repeat a group of statements until certain specified conditions are met.

2.if : If the expression returns true, then the statement-inside will be executed, otherwise statement-inside is skipped and only the statement-outside is executed.

if(expression)
{
    statement inside_if;
}
    statement outside_if;

/*Example: */
#include <stdio.h>

void main( )
{
    int x, y;
    x = 15;
    y = 13;
    if (x > y )
    {
        printf("x is greater than y");
    }
}

3.if..else : If the expression is true, the statement-block1 is executed, else statement-block1 is skipped and statement-block2 is executed.

if(expression)
{
    statement block1;
}
else
{
    statement block2;
}

/*Example: */
#include <stdio.h>

void main( )
{
    int x, y;
    x = 15;
    y = 18;
    if (x > y )
    {
        printf("x is greater than y");
    }
    else
    {
        printf("y is greater than x");
    }
}

Nested if....else : if expression is false then statement-block3 will be executed, otherwise the execution continues and enters inside the first if to perform the check for the next if block, where if expression 1 is true the statement-block1 is executed otherwise statement-block2 is executed.

if( expression )
{
    if( expression1 )
    {
        statement block1;
    }
    else 
    {
        statement block2;
    }
}
else
{
    statement block3;
}

/*Example: */
#include <stdio.h>

void main( )
{
    int a, b, c;
    printf("Enter 3 numbers...");
    scanf("%d%d%d",&a, &b, &c);
    if(a > b)
    { 
        if(a > c)
        {
            printf("a is the greatest");
        }
        else 
        {
            printf("c is the greatest");
        }
    }
    else
    {
        if(b > c)
        {
            printf("b is the greatest");
        }
        else
        {
            printf("c is the greatest");
        }
    }
}

5.else if ladder : The expression is tested from the top(of the ladder) downwards. As soon as a true condition is found, the statement associated with it is executed.

if(expression1)
{
    statement block1;
}
else if(expression2) 
{
    statement block2;
}
else if(expression3 ) 
{
    statement block3;
}
else 
    default statement;

/*Example: */
#include <stdio.h>

void main( )
{
    int a;
    printf("Enter a number...");
    scanf("%d", &a);
    if(a%5 == 0 && a%8 == 0)
    {
        printf("Divisible by both 5 and 8");
    }  
    else if(a%8 == 0)
    {
        printf("Divisible by 8");
    }
    else if(a%5 == 0)
    {
        printf("Divisible by 5");
    }
    else 
    {
        printf("Divisible by none");
    }
}

NOTES TO REMEMBER ABOUT IF ELSE:
->In if statement, a single statement can be included without enclosing it into curly braces { ... }

int a = 9;
if(a > 3)
    printf("success");

->"==" must be used for comparison in the expression of if condition, if you use = the expression will always return true, because it performs assignment not comparison.
->Other than 0(zero), all other values are considered as true.

if(9)
    printf("True");

above block will print "True".

6.switch : A switch statement allows a variable to be tested for equality against a list of values. Each value is called a case, and the variable being switched on is checked for each switch case.

switch(expression) {

   case constant-expression  :
      statement(s);
      break; /* optional */

   case constant-expression  :
      statement(s);
      break; /* optional */

   /* you can have any number of case statements */
   default : /* Optional */
   statement(s);
}

#include <stdio.h>

int main () {

   /* local variable definition */
   char grade = 'B';

   switch(grade) {
      case 'A' :
         printf("Excellent!\n" );
         break;
      case 'B' :
      case 'C' :
         printf("Well done\n" );
         break;
      case 'D' :
         printf("You passed\n" );
         break;
      case 'F' :
         printf("Better try again\n" );
         break;
      default :
         printf("Invalid grade\n" );
   }

   printf("Your grade is  %c\n", grade );

   return 0;
}

RULES TO REMEMBER ABOUT SWITCH:
->The expression (after switch keyword) must yield an integer value i.e the expression should be an integer or a variable or an expression that evaluates to an integer.
->The case label values must be unique.
->The case label must end with a colon(:)
->The next line, after the case statement, can be any valid C statement.

NOTES TO REMEMBER ABOUT SWITCH:
->break statements are used to exit the switch block. It isn't necessary to use break after each block, but if you do not use it, then all the consecutive blocks of code will get executed after the matching block.
->default case is executed when none of the mentioned case matches the switch expression. The default case can be placed anywhere in the switch case. Even if we don't include the default case, switch statement works.
->Nesting of switch statements are allowed, which means you can have switch statements inside another switch block. However, nested switch statements should be avoided as it makes the program more complex and less readable.

Difference between switch and if:
->if statements can evaluate float conditions. switch statements cannot evaluate float conditions.
->if statement can evaluate relational operators. switch statement cannot evaluate relational operators i.e they are not allowed in switch statement.

7.Nested switch : It is possible to have a switch as a part of the statement sequence of an outer switch. Even if the case constants of the inner and outer switch contain common values, no conflicts will arise.

switch(ch1) {

   case 'A': 
      printf("outer switch" );

      switch(ch2) {
         case 'A':
            printf("inner switch" );
            break;
         case 'B': /* case code */
      }

      break;
   case 'B': /* case code */
}

/*Example: */
#include <stdio.h>

int main () {

   int a = 110;
   int b = 220;

   switch(a) {

      case 110: 
         printf("outer switch\n", a );

         switch(b) {
            case 220:
               printf("inner switch\n", a );
         }
   }

   printf("a is : %d\n", a );
   printf("b is : %d\n", b );

   return 0;
}

8.?:: can be used to replace if...else statements.

Exp1 ? Exp2 : Exp3;

->Exp1 is evaluated. If it is true, then Exp2 is evaluated and becomes the value of the entire ? expression.

->If Exp1 is false, then Exp3 is evaluated and its value becomes the value of the expression.

9.goto : allows us to transfer control of the program to the specified label. label is an identifier. When the goto statement is encountered, the control of the program jumps to label: and starts executing the code.

Why to not avoid goto:
->code might get hard to follow.
->goto allows one to jump out of scope.

goto label;
... .. ...
... .. ...
label: 
statement;

/*Example: */
#include <stdio.h>

int main() {

   const int maxInput = 100;
   int i;
   double number, average, sum = 0.0;

   for (i = 1; i <= maxInput; ++i) {
      printf("%d. Enter a number: ", i);
      scanf("%lf", &number);

      // go to jump if the user enters a negative number
      if (number < 0.0) {
         goto jump;
      }
      sum += number;
   }

jump:
   average = sum / (i - 1);
   printf("Sum = %.2f\n", sum);
   printf("Average = %.2f", average);

   return 0;
}

C : Operators

Supriya Kolhe — Mon, 15 Mar 2021 15:13:42 +0000

What are operators and Types?
Categories with example

1.What are operators and Types?
-An operator is a symbol that tells the compiler to perform specific mathematical or logical functions. For example + is an operator to perform addition.
-Categories of operators depends upon no. of operands.

2.Arithmetic Operator:performs mathematical operation on numerical values (constants and variables).
2.1 + : addition or unary plus
2.2 - : subtraction or unary minus
2.3 * : multiplication
2.4 / : division
2.5 % : remainder after division (modulo division)
2.6 ++ :increment (pre and post increment)
2.7 -- :decrement (pre and post decrement)

/*arithmetic operators*/
#include <stdio.h>
int main()
{
    int a = 5,b = 7, c;

    c = a+b;
    printf("a+b = %d \n",c);
    c = a-b;
    printf("a-b = %d \n",c);
    c = a*b;
    printf("a*b = %d \n",c);
    c = a/b;
    printf("a/b = %d \n",c);
    c = a%b;
    printf("Remainder when a/b = %d \n",c);
    printf("++a = %d \n", ++a);
    printf("--b = %d \n", --b);
    printf("++c = %f \n", ++c);
    printf("--d = %f \n", --d);

    return 0;
}

Increment ++ increases the value by 1 whereas decrement -- decreases the value by 1. These two operators are unary operators, meaning they only operate on a single operand.

3.Relational Operator: checks the relationship between two operands. Returns 1, if the relation is true,else returns value 0. They are used in decision making and loops.
3.1 == : Equal to
3.2 != : Not Equal to
3.3 < : Less than
3.4 > : Greater than
3.5 <= : Less than or equal to
3.6 >= : Greater than or equal to

// relational operators
#include <stdio.h>
int main()
{
    int a = 9, b = 2;

    printf("%d == %d is %d \n", a, b, a == b);
    printf("%d > %d is %d \n", a, b, a > b);
    printf("%d < %d is %d \n", a, b, a < b);
    printf("%d != %d is %d \n", a, b, a != b);
    printf("%d >= %d is %d \n", a, b, a >= b);
    printf("%d <= %d is %d \n", a, b, a <= b);

    return 0;
}

4.Assignment Operator: used for assigning a value to a variable.
4.1 = : similar to a = b
4.2 += : similar to a=a+b
4.3 -= : similar to a=a-b
4.4 *= : similar to a=a*b
4.5 /= : similar to a=a/b
4.6 %= : similar to a=a%b

// assignment operators
#include <stdio.h>
int main()
{
    int a = 8, c;

    c = a;      // c is 5
    printf("c = %d\n", c);
    c += a;     // c is 10 
    printf("c = %d\n", c);
    c -= a;     // c is 5
    printf("c = %d\n", c);
    c *= a;     // c is 25
    printf("c = %d\n", c);
    c /= a;     // c is 5
    printf("c = %d\n", c);
    c %= a;     // c = 0
    printf("c = %d\n", c);

    return 0;
}

5.Logical Operator: expression with logical operator returns either 0 or 1 depending upon whether expression results true or false. Logical operators are commonly used in decision making in C programming.
5.1 && : Logical AND. True only if all operands are true
5.2 || : Logical OR. True only if either one operand is true
5.3 ! : Logical NOT. True only if the operand is 0

// logical operators
#include <stdio.h>
int main()
{
    int a = 9, b = 2, c = 16, result;

    result = (a == b) && (c > b);
    printf("(a == b) && (c > b) is %d \n", result);

    result = (a == b) && (c < b);
    printf("(a == b) && (c < b) is %d \n", result);

    result = (a == b) || (c < b);
    printf("(a == b) || (c < b) is %d \n", result);

    result = (a != b) || (c < b);
    printf("(a != b) || (c < b) is %d \n", result);

    result = !(a != b);
    printf("!(a != b) is %d \n", result);

    result = !(a == b);
    printf("!(a == b) is %d \n", result);

    return 0;
}

6.Bitwise Operator: mathematical operations are converted to bit-level during computation which makes processing faster and saves power. They are are used in C programming to perform bit-level operations.
6.1 & : Bitwise AND
6.2 | : Bitwise OR
6.3 ^ : Bitwise exclusive OR
6.4 ~ : Bitwise complement
6.5 << : Shift left
6.6 >> : Shift right

// bitwise operators 
#include <stdio.h> 
int main() 
{ 
    unsigned char a = 5, b = 9; 
    printf("a = %d, b = %d\n", a, b); 
    printf("a&b = %d\n", a & b); 
    printf("a|b = %d\n", a | b); 
    printf("a^b = %d\n", a ^ b); 
    printf("~a = %d\n", a = ~a); 
    printf("b<<1 = %d\n", b << 1); 
    printf("b>>1 = %d\n", b >> 1); 

    return 0; 
}

7.Misc Operator:
7.1 sizeof() : Returns the size of a variable.
7.2 & : Returns the address of a variable.
7.3 * : Pointer to a variable.
7.4 ? : Conditional Expression.

8.Ternary Operator: ternary operator evaluates the test condition and executes a block of code based on the result of the condition.
condition ? expression1 : expression2;
-Here, condition is evaluated and if condition is true, expression1 is executed else if condition is false, expression2 is executed.
-The ternary operator takes 3 operands (condition, expression1 and expression2). Hence, the name ternary operator.

//without ternary operator
int a = 1, b = 2, ans;
if (a == 1) {
    if (b == 2) {
        ans = 3;
    } else {
        ans = 5;
    }
} else {
    ans = 0;
}
printf ("%d\n", ans);

//with ternary operator i.e. conversion of above code
int a = 1, b = 2, ans;
ans = (a == 1 ? (b == 2 ? 3 : 5) : 0);
printf ("%d\n", ans);

C : Programming Fundamentals

Supriya Kolhe — Sun, 14 Mar 2021 18:40:00 +0000

Programming language
Purpose
What is a program
EDP (Electronic data processing)
CPU components
What is Software?

Programming language:-
The computer understands binary/machine/assembly language i.e. in the form of 0's and 1n's.
for example: printf("Hello"); will be 01010111110000100 in binary form

Purpose / Why use programming language?
The purpose of programming is to find a sequence of instructions that will automate the performance of a task (which can be as complex as an operating system) on a computer, often for solving a given problem. Also, The programing language enables us to write efficient programs and develop online solutions such as mobile applications, web applications, and games, etc. Programming is used to automate, maintain, assemble, measure and interpret the processing of the data and information.

What is a program?
A program is a specific set of ordered operations for a computer to perform. Also, a computer program is a collection of instructions that can be executed by a computer to perform a specific task. A computer program is usually written by a computer programmer in a programming language.

EDP (Electronic data processing):-
It is a modern technique to process data. The data is processed through the computer. Data and a set of instructions are given to the computer as input and the computer automatically processes the data according to the given set of instructions.

CPU components:-

MU or Memory Unit:-
-this unit can store instructions, data, and intermediate results. This unit supplies information to other units of the computer when needed. It is also known as the internal storage unit or the main memory or the primary storage or Random Access Memory (RAM).
-speed, power, and capability are affected by its size.
Control Unit:-
-responsible for controlling the transfer of data and instructions among other units of a computer or manages and coordinates all the units of the computer.
-It does not process or store data.
ALU or Arithmetic logic Unit:-
-two parts: 1. Arithmetic Section 2. Logic Section
-Arithmetic Section is responsible for arithmetic operations.
-Logic Section is responsible for logic operations such as comparing, selecting, matching, and merging of data.

What is Software?
-Software is a collection of instructions and data that tell the computer how to work. This is in contrast to physical hardware, from which the system is built and actually performs the work.
-For example calculate software holds programs to perform operations such as addition, subtraction and so on.

JAVA: OOP (Encapsulation)

Supriya Kolhe — Wed, 16 Dec 2020 07:34:10 +0000

Q1: Access Modifiers?
Q2: OOPS: Encapsulation?
Q3: How to achieve Encapsulation?
Q4: Advantages?

1. Access Modifier:-

1.1 used to set the access level for classes, attributes, methods and constructors.
1.2 java provides access modifiers such as public, private, default and protected.

Class level access modifiers:-

public: class is accessible by other classes
default: class can be accessed by the classes from the same package. by default, the access modifier is set to default

Method, attributes, constructor level access modifiers:-

public: code is accessible for all classes
private: code is only accessible within the class
default: code is only accessible in the same package. by default, the access modifier is set to default
protected: code is accessible in the same package and outside the package through subclass

2. Encapsulation:-

2.1 it is one of the most powerful and fundamental concepts of Object-Oriented Programming
2.2 also called as data-hiding since it hides sensitive data from the user in order to keep it safe from outside interference and misuse

wrapping up of data into a single unit in order to prevent access to it from the outside world

2.3 for example, a car has many parts such as wheels, engine etc which together form a single object.

2.4 since there is a prohibition for direct access to the data. Functions are the only ways to access data. It basically creates a shield due to which code or data can't be accessed outside the shield

in order to read the data items, you call the member function in the object. It will read the data items from the function and return the value to you. The data can't be accessed directly in order to keep it protected and accidental alteration.

2.5 For example, In a large organisation there are many departments like sales, payroll, accounts, etc. And each department had it's own staff to maintain it's data.

Suppose an employee wants to know the data of import and export material, but he won't be allowed to access that data. Rather he will have to issue an order from the authorised person requesting for the required information. Then also the particular employee will not be directly accessing the data, rather the employees of the authorised department will gather the request data and pass it to the desired employee. >therefore, we can say that here Department is a single unit which is holding data and employees together.

3. Achieve Encapsulation:-

step 1: declare class level variables private

so they can't be accessed from outside of the class

step 2: provide setter and getter methods that are declared as public

used to view or change the value of the variable

Github link to below code
Simple example of encapsulation:-

public class Encapsulation
{
  //Declaring variables as private
  private String EmployeeName;
  private String EmployeeJob;
  private int EmployeeAge;

  //'public' Setter and Getter Methods
  public void setName(String EmployeeName)
  {
    this.EmployeeName = EmployeeName;
  }
  public String getName()
  {
    return EmployeeName;
  }

  public void setJob(String EmployeeJob)
  {
    this.EmployeeJob = EmployeeJob;
  }
  public String getJob()
  {
    return EmployeeJob;
  }

  public void setAge(int EmployeeAge)
  {
    this.EmployeeAge = EmployeeAge;
  }
  public int getAge()
  {
    return EmployeeAge;
  }

  public static void main (String[] args)
  {
    //creating object
    Encapsulation e = new Encapsulation();

    // setting values through setter methods
    e.setName("SUPRIYA KOLHE");
    e.setAge(22);
    e.setJob("SOFTWARE DEVELOPER");

    // Displaying values through Getter methods
    System.out.println("Name of the employee: " + e.getName());
    System.out.println("Age of the employee: " + e.getAge());
    System.out.println("Job of the employee: " + e.getJob());
  }//PSVM ends
}//Encapsulation class ends

/*
Name of the employee: SUPRIYA KOLHE
Age of the employee: 22
Job of the employee: SOFTWARE DEVELOPER
*/

3.1 as you can see in the above example, here we are setting values using Setter methods and accessing them using Getter method

where Setter methods set the value of the variable and Getter methods returns the values

4. Advantages:-

Data Hiding:- programmer is able to hide inner classes and provide authorization to access them to only desired users.

limits the accessibility of data

Easy to Testing:- because of sorted structure, it is easy to perform unit testing.
Flexibility and Maintainability:- programmer can make code read-only and write-only according to need.

Getter methods are used to read/fetch the data. Thus using only them will make code read-only.
Setter methods are used to write into the variables. Thus using only them will make code write-only.

Read-only example:

public class Employee
{  
    private String Dept="IT";  
    public String getDept()
    {  
         return Dept;   
    }  
}

Write-only example:

public class Employee
{  
    private String Salary="80000";  
    public String setSalary()
    {  
         return Salary;   
    }  
}

Getter and Setter Methods:- able to access private variables outside the class
Code Reusability:- able to use existing code effectively again and again.
Control & security:- a class has control over the variables and fields i.e. what is stored in them.

Please comment if you have any feedback or suggestions

JAVA: OOP (Abstraction)

Supriya Kolhe — Tue, 15 Dec 2020 15:20:40 +0000

Q1: OOPS: Abstraction?
Q2: interface?
Q3. abstract class?
Q4: Why can’t static methods be abstract in Java?
Q5: Advantages of Abstraction?
Q6: Why can’t we create an object of an Abstract Class?
Q7: Data Encapsulation vs Data Abstraction?
Q8: Abstract Class vs Interface?
Q9: When to use abstract class?
Q10: when to use interface?

1. Abstraction:-

1.1 process of hiding implementation

showing essential features and hiding non-essential features from the user.

1.2 for example, the remote is an interface between user and TV. It can be operated using various buttons, but the user is unaware of the internal part of the remote(i.e. circuits). It is so because the user does not need to know the details except the one that helps him operate the remote.
1.3 another example can be a login or registration form. The user is unaware/does not need to know how things work behind the curtains i.e UI.
1.4 it is a collection of abstract methods

ways to achieve abstraction:-

using the interface

using abstract class

2. Using Interface:-

2.1 Consider an example of the remote. It only works as an interface between the TV and the user. It can't be used to operate any other device/machine. i.t. it contains all the necessary functionalities which the user might require while hiding the implementation details from the user.
2.2 similarly interface contains empty methods and can contain variables also.

it means that interfaces don't provide any implementation details and it's up to classes/clients to provide the implementation details fro the method/methods when they implement the interface.

2.3 a class can use implements keyword to implement the interface and provide the implementation of the interface method
2.4 a java class can implement the interface in order to provide the implementation of the methods using interface
2.5 interface provide sets of rules for classes and tell them what to do and not to do.

in case class does not provide an implementation for all the methods of the interface, then the class must be declared abstract

Simple Example:

interface printable
{
    void start();
    void stop();
    int off=0;
    void pressed(int key);
}
class InterfaceExample implements printable
{
    int off=1;
    @Override
    public void start()
    {
        System.out.println("Started");
    }
    @Override
    public void stop()
    {
        System.out.println("\nvariable from interface : "+printable.off+"\nStopped ");
    }
    @Override
    public void pressed(int key)
    {
                //printable.off=1;
        System.out.println("\nvariable from interface : "+off+"\nPressed key number "+key);
    }
    public static void main(String args[])
    {
        InterfaceExample obj = new InterfaceExample();
        obj.start();obj.pressed(23);
        obj.stop();

    }
}
/*Started

variable from interface : 1
Pressed key number 23

variable from interface : 0
Stopped*/

-:here, we have created an interface with methods and variable which we are implementing in class and also trying to see whether a change of value inside the method will affect the interface variable i.e. off variable.

changing variable value inside the method does not affect interface value

-:in the above example if we uncomment the line "printable.off=1;" and then execute the code, it will throw a compile-time error

InterfaceExample.java:24: error: cannot assign a value to final variable off
                printable.off=1;
                         ^
1 error

static method inside interface Example:

interface Jump 
{
    static int getHeight() 
    {
        return 1;
    }
}
class Cat implements Jump 
{
    public void jump() 
    {
        System.out.println(“Jumping height “ + getHeight());//COMPILE TIME ERROR
    }
}

-:above code will not compile, since it is calling for the getHeight() which is supposed to be inside Kangaroo.

in order to execute the code, one change needs to be done i.e.

System.out.println(“Jumping height “ + Jump.getHeight());

nested interface Example:

interface OuterInterface 
{
    interface InnerInterface 
    {        
    }

}

class ImplementingC implements OuterInterface.InnerInterface 
{
}

nested interface Example:

class OuterC
{
    interface InnerInterface 
    {        
    }
}

class ImplementingC implements OuterClass.InnerInterface 
{    
}

interface extending interface Example:

public interface Teacher 
{
   public void Name(String name);
   public void Age(int age);
}

public interface Computer extends Teacher 
{
   public void MonthlyAttendance(int attendance);
   public void Salary(String sal);
   public void City(String city);
}

-:here the class that implements Computer interface must provide an implementation for both Computer and Teacher interface as it is extended by the Computer interface.

class of interface is also created after compiler compiles the code, i.e. printable.class file will be created after the compilation is done

Facts about interface:-

-:all members i.e. both methods and variables/fields of an interface are public
-:all the methods are public, abstract by default

except static and default

-:all the fields are public, static, final by default
-:an interface can extend another interface using extend keyword.
-:interface can contain static methods

Interface features:-

-:provide the total abstraction
-:help achieve multiple inheritance as java doesn't support multiple inheritances.

one class can implement several interfaces which can also be called as multiple interface implementation.

-:help achieve loose coupling in design patterns implementation

loose coupling means independent behaviour, for example, class A only knows about class B what class B has exposed through its interface.

3. using abstract class:-

3.1 provide total abstraction where all the methods are empty and field variables are public static and final by default
3.2 use keyword abstract before the class declaration and method declaration
3.3 we can't create an object of an abstract class

-:but we can define its constructor which can only be invoked in the constructor of its subclass
-:subclass constructor can access a superclass constructor to initialize its variable which might be needed in the subclass

3.4 they can contain both abstract and non-abstract methods.

they can't contain the body of the abstract method

3.5 if the subclass is not implementing the abstract methods then we have to make it abstract explicitly

if the class contains an abstract method, then it must be defined as abstract

3.6 abstract class is used to provide the most common feature that is specific to various classes.

subclasses can provide a different implementation of those methods according to their requirement

Eaxmple:-

abstract class Animal
{
    public abstract void Like();
    public void doTheyHaveLegs()
    {
        System.out.println("Yes, animals have legs");
    }
}

class Dog extends Animal
{
    @Override
    public void Like()
    {
        System.out.println("Dog like to cuddle.");
    }
}

class Lion extends Animal
{
    @Override
    public void Like()
    {
        System.out.println("Lion like to Growl");
    }
}



class TestAnimal
{
    public static void main(String[] args)
    {
        Animal Dog = new Dog();
        Dog.Like();

        Animal Lion = new Lion();
        Lion.Like();
        Dog.doTheyHaveLegs();
        Lion.doTheyHaveLegs();
    }
}
/*
Dog like to cuddle.
Lion like to Growl
Yes, animals have legs
Yes, animals have legs
*/

3.7 Here Animal is an abstract class which share a common property of animal with Dog and Lion class, which are implementing Like() of Animal abstract class

Animal class has both abstract and non-abstract methods in it.

4. Why can’t static methods be abstract in Java:-

4.1 there are two points to remembers

static keyword stated that static method can't be overridden.
abstract stated that the implementation of the method must be provided by the subclass

4.2 here as you can see, both the points contradict with each other, thus resulting it is not possible to make an abstract method static

although, abstract class may contain static methods

6. Why can’t we create an object of an Abstract Class:-

6.1 it is not very useful to do so because there would not be any actual implementation of the called method.

7. Data Encapsulation vs Data Abstraction:-

Data Encapsulation is hiding data or information

Abstraction is hiding the implementation details

Encapsulation binds the data members and methods together

data abstraction deals with showing the external details of an entity to the user and hiding the details of its implementation.

Encapsulation hides the data

abstraction provides access to a specific part of data

8. Abstract Class vs Interface:-

"abstract" keyword is used

"interface" keyword is used

We can extend an abstract class using the extends keyword

We can implement an interface using the implements keyword

can have both final, non-final, static and non-static variables

can only have final and static variables that are declared by default

speed is fast as compared to the interface

speed is slow as compared to abstract class

may or may not have variables declared as final

variables are by default declared as final

can have all access modifiers

only public access modifier is allowed

can have both abstract and non-abstract or concrete methods

can only have abstract methods,but, from version 8 of Java, the interface supports static and non-static methods too.

can have constructors

can not have constructors

Abstract classes do not support Multiple Inheritance, but, a class can extend only a single abstract class but can implement multiple Java interfaces

Interface support Multiple Inheritance

abstract class is used to avoid independence

interface is used when Future enhancement is needed

9. When to use abstract class:-

9.1 when some related classes that need to share the same lines of code
9.2 is there is a requirement of using access modifiers other than public

10. When to use interface:-

10.1 to achieve 100% abstraction
10.2 to achieve multiple inheritance
10.3 to specify the behaviour of a particular data type, irrespective of who implements its behaviour

Please comment if you have any feedback or suggestions

JAVA: OOP (Polymorphism)

Supriya Kolhe — Tue, 15 Dec 2020 05:14:12 +0000

Q1: OOPS: Polymorphism?
Q2: Compile-time polymorphism?
Q3: Run-time polymorphism?
Q4: Facts about Polymorphism?
Q5: Advantages?
Q6: Disadvantages?
Q7: Method Overloading?
Q8: Method Overloading?

1. Polymorphism:-

1.1 having the ability for a message or data to be processed in more than one form
1.2 It is derived from two Greek words, that is, poly and morphs. “poly” means many and “morphs” means forms. Henceforth, polymorphism implies many forms.
1.3 for e.g. a function to read secured classes - class_category() can take up different types of arguments like - class_category(FirstClass), class_category(SecondClass), class_category(Distinction), etc.

2. Compile-time polymorphism:-

2.1 performed by method overloading
2.2 also called as Static binding/Early binding

3. Run-time polymorphism:-

3.1 performed by method overriding
3.2 also called Dynamic binding/Dynamic Method Dispatch/Late binding, where

a call to an overridden method is resolved at runtime rather than compile-time OR
implemented dynamically when a program is being executed is called run-time polymorphism.

3.3 Here the overridden method is called through a reference variable of a parent class
3.4 Runtime polymorphism can't be achieved by data members

4. Facts about Polymorphism:-

4.1 all the working code in various classes does not require to know about the class being used by it, since their way of usage is the same.
4.2 For example, suppose there is a button and we know that pressing it will do something, but unaware of the output or the reference of its use. So the conclusion is, either way, it will not affect the way it is used.

5. Advantages:-

5.1 helps programmer to reuse the code and also the classes that once written to be tested and implemented
5.2 one variable name can contain values of multiple data types such as int, float etc.
5.3 improved readability of the program

6. Disadvantages:-

6.1 developers may find it difficult to implement polymorphism in codes
6.2 may affect performance

if the machine needs to decide which method or variable to invoke. and as these decisions are taken at run time.

6.3 reduces the readability of the program.

7. Method overloading:-

7.1 same method name & different parameters
7.2 it is performed within class
7.3 the main advantage of it is increased readability

when we must perform only one operation, having the same name of the methods.

ways to overload the method:
option 1: changing the number of arguments
option 2: changing the data type
option 3: changing both the number of arguments and data type

option 1: changing the number of arguments:-
-suppose you have to perform a multiplication operation of the given number but there can be n number of arguments, then if you create a method such as mult1(int, int) for two parameters and mult2(int, int, int) for three parameters then it may be difficult for the programmer to understand the behaviour of the block i.e. method because of the different name. In such situations, option 1 can be used.
-Github Link to code

class MethodOverloading
{
    static int mult (int a,int b)
    {
        return a*b;
    }
    static int mult(int a,int b,int c)
    {
        return a*b*c;
    }
}
class MethodOverloadingDifferentNumberOfArguments
{
    public static void main(String[] args)
    {
        System.out.println(MethodOverloading.mult(13,13));
        System.out.println(MethodOverloading.mult(9,9,9));
    }
}

Here we are creating static methods so that there is no need to create an instance for calling methods.

option 2: changing the data type:-
-suppose you have to perform a multiplication operation of the given number where given numbers can be of any data types. Then we can create methods such as mult(int, int), mult(float, float) and so on.
-Github Link to code

class MethodOverloading
{
    static int mult (int a,int b)
    {
        return a*b;
    }
    static double mult(double a,double b,double c)
    {
        return a*b*c;
    }
}
class MethodOverloadingChangingDataType
{
    public static void main(String[] args)
    {
        System.out.println(MethodOverloading);
        System.out.println(MethodOverloading);
    }
}
/*15
35.721*/

option3: changing both the number of arguments and data type:-
-sometimes we may need to use the method which is having both different numbers of arguments and data types. These methods are called or invoked with the value of the same data type and number of parameters used.
-Github Link to code

class MethodOverloading
{
    static int one (int a)
    {
        return a*a;
    }//return square
    static int two(int a,int b)
    {
        return a*b;
    }//return multiplication
    static int three(int a,int b,int c)
    {
        return a+b+c;
    }//return addition
}
class MethodOverloadingBoth
{
    public static void main(String[] args)
    {
        System.out.println(MethodOverloading.one(5));
        System.out.println(MethodOverloading.two(2,3));
        System.out.println(MethodOverloading.three(2,3,4));
    }
}
/*25
6
9*/

8. Method overriding:-

-used to achieve the runtime polymorphism or dynamic binding.
how to achieve method overriding:

a. the method name must be same as in the parent class
b. the parameters must be same as in the parent class
c. there must be an inheritance i.e. IS-A relationship

-Github Link to code

class MethodOverridingParent
{
    int a=10;
    public void run()
    {
        System.out.println("MethodOverridingParent class's method");
    }
}
class MethodOverridingChild1 extends MethodOverridingParent
{
    int a=9;
    public void run()
    {
        System.out.println("MethodOverridingChild1 class's method "+a);
    }
}
class MethodOverridingChild2 extends MethodOverridingParent
{
    public void run()
    {
        System.out.println("MethodOverridingChild2 class's method "+a );
    }
}
class MethodOverriding
{
    public static void main(String[] args)
    {
        MethodOverridingParent m1=new MethodOverridingChild1();
        m1.run();
        MethodOverridingParent m2=new MethodOverridingChild2();
        m2.run();
    }
}
/*MethodOverridingChild1 class's method 9
MethodOverridingChild2 class's method 10*/

Here, child classes will override the default behaviour provided by superclass and some of its own specific behaviour. As you can see MethodOverridingChild1 is giving the priority to it's own variable a first in order to perform the operation. and since MethodOverridingChild2 does not have any of it's own variable a, it is accessing the values of it's parent class.

Please comment if you have any feedback or suggestions

JAVA: OOP (Inheritance)

Supriya Kolhe — Sat, 12 Dec 2020 09:56:03 +0000

Q1: OOPS: Inheritance?
Q2: When to use?
Q3: Advantages?
Q4: Disadvantages?
Q5: Explain types with example?
Q6: Facts about inheritance?
Q7: Why java does not support multiple inheritances?
Q8: How to access private members of the superclass?

1. Inheritance:-

1.1 it is a mechanism of acquiring certain properties and behaviour of one class and another class i.e. parent class to child class.
1.2 the purpose of inheritance is to be able to create new classes that are built upon existing classes such as new child class on the existing parent class.
1.3 inheritance represents an IS-A-relationship i.e. parent-child relationship.
1.4 access modifiers play a major role in inheritance. Only public and protected members can be accessed by child class and not the private members. Although we can indirectly use private members using public or protected functions.
Click here to view the code for 1.4 point

Syntax and terms used

class Subclass-name extends Superclass-name {

//methods and fields

}

-: class - it is a group of objects with common properties. it is a template or blueprint from which object can be created.
-: subclass - class that inherits another class. It is also called a derived class, extended class, or child class.
-: superclass - class from where a subclass inherits the features. It is also called as a base class or a parent class.
-: extends - indicates the new class is inheriting from the existing class.

Example Below source code

2. When to use:-

2.1 Method Overriding to achieve runtime polymorphism
2.2 Code reusability

3. Advantages:-

3.1 reusability
3.2 readability
3.3 reliability i.e. the base class code will be already tested and debugged
3.4 less costly because of reusability
3.5 supports code extensibility
3.6 improper use or less knowledge may lead to wrong solutions

4. Disadvantages:-

4.1 less use of data members present in the base class may lead to memory wastage.
4.2 dependability may cause unintended damage i.e. inheritance causes the coupling between classes, thus a change in the base class will affect all the child processes.
4.3 can't inherit from final class i.e. below program will an error.
final class Class1 {

...
}

class Class2 extends Class1{

...
}

5 Types:-

Single Inheritance

1.1 subclass extends or inherits the features of one superclass. eg. daughter class is inheriting father class
1.2 Basically, java only uses a single inheritance as a subclass cannot extend more superclass.
CLICK HERE FOR SIMPLE PROGRAM
Multilevel Inheritance

2.1 a class will be inheriting a base class and as well as the derived class also act as the base class to other class. eg. daughter inherit form father, and father inherit from grandfather
CLICK HERE FOR SIMPLE PROGRAM
Hierarchical Inheritance

3.1 one class serves as a superclass for more than one subclass. eg. one teacher serves multiple students
CLICK HERE FOR SIMPLE PROGRAM
Multiple Inheritance (can't be implemented using class in java)

4.1 one class can have more than one superclass
4.2 java does not support multiple inheritances with classes, but it can only be achieved through interfaces
CLICK HERE FOR SIMPLE PROGRAM
Hybrid Inheritance

5.1 combinations of two or more types of inheritance.
5.2 since multiple inheritances can't be achieved in java with classes, hybrid inheritance also can't be achieved in java with classes. But using inheritance only it can be implemented.
CLICK HERE FOR SIMPLE PROGRAM

6. Facts about inheritance:-

6.1 only one superclass: The superclass can only be one, that is because java does not support multiple inheritance with classes.
6.2 inherit constructor: derived class can inherit methods, variables and nested classes from its superclass but constructors, that is because constructors are not members.

However, constructors of the superclass can be invoked from its derived class

6.3 inheritance does not allow derived class to inherit private members of its superclass.

However, it can be accessed using getters and setters in order to access them.

7. Why java does not support multiple inheritances:-

7.1 To prevent ambiguity: consider a situation where both BaseClass1 and BaseClass2 has calculate() with different working or behaviour, then there will be ambiguity if ChildClass which inherits both the base classes will try to call calculate()

because java compiler can't decide which calculate() it should inherit.

8. How to access private members of the superclass?

We can use getter and setter methods that
Click here for the code

option 1. return private member
option 2. return public member that store private member's values

Please comment if you have any feedback or suggestions

JAVA: OOP in brief

Supriya Kolhe — Fri, 11 Dec 2020 10:14:02 +0000

Q1: what do you mean by OOP concept?
Q2: List of OOP Features?
Q3: Why use OOP concepts or advantages of OOP?
Q4: Disadvantages of OOP?
Q5: Difference between Procedural and OOP programming?

NOTE: For detailed information on OOP feature click on one you wish to explore

1. what do you mean by OOP concept:-

1.1 stands for Object-Oriented Programming.
1.2 OOP is a methodology or paradigm to design a program using classes and objects.
1.3 OOP simplifies software development and maintenance by providing a few concepts such as:

2. List of OOP Features:-

2.1 class: a collection of object & logical entity, eg. bike
2.2 object: a real-life entity that has state & behaviour of its own, eg. colour
2.3 Inheritance: acquiring properties and behaviour from another class, eg. father and son
2.4 Polymorphism: one task in different ways, speak can be as meow and for the dog, it can be woof.
2.5 Abstraction: hiding internal details and showing functionality, eg. ATM machine
2.6 Encapsulation: binding/ wrapping code & data together into a single unit, eg. capsule containing different medicines

3. Why use OOP concepts or advantages of OOP:-

3.1 faster
3.2 Simple and provide a clear understanding and structure of code
3.3 reusability - able to reuse content and behaviour of the existing class in a new class.
3.4 code optimisation
3.5 Modifiability i.e. easy to update
3.6 Secure because of data hiding concept
3.7 easy to upgrade from small to large system
3.8 we cn eliminate redundant code and extend the use of existing classes
3.9 possible to have multiple objects
3.10 easy to partition the work in a project based on objects
3.11 provide message passing technique for communication between objects

4. Disadvantages of OOP:-

4.1 require more memory to increase speed
4.2 larger program size
4.3 not suitable for all type of programs

5. Difference between OOP programming & Procedural oriented language:-

OOPs makes development and maintenance easier i.e. if code grows it's easy to manage it

POL is not easy to manage

OOP provide data hiding

in procedure-oriented programming global data can be accessed from anywhere

OOP follows the bottom-up approach

POL follows the top-down approach

OOP have many access specifiers such as public, private, protected etc

POL does not have any

updation in OOP based program is easy

updation in POL based program is difficult

because of data hiding, OOP is secure

POL doesn't have any proper way of data hiding, thus it is less secure

in OOP data is more important

in POL functions are more important

OOP is mainly used to solve real-world problems

POL is mainly used for unreal issues

Please comment if you have any feedback or suggestions

JAVA: Increment, Decrement operator

Supriya Kolhe — Wed, 09 Dec 2020 13:42:06 +0000

Please go through Java: theory of Operators, Precedence & Associativity
for other operators and basics of below-mentioned operators

Q1: Increment operator?
Q2: Decrement operator?
Q3: Facts?

Increment operator:-
-: used to increment a value by 1.
-: 2 varieties are available that are pre-increment and post-increment.

Pre-Increment: value is first used for calculating the result and then incremented
For example X=42
y=++X
step1: x=x+1 (x=42+1=43)
step2: y=x (y=43)
Post-Increment: value is incremented and then calculated the result
For example X=42
y=X++
step1: y=x (y=42)
step2: x=x+1 (x=42+1=43)

Decrement operator:-
-: used to decrement a value by 1.
-: 2 varieties available that are pre-decrement and post-decrement

Pre-Decrement: value is first used for calculating the result and then decremented
For example X=42
y=--X
step1: x=x-1 (x=42-1=41)
step2: y=x (y=41)
Post-Decrement: value is decremented and then calculated the result
For example X=42
y=X--
step1: y=x (y=42)
step2: x=x-1 (x=42-1=41)

Facts:-
F1. Nesting like ++(++a) is not allowed
error: unexpected type

F2. Can be only used with variables.
program.java:9: error: unexpected type
a = 34++;
^
required: variable

F3. Can't be used on final variables
error: cannot assign a value to final variable a

F4. Can be only applied only on all primitive data types
error: bad operand type boolean for unary operator '++'

Please comment if you have any feedback or suggestions

JAVA: theory of Operators, Precedence & Associativity

Supriya Kolhe — Wed, 09 Dec 2020 11:46:21 +0000

Q1: What are the operators?
Q2: Types?
Q3: Arithmetic operators?
Q4: Assignment Operators?
Q5: Relational Operators?
Q6: Logical Operators?
Q7: Unary Operators?
Q8: Bitwise Operators?
Q9: instanceof Operator?
Q10: Ternary Operator?
Q11: Precedence and Associativity of Operators

1. What are the operators:-
-symbols that perform operations on variables and values. For example, + is used to perform an addition operation.

2. Types:-

Arithmetic Operators
Assignment Operators
Relational Operators
Logical Operators
Unary Operators
Bitwise Operators
instanceof Operator
Ternary Operator

3. Arithmetic Operators:-

these operators are used to perform basic mathematical operations on variables or data. For example, a+b or so
Addition : a+b, here, a is added with b variable
Subtraction : a-b, here, b is subtracted from b variable
Multiplication : a*b, here, a is multiplied wth b variable
Division : a/b, here, b is divided by a
Modulus : a%b, here, remainder after division of b by a is passes

4. Assignment Operators:-
-used to store the value in variable right after performing basic mathematical operations

= : Assignment, used to assign values to variables. a=6 will store 6 value in a variable. It assigns the value on it's the right side to it's left.
+= : Addition Assignment, a += b will work as a = a + b;
-= : Subtraction Assignment, a -= b; will work as a = a - b;
*= : Multiplication Assignment, a *= b; will work as a = a * b;
/= : Division Assignment, a /= b; will work as a = a / b;
%= : Modulus Assignment, a %= b; will work as a = a % b;

5. Relational Operators:-

== : Is Equal To, 3 == 9 returns false
!= : Not Equal To, 8 != 5 returns true
> : Greater Than, 1 > 5 returns false
< : Less Than, 1 < 5 returns true
>= : Greater Than or Equal To, 1 >= 5 returns false
<= : Less Than or Equal To, 1 <= 5 returns false

6. Logical Operators:-

&& : logical AND, expression1 && expression2, return true only if both expressions are true
|| : logical OR, expression1 || expression2, return true if at least one expression is true
! : logical NOT, !expression, return true if expression is not true or false

7. Unary Operators:-
-these operators are used only with one operand.

+ : Unary plus, stores value as positive, but there is no need to use it since without any operator the value is taken as positive
- : Unart minus, convert a negative value to a positive one, a = -10
! : Logical complement operator, inverts the value of a boolean,
++ : Increment operator, increments value by 1
-- : Decrement operator, decrements value by 1

NOTE: please check Java: Increment, Decrement operator for detailed ++ and --.

8. Bitwise Operators:-
-used to perform operations on individual bits
-can be used with any of the integer types

~ : Bitwise Complement, return 1n's complement
& : Bitwise AND. returns bit by bit AND of input values
| : Bitwise OR, returns bit by bit OR of input values
^ : Bitwise XOR, returns bit by bit XOR of input values
<< : Left Shift Operator, shifts all bits towards the left by a certain number of specified bits. For example, number<<2 where 2 means 2-bit operation
<<< : Unsigned Left shift operator, since "<<<" and "<<" are similar, there is no "<<<" operator in java.
>> : Signed Right Shift Operator, shifts all bits towards the right by a certain number of specified bits, For example, number>>2 where 2 means 2-bit operation
>>> : Unsigned Right Shift Operator

9. instanceof:-
-checks whether an object is an instanceof a particular class
-For example, output = str instanceof String;

10. Ternary Operator:-
-short trick for "if-then-else" statement
-Syntax: variable = expression ? expression1 : expression2
OR you can also say,
variable = condition ? if_execution_block: else_execution_block

11. Precedence and Associativity of Operators:-
-higher it appears in the table, the higher its precedence
-If an expression has more than one operators with similar precedence, the expression is evaluated according to its associativity i.e. left to right or right to left. For example, x=y=z=a, here allocation will be followed from right to left.

-General doubts on Precedence and Associativity:

using + in System.out.println(): in order to perform addition operation in System.out.println(), one should make sure to add them in parenthesis. Now the question arises why? Well, associativity of addition is left to right and hence integers are added to a string first and so forth.
is something like a=n+++o right? the answer is yes because it is understood by the compiler as a, =, n, ++, +, 0. But something like a=b+++++c will not work since there is no operand after the second unary operator.

Please comment if you have any feedback or suggestions