Java Characters

isDigit() :

package charactersMethods;

public class isDigit {

public static void main(String[] args) {

System.out.println(Character.isDigit('a'));
System.out.println(Character.isDigit('5'));
System.out.println(Character.isDigit(5));
}

}

isLetter() :

package charactersMethods;

public class isLetter {

public static void main(String[] args) {

System.out.println(Character.isLetter('a'));
System.out.println(Character.isLetter('5'));
System.out.println(Character.isLetter(5));
}

}

isUppercase() \ isLowercase() :

package charactersMethods;

public class isUppercaseOrLowercase {

public static void main(String[] args) {

System.out.println(Character.isUpperCase(' '));
System.out.println(Character.isUpperCase('2'));
System.out.println(Character.isUpperCase('a'));
System.out.println(Character.isUpperCase('A'));
System.out.println(Character.isLowerCase('A'));
}

}

toUppercase() \ toLowercase() :

package charactersMethods;

public class toUppercaseOrLowercase {

public static void main(String[] args) {

System.out.println(Character.toLowerCase('c'));
System.out.println(Character.toLowerCase('C'));
System.out.println(Character.toUpperCase('c'));
System.out.println(Character.toUpperCase('C'));
}

}

isWhitespace() :

package charactersMethods;

public class isWhitespace {

public static void main(String[] args) {

System.out.println(Character.isWhitespace('\n'));
System.out.println(Character.isWhitespace(' '));
System.out.println(Character.isWhitespace('\t'));
}

}

toString() :

package charactersMethods;

public class toString {

public static void main(String[] args) {

System.out.println("Pring as string "+Character.toString('c'));
System.out.println("Pring as string "+Character.toString('2'));
System.out.println("Pring as string "+Character.toString('C'));
}

}

Java Number

xxxValue():

package numberMethods;

public class xxxValue {

public static void main(String[] args) {

Integer phone = 5 ;

System.out.println("double Value: "+phone.doubleValue());
System.out.println("int Value: "+phone.intValue());
System.out.println("long Value: "+phone.longValue());
System.out.println("byte Value: "+phone.byteValue());
System.out.println("short Value: "+phone.shortValue());
System.out.println("float Value: "+phone.floatValue());
}
}

valueOf():

package numberMethods;

public class valueOf {

public static void main(String[] args) {

Integer a = Integer.valueOf(5);

Double b = Double.valueOf(6);

Float c = Float.valueOf("7");

Integer d = Integer.valueOf("20",30);

System.out.println(a);

System.out.println(b);

System.out.println(c);

System.out.println(d);

}

}

toString() :

package numberMethods;

public class toString {

public static void main(String[] args) {

Integer a = 5;

System.out.println(a.toString());

System.out.println(Integer.toString(101));

}

}

toRadian() :

package numberMethods;

public class toRadian {

public static void main(String[] args) {

double x = 45;

double y  = 30;

System.out.println(Math.toRadians(y));

System.out.println(Math.toRadians(x));

}

}

toDegree() :

package numberMethods;

public class toDegrees {

public static void main(String[] args) {

double x = 45;

double y = 30;

System.out.println(Math.toDegrees(y));

System.out.println(Math.toDegrees(x));

}

}

sqrt() :

package numberMethods;

public class sqrt {

public static void main(String[] args) {

double a = 9;

System.out.println(Math.sqrt(a));

}

}

abs() :

package numberMethods;

public class abs {

public static void main(String[] args) {

Integer a = -4;

int b = -5;

float c = -6;

double d = -7;

System.out.println(Math.abs(a));

System.out.println(Math.abs(b));

System.out.println(Math.abs(c));

System.out.println(Math.abs(d));

}

}

ceil() / floor() :

package numberMethods;

public class ceil {

public static void main(String[] args) {

double d = -100.6;

float f = -90;

System.out.println(Math.ceil(d));

System.out.println(Math.ceil(f));

System.out.println(Math.floor(d));

System.out.println(Math.floor(f));

}

}

compareTo():

package numberMethods;

public class compareTo {

public static void main(String[] args) {

Integer age = 5 ;

System.out.println(age.compareTo(5));

System.out.println(age.compareTo(4));

System.out.println(age.compareTo(3));

}

}

equals() :

package numberMethods;

public class equals {

public static void main(String[] args) {

Integer a = 5;

Integer b = 10;

Short c = 5;

Integer d = 10;

System.out.println(a.equals(b));

System.out.println(a.equals(c));

System.out.println(b.equals(d));

}

}

exp() :

package numberMethods;

public class exp {

public static void main(String[] args) {

// The value of e is 2.7183

double x = 6.235;

double y = 2;

System.out.println(Math.exp(x));

System.out.println(Math.exp(y));

}

}

log() : 

package numberMethods;

public class log {

public static void main(String[] args) {

double x = 2.22;

double y = 11.635;

System.out.println(Math.log(x));

System.out.println(Math.log(y));

}

}

min() / max() :

package numberMethods;

public class minMax {

public static void main(String[] args) {

System.out.println(Math.min(20, 30));

System.out.println(Math.min(20.0, 30.0));

System.out.println(Math.max(20, 30));

System.out.println(Math.max(20.0, 30.0));

}

}

parseInt() :

package numberMethods;

public class parseInt {

public static void main(String[] args) {

int i = Integer.parseInt("1011");

double d = Double.parseDouble("909");

int z = Integer.parseInt("444", 16);

System.out.println(i);

System.out.println(d);

System.out.println(z);

}

}

 pow() : 

package numberMethods;

public class pow {

public static void main(String[] args) {

double a = 2;

double b = 3;

// 2 power 3 = 8

System.out.println(Math.pow(a, b));

}

}

random() : 

package numberMethods;

public class random {

public static void main(String[] args) {

System.out.println(Math.random());

}

}

rint() :

package numberMethods;

public class rint {

public static void main(String[] args) {

double d = 100.625;

double e = 100.500;

double f = 100.250;

System.out.println(Math.rint(d));

System.out.println(Math.rint(e));

System.out.println(Math.rint(f));

}

}

 round() : 

package numberMethods;

public class round {

public static void main(String[] args) {

double d = 100.625;

double e = 100.500;

double f = 100.250;

float g = 100;

float h = 100f;

System.out.println(Math.round(d));

System.out.println(Math.round(e));

System.out.println(Math.round(f));

System.out.println(Math.round(g));

System.out.println(Math.round(h));

}

}

sin() \ cos () \ tan(): asin() \ acos() \ atan() ::

package numberMethods;

public class sinAsin {

public static void main(String[] args) {

double radian = Math.toRadians(45);

System.out.println(Math.sin(radian));

System.out.println(Math.cos(radian));

System.out.println(Math.tan(radian));

System.out.println(Math.asin(Math.sin(radian)));

System.out.println(Math.asin(Math.cos(radian)));

System.out.println(Math.asin(Math.tan(radian)));

}

}

atan2() :

package numberMethods;

public class aTan2 {

public static void main(String[] args) {

double x = 45;

double y = 30;

System.out.println(Math.atan2(x, y));

}

}

Scanner

import java.util.Scanner;

public class Class1 {

public static void main(String[] args) {

System.out.println("Please Enter your name: ");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
System.out.println("Your Name is: " + name);
scanner.close();

}
}

Polymorphism

package package1;

public interface ParentsInterface {

public String getName();

}

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

package package1;

public class Child1 implements ParentsInterface{

@Override

public String getName() {

return "Child_1";

}

}

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

package package1;

public class Child2 implements ParentsInterface {

@Override

public String getName() {

return "Child_2";

}

}

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

package package1;

public class RelationsINTERMEDIATE {

public String getPersonName(ParentsInterface p) {

return p.getName();

}

}

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

package package1;

public class Main {

public static void main(String[] args) {

RelationsINTERMEDIATE in = new RelationsINTERMEDIATE();

String name = in.getPersonName(new Child1());

String name2 = in.getPersonName(new Child2());

System.out.println(name);

System.out.println(name2);

}

}

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

LessCoupling-BestWay2

package namePackage;

public interface NamingKidsInterface {

public String  getNames();

}

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

package namePackage;

public class Child1 implements NamingKidsInterface {

@Override

public String getNames() {

return "First Child Name is: Bipin";

}

}

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

package namePackage;

public class Child2 implements NamingKidsInterface {

@Override

public String getNames() {

return "Second Child Name is: Deepan";

}

}

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

package namePackage;

public class Child3 implements NamingKidsInterface{

@Override

public String getNames() {

return "Third Child Name is : Arun";

}

}

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

package namePackage;

public class Communicating_Intermediate_Class {

public String getKidName(NamingKidsInterface names) {

return names.getNames();

}

}

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

package namePackage;

public class MainActivity {

public static void main(String[] args) {

Communicating_Intermediate_Class commu = new Communicating_Intermediate_Class();

String kid1 = commu.getKidName(new Child1());

String kid2 = commu.getKidName(new Child2());

String kid3 = commu.getKidName(new Child3());

System.out.println(kid1);

System.out.println(kid2);

System.out.println(kid3);

}

}

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

LessCoupling-BestWay

package package1;

public interface AnimalInterface {

public String getName();

}

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

package package1;

public class Lion implements AnimalInterface {

@Override

public String getName() {

return "Lion Name";

}

}

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

package package1;

public class Tiger implements AnimalInterface{

@Override

public String getName() {

return "Tiger Name";

}

}

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

package package1;

// THIS WAY OF INTERMEDIATE CLASS REDUCE COUPLING

public class IntermediateClass {

public String getAnimal(AnimalInterface a) {

return a.getName();

}

/**

// HIGHLY COUPLED WAY

 

public String getAnimals(Tiger t){

return t.getName();

}

public String getAnimals(Lion l){

return l.getName();

}

**/

}

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

package package1;

public class MainActivity {

public static void main(String[] args) {

IntermediateClass ic = new IntermediateClass();

String animName = ic.getAnimal(new Tiger());

String animName2 = ic.getAnimal(new Lion());

System.out.println(animName2);

System.out.println(animName);

}

}

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

HighCoupling/BadWay

package package1;

public interface NamingChildrenInterface {

public String getNames();

}

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

package package1;

public class Jetha implements NamingChildrenInterface{

@Override

public String getNames() {

return "Bipin Pandey";

}

}

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

package package1;

public class Maila implements NamingChildrenInterface {

@Override

public String getNames() {

return "Deepen Pandey";

}

}

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

package package1;

public class Kancha implements NamingChildrenInterface {

@Override

public String getNames() {

return "Arun Pandey";

}

}

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

package package1;

public class Naming_Intermediate {

// BAD WAY WHICH IS HIGHLY COUPLING

// Getting First Child

public String myNames(Jetha firstChild) {

return firstChild.getNames() ;

}

// Getting Second Child

public String myNames(Maila secondChild) {

return secondChild.getNames() ;

}

// Getting Third Child

public String myNames(Kancha thirdChild) {

return thirdChild.getNames() ;

}

}

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

package package1;

public class MainActivity {

public static void main(String[] args) {

Naming_Intermediate in = new Naming_Intermediate();

String child1 = in.myNames(new Jetha());

String child2 = in.myNames(new Maila());

String child3 = in.myNames(new Kancha());

System.out.println(child1+"\n"+child2 + "\n"+ child3);

}

}

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

Interface

package package1;

// INTERFACE
//Different class ko common methods harulai INTERFACE create garera rakhna milxa...
// Interface is the PROTOTYPE or just a way to extrace the common abstrace interface
// properties or the method
// In the interface we have to make the method without body which are also known as abstract method.
// Class always IMPLEMENTS the interface and OVERRIDE all it abstract methods
// We can't make an object of the interface


public interface Interface1 {

public void namEmp();
public abstract void workEmp();

}

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

package package1;

public class Class1 implements Interface1 {

public static void main(String[] args) {

}

@Override

public void namEmp() {

}

@Override

public void workEmp() {

}

}

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

package package1;

public class Class2 implements Interface1{

public static void main(String[] args) {

}

@Override

public void namEmp() {

}

@Override

public void workEmp() {

}

}

DifferentType-SameObj

package package1;

public class Class1 {

public String abc() {
System.out.println("Abc Method from Class1");
return "ABCname";
}
}

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

package package1;

public class Class2 extends Class1 {

public String xyz() {

System.out.println("xyz method from Class2");

return "xyzNAME";

}

// this abc() method should be commented in first cases

public String abc() {

System.out.println("second abc method from class2");

return "abcFromClass2also";

}

}

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

package package1;

public class main extends Class2 {

// CHANGE DATATYPE

// Create an object using another OBJECT TYPE     Ex:  ClassA() objB = new ClassB();

// We can use the type of SuperClass to make the object of the sub class Example: above line

// Case 1:

// Suppose three calsses ClassA ClassB ClassC and 

// B extends A and nnnnnnn C extends B

// In A create methodClassA and create methodClassB in classB

// Now make Ex:  ClassA() objB = new ClassB(); in classC main method and try to fetch the method !!

// We can only fetch method from classA not from ClassB 

// so the output will be print only from the methodClassA of ClassA

// Case 2:

// Suppose three calsses ClassA ClassB ClassC and 

// B extends A and nnnnnnn C extends B

// In A create methodClassA and create methodClassB and methodClassA in classB

// Now make Ex:  ClassA() objB = new ClassB(); in classC main method and try to fetch the method !!

// We can now fetch method from classB not from ClassA

// so the output will be print only from the methodClassB of ClassB

public static void main(String[] args) {

Class2 clas2 = new Class2();

// Print the return syso result as well as return string

System.out.println("---------------------------------------------");

System.out.println(clas2.xyz());

System.out.println("---------------------------------------------");

System.out.println("\n--------------------no another abc() method-------------------------");

// Suppose in this case there is no another abc() method in the Class2 ,

// then the output will show from the abc() method from the class 1

Class1 c2obj = new Class2();

c2obj.abc();

System.out.println("\n-----------------another abc() method i class2 also---------------------");

// Suppose in this case there is an another abc() method in the Class2 ,

// then the output will first check abc() method from class2 

// show from the abc() method body from the class 2 as a result

c2obj = new Class2();

c2obj.abc();

}

}

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

Overloading

package package1;

        //METHOD_OVERLOADING: Let us consider three classes ClassA ClassB and ClassC
// ClassB extends ClassA and then ClassC extends ClassB
// And now again consider a public method abc() and abc(with arguments) in
        // both ClassA and ClassB
// and this process(same methodName in different class with and without arguments)
// is called Method OverLoading

public class Class1{

public void methodOfClass1() {
System.out.println("Method_of_class_1");

}
}

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

package package1;

public class Class2 extends Class1{

public void methodOfClass1(String name) {

System.out.println( "Method_of_class_2");

}

public void methodOfClass1(String name,String age) {

System.out.println( name + age + "Method_of_class_2");

}

public void methodOfClass2(String name) {

System.out.println(name + "Method_of_class_2");

}

}

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

package package1;

public class Class3 extends Class2{

public static void main(String[] args) {

Class3 c3 = new Class3();

c3.methodOfClass1();

c3.methodOfClass2("name");

}

}

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

Overriding

public class Class1 {

// METHOD_OVERRIDING: Let us consider three classes ClassA ClassB and ClassC
// ClassB extends ClassA and then ClassC extends ClassB
// And now again consider a public method abc() is in both ClassA and ClassB
// ok now inside main of ClassC make an object of it and try to
// use the abc() method from the super class
                // <<BOTH SUPER CLASSES HAVE SAME METHOD>>
// As a result we will  get the output from the ClassB syso
//<<A bit like priority based (checkout method from ClassB) >>

public void abcd() {
System.out.println("This the SYSO from CLASS_1");
}

public static void main(String[] args) {

}
}

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

public class Class2 extends Class1{

public void xyz() {

System.out.println("THIS IS SYSO FROM CLASS_2");

}

public void abcd() {

System.out.println("THIS IS SYSO FROM CLASS_2");

}

}

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

public class Class3 extends Class2 {

public static void main(String[] args) {

Class3 c3 = new Class3();

c3.abcd();

}

}

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

Multilevel Inheritance

package package1;

// Multi-level Inheritance: It means,
// Let us consider a Class_A Class_B and CLass_C.
// Class_B extends Class_A which means all properties of Class_A and
// Class_C extends Class_B which means all properties of
// Class_B as well as all properties of Class_A
// This way of inheritance is called Multilevel Inheritance

public class Class1 {

public String nameClass1;

public static void main(String[] args) {

}
}

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

package package1;

public class Class2 extends Class1{

public String nameCLass2;

public static void main(String[] args) {

}

}

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

package package1;

public class Class3 extends Class2{

public static void main(String[] args) {

Class3 c3 = new Class3();

c3.nameClass1 = "namePropertyOfClass1";

c3.nameCLass2 = "namePropertyOfClass2";

System.out.println(c3.nameClass1);

System.out.println(c3.nameCLass2);

}

}

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

Inheritance

package inhertance;

public class SuperCLass {

public String name;

public static void main(String[] args) {


}
}

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

package inhertance;

// INHERITANCE: Inheritance is used to inherit the properties and methods from super class to its child class

public class SubClass extends SuperCLass{

public String classes;

public static void main(String[] args) {

SuperCLass sup = new SuperCLass();

sup.name = "binn";

SubClass sub = new SubClass();

sub.name = "This is the inherit properties from parent";

sub.classes = "This is its own property";

System.out.println(sub.name);

System.out.println(sub.classes);

}

}

StringBuilder/Tokenizer

import java.util.StringTokenizer;

//  STRINGS and STRING BUILDER and STRING BUFFER

public class ClassA {

public static void main(String[] args) {

System.out.println("-----STRING CASE: This create two object-----");
String str = new String("Ram");
str.concat("Hari");
  // Here if we don't assign the value to str we get the output Ram only

str = str.concat("Hari");
System.out.println(str);

System.out.println("\nSTRING BUILDER CASE:  -----This create only one object-----");

StringBuilder strBui = new StringBuilder("Ram");
strBui.append("Hari");
   // Here we don't have to assign the value to strBui cause it directly appends to the same object

System.out.println(strBui);

System.out.println("\nStringBuilder and StringBuffer do the same job but different is that                StringBuffer is synchronized which is thread safe");

System.out.println("\nSTRING TOKENIZER CASE:  -----This create only one object-----");
StringTokenizer st = new StringTokenizer("This is Java class");

//StringTokenizer st = new StringTokenizer("This is Java class","i");
  //Break the value from "i"

while(st.hasMoreElements()){
System.out.println(st.nextElement());
}
}
}

HashMap

import java.util.HashMap;
import java.util.Map;


// HASH MAP
// Value can be set using KEY and VALUE pairs
//

public class ClassHasMap {

public static void main(String[] args) {

System.out.println("\n-----------Using String----------");
Map<String , String> map = new HashMap<>();
map.put("KEY_1", "value Of key one");
map.put("KEY_2", "Value of key 2");

System.out.println(map.get("KEY_1"));

System.out.println("\n-----------Using INTEGER----------");

Map<Integer,  String> map2 = new HashMap<Integer, String>();
map2.put(1, "value Of key one");
map2.put(2, "Value of key 2");

System.out.println(map2.get(1));

System.out.println("\n-----------Using ITERATION----------");
Map<String , String> map3 = new HashMap<>();
map3.put("KEY_1", "value Of key one");
map3.put("KEY_2", "Value of key 2");

for(Object k: map3.keySet()){
System.out.println(k + " "+ map3.get(k));
}
}
}