晓宇blog

HELLO WORLD :ghost:

//Text file name HelloWorld.java
public class HelloWorld {
  // main() is the method
  public static void main (String[] args)
    //Prints "Hello World" in the terminal window.
    System.out.println("Hello World");
}

COMPILATION & EXECUTING JAVA CODE

Go to your program directory in terminal (Assumed JAVA Path is set)
After for compile your code

javac HelloWorld.java (your program file name)

For run program

java HelloWorld (main class name)

DATA TYPES

Type	Set of values	Values	Operators
short	integers	between -2^15 and + (2^15)-1	+ - * / %
int	integers	between -2^31 and + (2^31)-1	+ - * / %
long	integers	between -2^63 and + (2^63)-1	+ - * / %
float	integers	real numbers 32 bit	+ - * /
double	floating-point numbers	real numbers 64 bit	+ - * /
boolean	boolean values	true or false	&& \|\| !
char	characters	16 bit
String	sequences of characters	it’s not a primitive data type

DECLARATION AND ASSIGNMENT STATEMENTS

//Declaration statement
int a,b;

//Assignment statement
a = 13212; //a is the variable name; 13212 is the literal which is assign to the variable a

//Initialization statement
int c = a + b;

//Compound assignment expressions
a += b; //a is the variable name; b is the variable name; this expression is an equivalent shorthand notation of a = a + b
a -= b; //a is the variable name; b is the variable name; this expression is an equivalent shorthand notation of a = a - b
a *= b; //a is the variable name; b is the variable name; this expression is an equivalent shorthand notation of a = a * b
a /= b; //a is the variable name; b is the variable name; this expression is an equivalent shorthand notation of a = a / b
a %= b; //a is the variable name; b is the variable name; this expression is an equivalent shorthand notation of a = a % b
a ^= b; //a is the variable name; b is the variable name; this expression is an equivalent shorthand notation of a = a ^ b
a &= b; //a is the variable name; b is the variable name; this expression is an equivalent shorthand notation of a = a & b
a \|= b; //a is the variable name; b is the variable name; this expression is an equivalent shorthand notation of a = a \| b

COMPARISON OPERATORS

Operation	Meaning
==	equal
!=	not equal
<	less than
>	greater than
<=	less than or equal
>=	greater than or equal

PRINTING

String s = "Happy Coding Folks!!"
System.out.print(String s) //print s
System.out.println(String s) //print s, followed by a newline
System.out.println() //print a newline

PARSING COMMAND-LINE ARGUMENTS

  String s = "Java is the best!!"
  int Integer.parseInt(String s) //convert s to an int value
  double Double.parseDouble(String) //convert s to a double value
  long Long.parseLong(String s) // convert s to a long value
````

### MATH LIBRARY
```java
  Public Class Math{
    double abs(double a)    // absolute value of a
    double max(double a, double b)  //maximum of a and b
    double min(double a, dobule a)  //minimum of a and b
    double sin(double theta) //sine of theta
    double cos(double theta) //cosine of theta
    double tan(double theta) //tangent of theta
    double toRadians(double degrees) // convert angle from degrees to radians
    double toDegrees(double radians)  // convert angle from radians to degrees
    double exp(double a)  // exponential (e^a)
    double pow(double a, double p) //raise a to the bth power (a^b)
    double random() //random in [0,1)
    double sqrt(double a)  //square root of a
    }

EXAMPLES OF TYPE CONVERSION

Expression	Expression type	Expression value
(1 + 2 + 3 + 4) / 4.0	double	2.5
Math.sqrt(4)	double	2.0
“123343” + 99	String	“12334399”
11 * 0.25	double	2.75
(int) 11 * 0.25	double	2.75
11 * (int) 0.25	int	0
(int) (11 * 0.25)	int	2

CONDITIONAL & LOOP STATEMENT

ANATOMY OF CONDITIONAL STATEMENT

IF Statement

if (x>y) { // x > y is the boolean expression
 //Sequence of statements
 x = y;
}

IF-ELSE STATEMENT

if (BOOLEAN EXPRESSION) {
//Sequence of statements
} else {
//Sequence of statements
}

NESTED IF STATEMENT

if (BOOLEAN EXPRESSION) {
//Sequence of statements
} else if {
//Sequence of statements
}
.
.
.
else {
//Sequence of statements
}

SWITCH STATEMENT

switch (VARIABLE TO EVALUATE ITS VALUE) {
  case value: Statement; break;
  ...
  ...
  ...
  default: Statement; break;
}

Example:

int month = 8;
      String monthString;
      switch (month) {
          case 1:  monthString = "January";
                   break;
          case 2:  monthString = "February";
                   break;
          case 3:  monthString = "March";
                   break;
          case 4:  monthString = "April";
                   break;
          case 5:  monthString = "May";
                   break;
          case 6:  monthString = "June";
                   break;
          case 7:  monthString = "July";
                   break;
          case 8:  monthString = "August";
                   break;
          case 9:  monthString = "September";
                   break;
          case 10: monthString = "October";
                   break;
          case 11: monthString = "November";
                   break;
          case 12: monthString = "December";
                   break;
          default: monthString = "Invalid month";
                   break;
      }

ANATOMY OF A LOOP STATEMENT

FOR LOOP STATEMENT

for (declare and initialize a loop control variable; loop-continuation condition/s; increment or decrement of the variable of control)
{
  //Statement
}

Example:

1
2
3

for (int i = 0; i <= n; i++) {
   System.out.println(i);
}

Enhanced for loop/for-each

for(dataType item : array) {
    ...
}

Example:

// array of numbers
int[] numbers = {100, 200, 300, 400};

// for each loop
for (int number: numbers) {
  System.out.println(number);

WHILE LOOP STATEMENT

1
2
3

while(condition){  //till condition will be true.
//code to be executed
}

Example:

//Initialization is a separate statement
int power = 1;

while ( power <= 10/2 ) // power <= n/2 is an example of the loop-continuation condition
{
  System.out.println(power);
}

DO-WHILE LOOP STATEMENT

1
2
3

do{ //always run one time even if condition would be false
  //Statement
} while(loop-continuation condition);

Example:

int i=1;  
do{  
  System.out.println(i);  
  i++;  
}while(i<=10);

ARRAY

ARRAY DECLARATION

int[]           ai;        // array of int
short[][]       as;        // array of array of short
short           s,         // scalar short
                aas[][];   // array of array of short
Object[]        ao;        // array of Object
Collection<?>[] ca;  // array of Collection of unknown type

DECLARATION OF ARRAY VARIABLE

Exception ae[]  = new Exception[3];
Object aao[][]  = new Exception[2][3];
int[] factorial = { 1, 1, 2, 6, 24, 120, 720, 5040 };
char ac[]       = { 'n', 'o', 't', ' ', 'a', ' ',
                    'S', 't', 'r', 'i', 'n', 'g' };
String[] aas    = { "array", "of", "String", };

ACCESS MODIFIERS

defualt(No keyword required)
private
public
protected

NON ACCESS MODIFIERS

static
final
transient
abstract
synchronized
volatile

Object Oriented Programming (OOPs) Concept :clipboard:

OBJECT

//Declare a variable, object name
String s;

//Invoke a contructor to create an object
s = new String ("Hello World");

//Invoke an instance method that operates on the object's value
char c = s.chartAt(4);

INSTANCE VARIABLES

public class Charge {
  //Instance variable declarations
  private final double rx, ry;
  private final double q;
}

METHODS

public static double sum (int a, int b) { //double is the return type, sum is the method's name, a and b are two arguments of type int;
  int result; //local variable
  result = a + b;
  return result;//return statement;
}

CLASS DECLARATION

class MyClass {
    // field, constructor, and
    // method declarations
}

Example:

    public class Bicycle {
        // the Bicycle class has
        // three fields
        public int cadence;
        public int gear;
        public int speed;
        // the Bicycle class has
        // one constructor
        public Bicycle(int startCadence, int startSpeed, int startGear) {
            gear = startGear;
            cadence = startCadence;
            speed = startSpeed;
        }
        // the Bicycle class has
        // four methods
        public void setCadence(int newValue) {
            cadence = newValue;
        }   
        public void setGear(int newValue) {
            gear = newValue;
        }   
        public void applyBrake(int decrement) {
            speed -= decrement;
        }  
        public void speedUp(int increment) {
            speed += increment;
        }
}

DECLARING CLASSESS IMPLEMENTATING AN INTERFACE AND EXTENDING PARENT CLASS

class MyClass extends MySuperClass implements YourInterface {
    // field, constructor, and
    // method declarations
}

MyClass is a subclass of MySuperClass and that it implements the YourInterface interface.

CONSTRUCTORS

A class contains constructors that are invoked to create objects from the class blueprint.
Constructor declarations look like method declarations—except that they use the name of the class and have no return type
Each and every class has defualt No-args constructor.

public class Bicycle{

    private int gear;
    private int cadence;
    private int speed;

    public Bicycle(int startCadence, int startSpeed, int startGear) { //args-constructor
      gear = startGear;
      cadence = startCadence;
      speed = startSpeed;
    }

    public Bicycle(){//No-args constructor
      super();
    }
}

POLYMORPHISM

Polymorphism is the concept where an object behaves differently in different situations.
There are two types of polymorphism
1. compile time polymorphism
2. runtime polymorphism.

1. Compile Time Polymorphism

Compile-time polymorphism is achieved by method overloading.

method overloading is creating multiple method with methods name is same and arguments are different.

public class Circle {

  public void draw(){
    System.out.println("Drwaing circle with default color Black and diameter 1 cm.");
  }

  public void draw(int diameter){ //method draw() overloaded.
    System.out.println("Drwaing circle with default color Black and diameter"+diameter+" cm.");
  }

  public void draw(int diameter, String color){ //method draw() overloaded.
    System.out.println("Drwaing circle with color"+color+" and diameter"+diameter+" cm.");
  }
}

2. Run Time Polymorphism

Run-time polymorphism is achieved by method overriding.
Runtime polymorphism is implemented when we have an “IS-A” relationship between objects.

method overriding is the subclass has to override the superclass method.

public interface Shape {

 public void draw();
}

public class Circle implements Shape{

  @Override
  public void draw(){
    System.out.println("Drwaing circle");
  }

}

public class Square implements Shape {

  @Override
  public void draw() {
    System.out.println("Drawing Square");
  }

}

Shape is the superclass and there are two subclasses Circle and Square

Below is an example of runtime polymorphism.

Shape sh = new Circle();
sh.draw();

Shape sh1 = getShape(); //some third party logic to determine shape
sh1.draw();

INHERITANCE

Inheritance is the mechanism of code reuse.
The object that is getting inherited is called the superclass and the object that inherits the superclass is called a subclass.
We use extends keyword in java to implement inheritance from class.
We use implements keyword in java to implement inheritance from interface.

1
2
3

public class Superclass{
  // methods and fields
}

1
2
3

public interface Superinterface{
  // methods and fields
}

1
2
3

public class Subclass extends Superclass implements Superinterface{
  // methods and fields
}

Abstraction

Abstraction is the concept of hiding the internal details and describing things in simple terms.
Abstraction can be achieved by two ways.
1. Abstract Class
2. Interface

1. Abstract Class

An abstract class must be declared with an abstract keyword.
It can have abstract and non-abstract methods.
It cannot be instantiated.
It can have constructors and static methods also.
It can have final methods which will force the subclass not to change the body of the method.

abstract class Flower{
    abstract String Smell(); //abstract method.
    String Oil(){  // non-abstract method.
       System.out.println("Flower Oil is good.");
     }
}

public class Lily extends Flower{
    private String Smell(){ // implementation of abstarct method.
      System.out.println("Lily smell's lovender.");
    }
}

2. Interface

Interface is a blueprint of a class.
It can have only abstract methods. [Except Java 8 and next versions.]
Since Java 8, we can have default and static methods in an interface.

interface print{  
    void printPaper();  
}  
public class A4 implements print{  
    public void printPaper(){
      System.out.println("A4 Page Printed. ");
    }  
}

Encapsulation

Encapsulation is used for access restriction to class members and methods.
Encapsulation is the technique used to implement abstraction in OOP.
As in encapsulation, the data in a class is hidden from other classes, so it is also known as data-hiding.
Encapsulation can be achieved by Declaring all the variables in the class as private and writing public methods in the class to set and get the values of variables.
Best example of Encapsulation is POJO (Plain-Java-Object-Class).

public class User {
    private String username;
    private String password;

    public String getUsername() {
      return username;
    }

    public void setUsername(String username) {
      this.username = username;
    }

    public String getPassword() {
      return password;
    }

    public void setPassword(String password) {
      this.password = password;
    }
}

ADVANCE DATA TYPE

STACK DATA TYPE

public class Stack<Item> implements Iterable <Item>

Stack()   //create an empty stack
boolean isEmpty() //return if the stack empty
void push(Item item) // push an item onto the stack
Item pop() //return and remove the item that was inserted most recently
int size() //number of item on stack

QUEUE DATA TYPE

public class Queue<Item> implements Iterable<Item>

Queue()  //create an empty queue
boolean isEmpty()  //return if the queue empty
void enqueue(Item item) // insert an item onto queue
Item dequeue()  //return and remove the item that was inserted least recently
int size() //number of item on queue

ITERABLE

//import Iterator
import java.util.Iterator;

public class Queue<Item> implements Iterable<Item> {

//FIFO queue
  private Node first;
  private Node last;
  private class Node {
    Item item;
    Node next;
  }

  public void enqueue (Item item)
  ...

  public Item dequeue()
  ...

}

SYMBOL TABLE DATA TYPE

public class ST<Key extends Comparable<Key>, Value>

ST()  //create and empty symbol table
void put(Key key, Value val)  //associate val with key
Value get(Key key)  //value associated with key
void remove(Key key) //remove key (and its associated value)
boolean contains (Key key)  //return if there is a value associated with key
int size()  //number of key-value pairs
Iterable<Key> keys()  // all keys in the symbol table

SET DATA TYPE

public class Set<Key extends Comparable<Key>> implements Iterable<Key>
Set() //create an empty set
boolean isEmpty()  //return if the set is empty
void add (Key key)  //add key to the set
void remove(Key key)  //remove key from set
boolean contains(Key key) //return if the key is in the set
int size() //number of elements in set

技术

JAVA

HELLO WORLD :ghost:

COMPILATION & EXECUTING JAVA CODE

DATA TYPES

DECLARATION AND ASSIGNMENT STATEMENTS

COMPARISON OPERATORS

PRINTING

PARSING COMMAND-LINE ARGUMENTS

EXAMPLES OF TYPE CONVERSION

CONDITIONAL & LOOP STATEMENT

ANATOMY OF CONDITIONAL STATEMENT

ANATOMY OF A LOOP STATEMENT

ARRAY

ACCESS MODIFIERS

NON ACCESS MODIFIERS

Object Oriented Programming (OOPs) Concept :clipboard:

OBJECT

METHODS

CLASS DECLARATION

POLYMORPHISM

1. Compile Time Polymorphism

2. Run Time Polymorphism

INHERITANCE

Abstraction

1. Abstract Class

2. Interface

Encapsulation

ADVANCE DATA TYPE