Followers

Tuesday, May 19, 2020

what is Java Operators ,Arithmetic Operators,Java Assignment Operators,Java Comparison Operators,java logical operators,best notes of java for all level,

Java Operators

Operators are used to perform operations on variables and values.

In the example below, we use the + operator to add together two values:

Example

int x = 100 + 50;

Although the + operator is often used to add together two values, like in the example above, it can also be used to add together a variable and a value, or a variable and another variable:

Example

int sum1 = 100 + 50;        // 150 (100 + 50)
int sum2 = sum1 + 250;      // 400 (150 + 250)
int sum3 = sum2 + sum2;     // 800 (400 + 400)

Java divides the operators into the following groups:

  • Arithmetic operators
  • Assignment operators
  • Comparison operators
  • Logical operators
  • Bitwise operators
  • Arithmetic Operators

    Arithmetic operators are used to perform common mathematical operations.







Java Assignment Operators

Assignment operators are used to assign values to variables.

In the example below, we use the assignment operator (=) to assign the value 10 to a variable called x:

Example

int x = 10;

The addition assignment operator (+=) adds a value to a variable:

Example

int x = 10;
x += 5;


Java Comparison Operators

Comparison operators are used to compare two values:



Java Type Casting widening,Java Type Casting narrowing,the best notes for java ,best notes for university of IT,what is narrowing and widening,how to use narrowing and widening




Java Type Casting

Type casting is when you assign a value of one primitive data type to another type.

In Java, there are two types of casting:

  • Widening Casting (automatically) - converting a smaller type to a larger type size
    byte -> short -> char -> int -> long -> float -> double

  • Narrowing Casting (manually) - converting a larger type to a smaller size type
    double -> float -> long -> int -> char -> short -> byte
  • Widening Casting

    Widening casting is done automatically when passing a smaller size type to a larger size type:

    Example

    public class MyClass {
      public static void main(String[] args) {
        int myInt = 9;
        double myDouble = myInt; // Automatic casting: int to double
    
        System.out.println(myInt);      // Outputs 9
        System.out.println(myDouble);   // Outputs 9.0
      }
    }
    


    Narrowing Casting

    Narrowing casting must be done manually by placing the type in parentheses in front of the value:

    Example

    public class MyClass {
      public static void main(String[] args) {
        double myDouble = 9.78;
        int myInt = (int) myDouble; // Manual casting: double to int
    
        System.out.println(myDouble);   // Outputs 9.78
        System.out.println(myInt);      // Outputs 9
      }
    }
    

WHAT IS Floating Point Types,how to type Floating Point Types in java language, float,scientific number,booleans,character,string,non premitive data, what is the meaning of Floating Point Types,the coding of Floating Point Types,best notes for java,


Floating Point Types

You should use a floating point type whenever you need a number with a decimal, such as 9.99 or 3.14515.

Float

The float data type can store fractional numbers from 3.4e−038 to 3.4e+038. Note that you should end the value with an "f":

Example

float myNum = 5.75f;
System.out.println(myNum);

Double

The double data type can store fractional numbers from 1.7e−308 to 1.7e+308. Note that you should end the value with a "d":

Example

double myNum = 19.99d;
System.out.println(myNum);

Use float or double?

The precision of a floating point value indicates how many digits the value can have after the decimal point. The precision of float is only six or seven decimal digits, while double variables have a precision of about 15 digits. Therefore it is safer to use double for most calculations.

Scientific Numbers

A floating point number can also be a scientific number with an "e" to indicate the power of 10:

Example

float f1 = 35e3f;
double d1 = 12E4d;
System.out.println(f1);
System.out.println(d1);


Booleans

A boolean data type is declared with the boolean keyword and can only take the values true or false:

Example

boolean isJavaFun = true;
boolean isFishTasty = false;
System.out.println(isJavaFun);     // Outputs true
System.out.println(isFishTasty);   // Outputs false

Boolean values are mostly used for conditional testing, which you will learn more about in a later chapter.


Characters

The char data type is used to store a single character. The character must be surrounded by single quotes, like 'A' or 'c':

Example

char myGrade = 'B';
System.out.println(myGrade);

Alternatively, you can use ASCII values to display certain characters:

Example

char a = 65, b = 66, c = 67;
System.out.println(a);
System.out.println(b);
System.out.println(c);

Tip: A list of all ASCII values can be found in our ASCII Table Reference.


Strings

The String data type is used to store a sequence of characters (text). String values must be surrounded by double quotes:

Example

String greeting = "Hello World";
System.out.println(greeting);

The String type is so much used and integrated in Java, that some call it "the special ninth type".

A String in Java is actually a non-primitive data type, because it refers to an object. The String object has methods that are used to perform certain operations on strings. Don't worry if you don't understand the term "object" just yet. We will learn more about strings and objects in a later chapter.


Non-Primitive Data Types

Non-primitive data types are called reference types because they refer to objects.

The main difference between primitive and non-primitive data types are:

  • Primitive types are predefined (already defined) in Java. Non-primitive types are created by the programmer and is not defined by Java (except for String).
  • Non-primitive types can be used to call methods to perform certain operations, while primitive types cannot.
  • A primitive type has always a value, while non-primitive types can be null.
  • A primitive type starts with a lowercase letter, while non-primitive types starts with an uppercase letter.
  • The size of a primitive type depends on the data type, while non-primitive types have all the same size.

how to type Java Data Types,how to type and what is Primitive Data Types,how to type the whole number,int,short,long



Java Data Types

As explained in the previous chapter, a variable in Java must be a specified data type:

Example

int myNum = 5;               // Integer (whole number)
float myFloatNum = 5.99f;    // Floating point number
char myLetter = 'D';         // Character
boolean myBool = true;       // Boolean
String myText = "Hello";     // String


Data types are divided into two groups:

  • Primitive data types - includes byte, short, int, long, float, double, boolean and char
  • Non-primitive data types - such as String, Arrays and Classes (you will learn more about these in a later chapter)

Primitive Data Types

A primitive data type specifies the size and type of variable values, and it has no additional methods.

There are eight primitive data types in Java:

Data Type Size Description
byte 1 byte Stores whole numbers from -128 to 127
short 2 bytes Stores whole numbers from -32,768 to 32,767
int 4 bytes Stores whole numbers from -2,147,483,648 to 2,147,483,647
long 8 bytes Stores whole numbers from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
float 4 bytes Stores fractional numbers. Sufficient for storing 6 to 7 decimal digits
double 8 bytes Stores fractional numbers. Sufficient for storing 15 decimal digits
boolean 1 bit Stores true or false values
char2 bytesStores a single character/letter or ASCII values
 

Numbers

Primitive number types are divided into two groups:

Integer types stores whole numbers, positive or negative (such as 123 or -456), without decimals. Valid types are byte, short, int and long. Which type you should use, depends on the numeric value.

Floating point types represents numbers with a fractional part, containing one or more decimals. There are two types: float and double.

Even though there are many numeric types in Java, the most used for numbers are int (for whole numbers) and double (for floating point numbers). However, we will describe them all as you continue to read

Integer Types

Byte

The byte data type can store whole numbers from -128 to 127. This can be used instead of int or other integer types to save memory when you are certain that the value will be within -128 and 127:

Example

byte myNum = 100;
System.out.println(myNum);

Short

The short data type can store whole numbers from -32768 to 32767:

Example

short myNum = 5000; System.out.println(myNum);

Int

The int data type can store whole numbers from -2147483648 to 2147483647. In general, and in our tutorial, the int data type is the preferred data type when we create variables with a numeric value.

Example

int myNum = 100000;
System.out.println(myNum);

Long

The long data type can store whole numbers from -9223372036854775808 to 9223372036854775807. This is used when int is not large enough to store the value. Note that you should end the value with an "L":

 


how to create a responsive slideshow with CSS and JavaScript,how to make slide for web,automatic slide show,multiple slide show.

Slideshow / Carousel

A slideshow is used to cycle through elements:








Create A Slideshow

Step 1) Add HTML:

Example

<!-- Slideshow container -->
<div class="slideshow-container">

  <!-- Full-width images with number and caption text -->
  <div class="mySlides fade">
    <div class="numbertext">1 / 3</div>
    <img src="img1.jpg" style="width:100%">
    <div class="text">Caption Text</div>
  </div>

  <div class="mySlides fade">
    <div class="numbertext">2 / 3</div>
    <img src="img2.jpg" style="width:100%">
    <div class="text">Caption Two</div>
  </div>

  <div class="mySlides fade">
    <div class="numbertext">3 / 3</div>
    <img src="img3.jpg" style="width:100%">
    <div class="text">Caption Three</div>
  </div>

  <!-- Next and previous buttons -->
  <a class="prev" onclick="plusSlides(-1)">&#10094;</a>
  <a class="next" onclick="plusSlides(1)">&#10095;</a>
</div>
<br>

<!-- The dots/circles -->
<div style="text-align:center">
  <span class="dot" onclick="currentSlide(1)"></span>
  <span class="dot" onclick="currentSlide(2)"></span>
  <span class="dot" onclick="currentSlide(3)"></span>
</div>

Step 2) Add CSS:

Style the next and previous buttons, the caption text and the dots:

Example

* {box-sizing:border-box}

/* Slideshow container */
.slideshow-container {
  max-width: 1000px;
  position: relative;
  margin: auto;
}

/* Hide the images by default */
.mySlides {
  display: none;
}

/* Next & previous buttons */
.prev, .next {
  cursor: pointer;
  position: absolute;
  top: 50%;
  width: auto;
  margin-top: -22px;
  padding: 16px;
  color: white;
  font-weight: bold;
  font-size: 18px;
  transition: 0.6s ease;
  border-radius: 0 3px 3px 0;
  user-select: none;
}

/* Position the "next button" to the right */
.next {
  right: 0;
  border-radius: 3px 0 0 3px;
}

/* On hover, add a black background color with a little bit see-through */
.prev:hover, .next:hover {
  background-color: rgba(0,0,0,0.8);
}

/* Caption text */
.text {
  color: #f2f2f2;
  font-size: 15px;
  padding: 8px 12px;
  position: absolute;
  bottom: 8px;
  width: 100%;
  text-align: center;
}

/* Number text (1/3 etc) */
.numbertext {
  color: #f2f2f2;
  font-size: 12px;
  padding: 8px 12px;
  position: absolute;
  top: 0;
}

/* The dots/bullets/indicators */
.dot {
  cursor: pointer;
  height: 15px;
  width: 15px;
  margin: 0 2px;
  background-color: #bbb;
  border-radius: 50%;
  display: inline-block;
  transition: background-color 0.6s ease;
}

.active, .dot:hover {
  background-color: #717171;
}

/* Fading animation */
.fade {
  -webkit-animation-name: fade;
  -webkit-animation-duration: 1.5s;
  animation-name: fade;
  animation-duration: 1.5s;
}

@-webkit-keyframes fade {
  from {opacity: .4}
  to {opacity: 1}
}

@keyframes fade {
  from {opacity: .4}
  to {opacity: 1}
}


Step 3) Add JavaScript:

Example

var slideIndex = 1;
showSlides(slideIndex);

// Next/previous controls
function plusSlides(n) {
  showSlides(slideIndex += n);
}

// Thumbnail image controls
function currentSlide(n) {
  showSlides(slideIndex = n);
}

function showSlides(n) {
  var i;
  var slides = document.getElementsByClassName("mySlides");
  var dots = document.getElementsByClassName("dot");
  if (n > slides.length) {slideIndex = 1}
  if (n < 1) {slideIndex = slides.length}
  for (i = 0; i < slides.length; i++) {
      slides[i].style.display = "none";
  }
  for (i = 0; i < dots.length; i++) {
      dots[i].className = dots[i].className.replace(" active", "");
  }
  slides[slideIndex-1].style.display = "block";
  dots[slideIndex-1].className += " active";




Automatic Slideshow

To display an automatic slideshow, use the following code:

Example

var slideIndex = 0;
showSlides();

function showSlides() {
  var i;
  var slides = document.getElementsByClassName("mySlides");
  for (i = 0; i < slides.length; i++) {
    slides[i].style.display = "none";
  }
  slideIndex++;
  if (slideIndex > slides.length) {slideIndex = 1}
  slides[slideIndex-1].style.display = "block";
  setTimeout(showSlides, 2000); // Change image every 2 seconds
}

Multiple Slideshows

Example

var slideIndex = [1,1];
/* Class the members of each slideshow group with different CSS classes */
var slideId = ["mySlides1", "mySlides2"]
showSlides(1, 0);
showSlides(1, 1);

function plusSlides(n, no) {
  showSlides(slideIndex[no] += n, no);
}

function showSlides(n, no) {
  var i;
  var x = document.getElementsByClassName(slideId[no]);
  if (n > x.length) {slideIndex[no] = 1}
  if (n < 1) {slideIndex[no] = x.length}
  for (i = 0; i < x.length; i++) {
    x[i].style.display = "none";
  }
  x[slideIndex[no]-1].style.display = "block";
}

Tip: Also check out How To - Slideshow Gallery and How To - Lightbox.

what is Java Variables,Java Identifiers,Declare Many Variables,Display Variables,how to use variable in programming,imported variable lesson,java lesson

Java Variables

Variables are containers for storing data values.

In Java, there are different types of variables, for example:

  • String - stores text, such as "Hello". String values are surrounded by double quotes
  • int - stores integers (whole numbers), without decimals, such as 123 or -123
  • float - stores floating point numbers, with decimals, such as 19.99 or -19.99
  • char - stores single characters, such as 'a' or 'B'. Char values are surrounded by single quotes
  • boolean - stores values with two states: true or false
  • Declaring (Creating) Variables

  • To create a variable, you must specify the type and assign it a value:

  • Syntax

    type variable = value;
    

    Where type is one of Java's types (such as int or String), and variable is the name of the variable (such as x or name). The equal sign is used to assign values to the variable.

    To create a variable that should store text, look at the following example.
  • Example

    Create a variable called name of type String and assign it the value "John":

    String name = "John";
    System.out.println(name);
    

    To create a variable that should store a number, look at the following example:

    Example

    Create a variable called myNum of type int and assign it the value 15.
  • int myNum = 15;
    System.out.println(myNum);
    

    You can also declare a variable without assigning the value, and assign the value later:

    Example

    int myNum;
    myNum = 15;
    System.out.println(myNum);
    

    Note that if you assign a new value to an existing variable, it will overwrite the previous value:

    Example

    Change the value of myNum from 15 to 20:

    int myNum = 15;
    myNum = 20;  // myNum is now 20
    System.out.println(myNum);
  • Final Variables

    However, you can add the final keyword if you don't want others (or yourself) to overwrite existing values (this will declare the variable as "final" or "constant", which means unchangeable and read-only):

    Example

    final int myNum = 15; myNum = 20; // will generate an error: cannot assign a value to a final variable
  • Other Types

    A demonstration of how to declare variables of other types:

    Example

    int myNum = 5;
    float myFloatNum = 5.99f;
    char myLetter = 'D';
    boolean myBool = true;
    String myText = "Hello";
  • Display Variables

    The println() method is often used to display variables.

    To combine both text and a variable, use the + character:

    Example

    String name = "John"; System.out.println("Hello " + name);
  • You can also use the + character to add a variable to another variable:

    Example

    String firstName = "John ";
    String lastName = "Doe";
    String fullName = firstName + lastName;
    System.out.println(fullName); 
  • For numeric values, the + character works as a mathematical operator (notice that we use int (integer) variables here):

    Example

    int x = 5;
    int y = 6;
    System.out.println(x + y); // Print the value of x + y
    

    From the example above, you can expect:

    • x stores the value 5
    • y stores the value 6
    • Then we use the println() method to display the value of x + y, which is 11
    • Declare Many Variables

      To declare more than one variable of the same type, use a comma-separated list:

      Example

      int x = 5, y = 6, z = 50;
      System.out.println(x + y + z);
    • Java Identifiers

      All Java variables must be identified with unique names.

      These unique names are called identifiers.

      Identifiers can be short names (like x and y) or more descriptive names (age, sum, totalVolume).

      Note: It is recommended to use descriptive names in order to create understandable and maintainable code:

      Example

      // Good int minutesPerHour = 60; // OK, but not so easy to understand what m actually is int m = 60;
    • The general rules for constructing names for variables (unique identifiers) are:

    • Names can contain letters, digits, underscores, and dollar signs
    • Names must begin with a letter
    • Names should start with a lowercase letter and it cannot contain whitespace
    • Names can also begin with $ and _ (but we will not use it in this tutorial)
    • Names are case sensitive ("myVar" and "myvar" are different variables)
    • Reserved words (like Java keywords, such as int or boolean) cannot be used as names
    •  
     
     

Monday, May 18, 2020

what is Java Comments,how to put comment in java,multi line comment,single line comment,java comment single and multiline with example,

Java Comments

Comments can be used to explain Java code, and to make it more readable. It can also be used to prevent execution when testing alternative code.

Single-line comments start with two forward slashes (//).

Any text between // and the end of the line is ignored by Java (will not be executed).

This example uses a single-line comment before a line of code:

Example

// This is a comment
System.out.println("Hello World");

This example uses a single-line comment at the end of a line of code:

Example

System.out.println("Hello World"); // This is a comment

Java Multi-line Comments

Multi-line comments start with /* and ends with */.

Any text between /* and */ will be ignored by Java.

This example uses a multi-line comment (a comment block) to explain the code:

Example

/* The code below will print the words Hello World
to the screen, and it is amazing */
System.out.println("Hello World");

Single or multi-line comments?

It is up to you which you want to use. Normally, we use // for short comments, and /* */ for longer.