From d0cfe5b6bdfb763323dd8284beb581341febfe29 Mon Sep 17 00:00:00 2001
From: Harsh Soni <algebra.soni@gmail.com>
Date: Mon, 18 Mar 2024 10:09:55 +0000
Subject: [PATCH 1/2] hack evm

---
 HackEVM.java | 98 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 98 insertions(+)
 create mode 100644 HackEVM.java

diff --git a/HackEVM.java b/HackEVM.java
new file mode 100644
index 0000000..f3af4c2
--- /dev/null
+++ b/HackEVM.java
@@ -0,0 +1,98 @@
+import java.util.Scanner;
+
+public class HackEVM {
+    private static int votesA = 0;
+    private static int votesB = 0;
+    private static int votesC = 0;
+    private static int totalVotes = 0;
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+
+        while (true) {
+            System.out.println("1. Cast Vote");
+            System.out.println("2. Count Votes of Individual");
+            System.out.println("3. Count All Votes");
+            System.out.println("4. Generate Report");
+            System.out.println("5. Exit");
+            System.out.print("Choose an option: ");
+            int choice = scanner.nextInt();
+
+            switch (choice) {
+                case 1:
+                    castVote();
+                    break;
+                case 2:
+                    countVotesOfIndividual();
+                    break;
+                case 3:
+                    countAllVotes();
+                    break;
+                case 4:
+                    generateReport();
+                    break;
+                case 5:
+                    System.exit(0);
+                default:
+                    System.out.println("Invalid choice. Please choose a valid option.");
+            }
+        }
+    }
+
+    private static void castVote() {
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Enter the candidate (A/B/C): ");
+        String candidate = scanner.nextLine().toUpperCase();
+
+        if (!candidate.equals("A") && !candidate.equals("B") && !candidate.equals("C")) {
+            System.out.println("Invalid candidate.");
+            return;
+        }
+
+        if ((totalVotes + 1) % 5 == 0 || (totalVotes + 1) % 7 == 0) {
+            votesB++;
+        } else {
+            switch (candidate) {
+                case "A":
+                    votesA++;
+                    break;
+                case "B":
+                    votesB++;
+                    break;
+                case "C":
+                    votesC++;
+                    break;
+            }
+        }
+
+        totalVotes++;
+        System.out.println("Vote casted for candidate " + candidate);
+    }
+
+    private static void countVotesOfIndividual() {
+        System.out.println("Candidate A has " + votesA + " votes.");
+        System.out.println("Candidate B has " + votesB + " votes.");
+        System.out.println("Candidate C has " + votesC + " votes.");
+    }
+
+    private static void countAllVotes() {
+        System.out.println("Total votes casted: " + totalVotes);
+    }
+
+    private static void generateReport() {
+        System.out.println("Candidates\t|\tVotes\t|\tTotal Votes");
+        System.out.println("---------------------------------------------");
+        System.out.println("A\t\t|\t" + votesA + "\t|\t" + totalVotes);
+        System.out.println("B\t\t|\t" + votesB + "\t|\t" + totalVotes);
+        System.out.println("C\t\t|\t" + votesC + "\t|\t" + totalVotes);
+        System.out.println("---------------------------------------------");
+        System.out.println("Total: " + totalVotes);
+        String winner = getWinner();
+        System.out.println("Winner: " + winner);
+    }
+
+    private static String getWinner() {
+        return (votesA > votesB && votesA > votesC) ? "A" :
+         (votesB > votesA && votesB > votesC) ? "B" : "C";
+    }
+}

From 0470c1121db8f614c3ea142a71c686eb1bc97cc1 Mon Sep 17 00:00:00 2001
From: Harsh Soni <algebra.soni@gmail.com>
Date: Sun, 24 Mar 2024 11:16:24 +0000
Subject: [PATCH 2/2] delete main dir for new branch

---
 About JVM.md           |  45 ---------
 About Java.md          | 102 -------------------
 Abstraction.md         |  31 ------
 Class Overriding.md    |   1 -
 Constructors.md        | 144 ---------------------------
 DataMembers.md         |  22 -----
 Datatype.md            |  42 --------
 HelloJava.class        | Bin 422 -> 0 bytes
 HelloJava.md           | 217 -----------------------------------------
 InitializationBlock.md |  91 -----------------
 Intro.txt              | 168 -------------------------------
 Java keywords.md       |  98 -------------------
 OOPsConcept.md         |  78 ---------------
 README.md              |  13 ---
 conditionals.md        |  41 --------
 inheritance.md         | 139 --------------------------
 loops.md               |  43 --------
 operators.md           | 122 -----------------------
 super_keyword.md       | 104 --------------------
 this_Keyword.md        |  47 ---------
 20 files changed, 1548 deletions(-)
 delete mode 100644 About JVM.md
 delete mode 100644 About Java.md
 delete mode 100644 Abstraction.md
 delete mode 100644 Class Overriding.md
 delete mode 100644 Constructors.md
 delete mode 100644 DataMembers.md
 delete mode 100644 Datatype.md
 delete mode 100644 HelloJava.class
 delete mode 100644 HelloJava.md
 delete mode 100644 InitializationBlock.md
 delete mode 100644 Intro.txt
 delete mode 100644 Java keywords.md
 delete mode 100644 OOPsConcept.md
 delete mode 100644 README.md
 delete mode 100644 conditionals.md
 delete mode 100644 inheritance.md
 delete mode 100644 loops.md
 delete mode 100644 operators.md
 delete mode 100644 super_keyword.md
 delete mode 100644 this_Keyword.md

diff --git a/About JVM.md b/About JVM.md
deleted file mode 100644
index 69321bb..0000000
--- a/About JVM.md	
+++ /dev/null
@@ -1,45 +0,0 @@
-# **JVM (Java Virtual MAchine)**
-
-## JVM is responsible for creating `.class` file and converting each byte code instruction in machine language instruction and that can be executed by micro-processor <br>
-
-.JAVA<br>
-&nbsp;&nbsp;&nbsp;   |<br>
-javac<br>
-&nbsp;&nbsp;&nbsp;   |<br>
-.class (byte code) <br>
-&nbsp;&nbsp;&nbsp;   |<br>
-JVM <br>
-
-![JVM](https://imgr.whimsical.com/object/XJ15gXSMAWE8mTSZmuNHs)
-
-+ First, Java program  (`.java`) is converted by `javac` compiler into `.class` file by `javac` compiler which contains byte code instructions. **This Java compiler is outside of JVM**
-+ Now this `.class` file is given to JVM.
-
-+ **Class Loader Subsystem**
-
-  + In JVM, there is a module called **Class Loader Subsystem** which perform following task
-    + It loads `.class` file into memory then verifies if all the byte code instructions are proper or not. If it find any instruction suspicious then execution is rejected immediately.
-    + If byte code is proper then it allocate the necessary memory to execute the program. This memory is divided into 5 parts called **Run Time Data Areas**
-
-      + **Method area**
-        + This area store `class code`, `method code` of the Java program
-      + **Heap area:**
-        + It stores the object of the program
-      + **Java Stack:**
-        + While running a method, there is a need of some more memory to store temporary data and result. This memory is allocated in Java Stack
-      + **PC Registers**
-        + These are the registers which contain memory address of the instructions of the methods
-      + **Native Method Stack**
-        + All the Native Methods are stored here. Native Methods are those _whose implementation are written in other programming language like C, C++ etc._
-
-+ **Execution Engine**
-  + Execution Engine contains Interpreter and JIT Compiler which are responsible for converting the byte code instructions into Machine Code. In Java, Compiler and Interpreter works together. For simple statements Interpreter is used and for looping statement JIT Compiler is used.
-  + JIT Compiler is a part of JVM which increase the speed for the execution of Java Program
-
-+ **Garbage Collector**
-  + JVM is also capable of deallocating the memory when it is not used.
-  + Suppose a variable or an object is created in memory and if it is not used then after sometime it is automatically removed by the **Garbage Collector**.
-    + **Garbage Collector** is a form of memory management that checks the memory time-to-time and mark the object which are not used and after sometime it deletes them.
-    + Garbage Collector uses **Mark and Sweep Algorithm**.
-    + Garbage Collector is automatically called when the program is being run.
-    + It can also be called explicitly by **GC Method of RunTime Class** or **System Class** in Java.
diff --git a/About Java.md b/About Java.md
deleted file mode 100644
index d071eb9..0000000
--- a/About Java.md	
+++ /dev/null
@@ -1,102 +0,0 @@
-# Table of Content
-[About Java](#About-JAVA☕) <br>
-[Java character set](#Java-character-set) <br>
-[History of Java](#History-of-Java) <br>
-[Features of Java](#Features-of-Java)
-
-# About JAVA☕
-
-+ ### **Father:** James Arthur Gosling aka Dr. Java (1955)
-
-+ ### **Principle:** Simple, Robust, Portable, Platform-independent, Secured, High Performance, Multi-threaded, Architecture Neutral, Object-oriented, Interpreted, and Dynamic
-
-+ ### **Etymology:** Java is an island of Indonesia where first coffee was produced(Java Coffee)
-
-+ ### **Paradigm:** Generic, Object-oriented, Imperative, Reflective
-
-# Java character set
-
-Java uses **Unicode** character set.  </br>
-**65,536** characters are available in Java </br>
-For Example:
-
-+ A: 65 (ASCII for A)
-+ B: 66 (ASCII for B)
-+ A(devanagari): 400  (ASCII)
-+ Aa(devanagari): 401 (ASCII)
-
-# History of Java
-
-+ Java is one of the programming language created for development of distributed applications
-+ Java software is developed at SunMicro Systems by James Arthur Gosling
-+ Java development was started in the year 1990 and completed in the middle of 1991
-+ Guardians of Java
-  + SunMicro System has handed over entire rights of Java to Oracle
-
-### NOTE
-
-+ Java software is available in the form of JDK (Java Development Kit)
-
-+ In the real industry, Java software is present in 3 categories
-  + **J2SE (Java to Standard Edition)**
-    +      used for developing client side applications
-  + **J2EE (Java to Enterprise Edition)**
-    +      used for developing server side applications
-  + **J2ME (Java to Micro Edition)**
-    +      used for developing mobile applications
-
-# Features of Java
-
-### **Simple**
-
-+ Java is simple language and the basic reason behind this is that Java has removed the concept of pointers
-+ Pointers lead to confuse program
-+ Pointer may crash program easily
-+ Pointers may break security
-
-### **Object Oriented**
-
-Java is object oriented which supports features of object oriented language:
-
-+ Features of OOPS
-  + class
-  + object
-  + encapsulation
-  + abstraction
-  + inheritance
-  + polymorphism
-
-### **Robust**
-
-+ Robust means strong; Java programs do not crash easily
-+ There are two reasons behind it:
-+ Java has powerful concept called **Exception handling _(run time problems)_**
-+ Java has in-built memory feature
-+ Most of the C/C++ programs crash in the middle because they are not able to allocate sufficient memory or forget to free the allocated memory.
-+ Such problems are not present in Java because here user need not to allocate/reallocate the memory. Every care would be taken by **JVM(Java Virtual Machine**)
-
-### **Architecture Neutral**
-
-+ Java is **Architecture Neutral Language** because the size of data type is same across the platform
-
-### **Portable**
-
-+ Portable applications are those which can run on each and every Operating System; and each and every processor without considering their vendor.
-
-### **Platform Independent**
-
-+ Java is a Platform Independent Language
-+ `.java` is converted to `.class` file after being compiled.
-+ This `.class` file is then converted to native code of OS
-+ **Note**: JVM is Platform Dependent
-
-### **Multi-Threaded**
-
-+ Thread is a light-weight process.
-+ The basic aim of multi-threading is **to achieve concurrent execution**
-+ **The flow of control in Java is known as Thread**
-+ The purpose of thread is to execute the program
-
-### **Secure**
-
-+ Java program has pre-defined API for security
diff --git a/Abstraction.md b/Abstraction.md
deleted file mode 100644
index e4f246c..0000000
--- a/Abstraction.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# Abstract class in Java (Abstraction)
-
-+ ### `class` which is declared as Abstract is known as an **Abstract Class**
-
-+ ### It can have abstract and non-abstract methods
-
-+ ### We cannot create object of an Abstract class
-
-```java
-abstract class Bike{  // abstract class
-    abstract void run();  // abstract method
-}
-
-class Hero extends Bike{
-    // Error if run() methods is undefined: Hero is not abstract and does not override abstract method run() in Bike
-    void run(){
-        System.out.println("Run from Hero");
-    }
-}
-
-class test{
-    public static void main(String args[]){
-        Hero obj = new Hero();  // object of class Hero created
-        obj.run();  // Output : Run from Hero
-        /* Bike obj2 = new Bike();  // object of abstract class cannot be created
-           obj2.run(); // error: Bike is abstract; cannot be instantiated */
-    }
-}
-```
-
-
diff --git a/Class Overriding.md b/Class Overriding.md
deleted file mode 100644
index b509fa8..0000000
--- a/Class Overriding.md	
+++ /dev/null
@@ -1 +0,0 @@
-# Not added yet 😅 Do it Yourself 😎
\ No newline at end of file
diff --git a/Constructors.md b/Constructors.md
deleted file mode 100644
index 90ad44c..0000000
--- a/Constructors.md
+++ /dev/null
@@ -1,144 +0,0 @@
-# Constructor
-
-## A constructor is a special method which is automatically called by jvm whenever object is created
-
-+ ### Constructor name is same as class name and it should not return any value
-
-+ ### It cannot be static
-
-+ ### constructor may or may not be private
-
-## Types of constructor
-  + ## Default Constructor
-  + ## Parametrized Constructor
-
-## Default constructor
-  + ### There are 2 types of default constructor:
-    + ## System-defined default constructor
-      + ### Whenever we are not creating any constructor in the class, then system will define a constructor called: System-defined defined constructor
-    + ## User-defined default constructor
-      + ### A constructor without any parameter is called User-defined default constructor
-
-```java
-/*Without constructor:System-defined def cons*/
-class Sample{
-    int a, b;
-    void accept(){
-        a = 100;
-        b = 200;
-    }
-    void display(){
-        System.out.println("Value of a: " + a + " Value of b: " + b);
-    }
-}
-class Demo{
-    public static void main(String args[]){
-        Sample obj = new Sample
-        obj.accept()
-        obj.display()  // Value of a: 100 Value of b: 200
-    }
-}
-```
-
-```java
-/*With constructor:User-defined def cons*/
-class Sample{
-    int a, b;
-    Sample(){
-        a = 100;
-        b = 200;
-    }
-    void display(){
-        System.out.println("Value of a: " + a + " Value of b: " + b);
-    }
-}
-class Demo{
-    public static void main(String args[]){
-        Sample obj = new Sample
-        obj.accept()
-        obj.display()  // Value of a: 100 Value of b: 200
-    }
-}
-
-```
-
-```java
-/*Idea.Definition: None*/
-class Demo{
-    public static void main(){
-        sample obj1 = new sample
-        sample obj2 = new sample
-        sample obj3 = new sample
-        obj1.display()
-        obj2.display()
-        obj3.display()
-}
-}
-```
-
-+ ## Parametrized constructor
-
-  + ### A constructor is said to be Parametrized Constructor if it takes arguments or parameters
-
-```java
-class Sample{
-    int a, b;
-    Sample(int x, int y){  // constructor
-        a = x;
-        b = y;
-    }
-    void display(){
-        System.out.println("Value of a: " + a + " Value of b: " + b);
-    }
-}
-class Demo{
-    public static void main(String args[]){
-        Sample obj1 = new Sample(100, 200)  // object
-        Sample obj2 = new Sample(10, 20)  // object
-        // Sample obj3 = new Sample()  // without parameter: error
-        obj1.display();
-        obj2.display();
-
-    }
-}
-```
-
-## Can we overload constructor 🤔
-
-### Constructor is said to be overloaded if Constructor name is same but signature is different
-
-<!-- Assignment: write a program to create a class called BCA which contain 4 constructor: 
-default, single param, two param, 3 param -->
-
-  + ## Object Constructor
-
-    + ### A constructor is said to be object parameter iff it takes object as a parameter
-
-    + ### The purpose of this constructor is to copy content of one source object into another destination object
-
-```java
-class Sample{
-    int a, b;
-    Sample(int x, int y){  // constructor
-        a = x;
-        b = y;
-        System.out.println("Object Parametrized Constructor called!");
-    }
-    Sample(Sample z){
-        a = za;
-        b = zb;
-        System.out.println("Object Parameter");
-    }
-    void display(){
-        System.out.println(a + " and " + b);
-    }
-}
-class Demo{
-    public static void main(String args[]){
-        Sample obj = new Sample(10, 20);
-        Sample obj2 = new Sample(obj);
-        obj.display();
-        obj2.display();
-    }
-}
-```
diff --git a/DataMembers.md b/DataMembers.md
deleted file mode 100644
index 0dd4955..0000000
--- a/DataMembers.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# Types of data members in a class
-
-## In Java programming, data members are classified into 2 types
-
-+ ### Instance/Non-static data member
-
-+ ### Static data member
-
-|Non-Static|Static|
-|------|-----|
-These are the variables whose memory space is created each and every time whenever we create an object | These are the variables whose memory space is created only once whenever the class is loaded in the main memory|
-Instance data members are used to store specific value| static data members are used to store common values|
-Each and every instance data member must be accessed with respect to object name|Each and every data member must be accessed with respect to class name|
-
-## Types of Methods in a class
-
-### There are 2 types of data members in a class
-
-|Non Static Method|Static Method|
-|-|-|
-|These are used for performing repeated operations such as reading the record of for, database etc.|These are recommended to perform one time operation such as opening a file, database etc.|
-|We can access non-static methods wrt object name|We can access static method wrt class name|
\ No newline at end of file
diff --git a/Datatype.md b/Datatype.md
deleted file mode 100644
index a85777f..0000000
--- a/Datatype.md
+++ /dev/null
@@ -1,42 +0,0 @@
-
-# Data Type
-
-## Data type reserve memory for data. They define two things
-
-+ Size
-+ Type
-
-## Datatype in Java
-
-+ byte -> -128 TO 127 (inc)  -> 1 byte
-+ short -> -32,768 TO 32,767 (inc)  -> 2 bytes
-+ long -> 9,223,372,036,854,775,807 TO 9,223,372,036,854,775,807 (inc) [(2^63) TO (2^63)-1]  -> 8 bytes
-+ int -> 2147483647 TO 2147483647 (inc) [(2^31) TO (2^31)-1]  -> 4 bytes
-+ float -> 3.40282347x10^(38) TO 1.40239846x10^(-45) (inc)  -> 4 bytes
-+ char -> '\u0000' OR 0 TO '\uffff' OR 65,535 (inc)  -> 2 bytes
-+ Double -> 1.79769313486x10^(308) TO 4.94065645841x10^(-324) (inc) {default val for decimal values}  -> 8 bytes
-+ boolean ->  true OR false  -> 1 bit
-    key: (inc: included)
-
-### NOTE
-
-+ In Java, there is no signed, unsigned data type because by default here signed is there
-+ Size of data type does not change from one OS to another OS
-+ (byte, short, int, long) belongs to integer type
-+ (Double) belongs to float type
-+ In float, 7 decimal digits after decimal point are displayed
-+ In Double, 15 decimal digits after decimal point are displayed
-+ (char) belongs to character type
-  + In Java, size of char is 2 byte; because of this, it supports large range of characters
-  + In Java, we can use 18 international languages because of large range of characters
-+ (boolean) belongs to boolean type
-  + It is used for storing logical values, i.e. either true or false.
-  + Java Boolean datatype takes 0 byte of main memory space because it is implemented with general purpose register
-        which allows to store 1 bit of information where (1 for true) and (0 for false)
-
-### Default values of data-types (category wise)
-
-+ integer === 0
-+ float === 0.0
-+ character === null
-+ boolean === false
diff --git a/HelloJava.class b/HelloJava.class
deleted file mode 100644
index 0d843afeb17fc4d1fa39f044024df9a3977efeae..0000000000000000000000000000000000000000
GIT binary patch
diff --git a/HelloJava.md b/HelloJava.md
deleted file mode 100644
index 7ad6e59..0000000
--- a/HelloJava.md
+++ /dev/null
@@ -1,217 +0,0 @@
-i# First Program in Java (Hello, Java!)
-
-```java
-// To import everything from package directory-[java >> lang ]
-import java.lang.*;  
-// class name same as that of .java file
-class HelloJava{  
-    // main method
-    public static void main(String args[]){
-        System.out.println("Hello, Java!");
-    }
-}
-```
-
-## Import Statement
-
-### If programmer wants to use any pre-defined class than it should be imported in the program through *import* statement
-
-### Import statement makes the JVM go to the Java Standard Library, execute the code there and substitute the result ito the program
-
-### In this process, no code was copied into source program; hence no wastage of memory and processor time
-
-```powershell
-"""
- To run Program from CLI
- [In: Input] :: [op: Output]
-"""
-[In]    javac HelloJava.java
-[In]    java HelloJava.java
-[op]    Hello Java
-```
-
-## class
-
-### `class` is a keyword which is used for creating user defined datatype. Each and every java program starts its execution from `main()`
-
-### public
-
-+ Since `main()` method can be accessed by every java programme, hence its access specifier must be `public`
-
-### static
-
-+ Since `main()` method is executing only once throughout the life of entire java program and it is not called with any object hence nature of `main()` is static
-
-### void
-
-+ `main()` method doesn't return anything value hence its datatype is `void`
-
-## String args[ ]
-
-### `String` is a class and each and every `main()` method of java takes **array of objects of String class**
-
-## println( )
-
-### `println()` is a predefined method present in predefined class called **PrintStream** class
-
-+ To access `println()` method, we require an object of **PrintStream** class.
-
-+ An object of **PrintStream** class called **`out`** is created by **SunMicro System** in an another predefined class called **`System`** as a static data member.
-
-+ Hence, to access **`println()`** and **`print()`** method, **`System`** class is used
-
-+ In **`System.out.println()`** : **System** is **class**; **out** is **object**; **println()** is method
-
-+ **_`static`_** **`public void main (String args[]){}`** is same as **_`public`_** **`static void main(){}`**
-
-+ **`String args[]`** is same as **`String something_else[]`**
-
-
-## Programme to display value of a variable
-
-```java
-class Display{
-    public static void main(String args[]){
-        int a = 100;
-        System.out.println("Value of a is: " + a);
-    }
-}
-```
-
-### Output
-
-```powershell
-Value of a is: 100
-```
-
-## Programme to display sum of two numbers
-
-```java
-class Sum{
-    public static void main(String args[]){
-        int a = 10;
-        int b = 80;
-        int c = a + b;
-        System.out.println("Sum of" + a "and" + b + "is" + c);
-    }
-}
-```
-
-### Output
-
-```powershell
-Sum of 10 and 80 is 90
-```
-
-### Out of the following classes, the same class will run in the name of which the program has been saved
-
-```java
-class One{
-    public static void main(){
-        class Two{
-            public static void main(){
-                // code here
-            }
-        }
-    }
-}
-```
-
-### A programme can not have Two main( ) methods in single main class
-
-```java
-class Test{
-    public static void main(){
-        System.out.println("First main method");
-    }
-    public static void main(){
-        System.out.println("Second main method");
-    }
-}
-```
-
-### Class is a collection of data member and methods
-
-```java
-// Filename: Demo.java
-class First{
-    int a, b, c;
-    void accept(){
-        a = 100;
-        b = 900;
-    }
-    void sum(){
-        c = a + b;
-    }
-    void display(){
-        System.out.println("Sum is " + c);
-    }
-}
-
-class Demo{
-    public static void main(String args[]){
-        First obj1 = new First();
-        obj.accept();
-        obj.sum();
-        obj.display();
-    }
-}
-
-```
-
-## Another way
-
-```java
-// Filename: Demo.java
-class First{
-    int a, b, c;  // data members
-    void accept(int x, int y){  // (x, y) :: local parameters
-        a = x;
-        b = y;
-    }
-    void sum(){
-        c = a + b;
-    }
-    void display(){
-        return c;
-    }
-}
-
-class Demo{
-    public static void main(String args[]){
-        First obj = new First();
-        obj.accept(99, 1);
-        obj.sum();
-        System.out.println(obj.display());
-    }
-}
-
-```
-
-## Play with Java classes
-
-```java
-class Demo {
-  int x;
-  public static void main (String args[]){
-    System.out.println(x);
-  }
-}
-
-/*
-Output:
-Error... 
-*/
-```
-
-### Note
-
-+ ### 1 non static method can call another static method  directly if both belong to same class
-
-+ ### 1 non static method can call another non static method directly if both belong to same class
-
-+ ### 1 static can call another instance method (non-static) w.r.t. object
-
-+ ### 1 instance method can call another static method directly if both belong to same class
-
-  + ### If both methods are from different class, then calling will be w.r.t. class name
diff --git a/InitializationBlock.md b/InitializationBlock.md
deleted file mode 100644
index b0a4f00..0000000
--- a/InitializationBlock.md
+++ /dev/null
@@ -1,91 +0,0 @@
-# Initialization
-
-## There are 2 types of initialization block
-
-+ ### Instance Initialization Block
-
-  + ### For every object creation **Instance Initialization Block** will be created
-
-```java
-class A{
-    static int count;
-    A(){
-        System.out.println("default");
-    }
-    {
-        count++;
-        System.out.println("instance block");
-    }
-    A(int x){
-        //
-    }
-    A(int x, int y){
-        //
-    }
-    void display(){
-        System.out.println(count);
-    }
-}
-class Demo{
-    public static void main(String args[]){
-        A obj = new A();  // default constructor
-        A obj2 = new A(100);  // single param
-        A obj3 = new A(100, 200);  // double param
-        obj3.display();
-    }
-}
-/* Output
-instance block
-default
-instance block
-instance block
-3
-*/
-```
-
-### We can have more than one initialization block
-
-+ ### Static Initialization Block
-
-  + ### Whenever class is loaded in memory then static initialization block will be created
-
-  + ### Whenever we call any executable block then class is loaded in memory
-
-```java
-class A{
-    static int count;
-    A(){
-        System.out.println("default");
-    }
-    {
-        count++;
-        System.out.println("instance block");
-    }
-    A(int x){
-        //
-    }
-    A(int x, int y){
-        //
-    }
-    static{
-        System.out.println("static block");
-    }
-    // void display(){
-    //     System.out.println(count);
-    // }
-}
-class Demo{
-    public static void main(String args[]){
-        A obj = new A();  // default constructor
-        A obj2 = new A(100);  // single param
-        // A obj3 = new A(100, 200);  // double param
-        // obj3.display();
-    }
-}
-/* Output
-static block
-instance block
-default
-instance block
-*/
-```
diff --git a/Intro.txt b/Intro.txt
deleted file mode 100644
index 99c9bac..0000000
--- a/Intro.txt
+++ /dev/null
@@ -1,168 +0,0 @@
-JAVA:
-    Father: James Arthur Gosling aka Dr. Java (1955)
-    Principle: Simple, Robust, Portable, Platform-independent, Secured, 
-        High Performance, Multithreaded, Architecture Neutral, Object-oriented, Interpreted, and Dynamic
-    Etymology: Java is an island of Indonesia where first coffee was produced(Java Coffee)
-    Paradigm: Generic, Object-oriented, Imperative, Reflective
-
-
-Java character set: (65,556)
-        >  Unicode
-           A: 65
-           B: 66
-           A(devnagri): 400
-           Aa(devnagri): 401 
-
-
-
-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-Java reserved words:-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
-
-        keywords                        reserved literals
-___________|____________               (true, false, null)
-|                       |
-Used keywords       unused keywords
-                    (goto, const)
-
-
-*-*-*-*-*-*-*-*-*-*-Keywords related to data types-*-*-*-*-*-*-*-*-*-*
--> byte -> -128 TO 127 (inc)
--> int -> 2147483647 TO 2147483647 (inc) [(2^31) TO (2^31)-1]
--> float -> 3.40282347x10^(38) TO 1.40239846x10^(-45) (inc)
--> long -> 9,223,372,036,854,775,807 TO 9,223,372,036,854,775,807 (inc) [(2^63) TO (2^63)-1]
--> char -> '\u0000' OR 0 TO '\uffff' OR 65,535 (inc)
--> Double -> 1.79769313486x10^(308) TO 4.94065645841x10^(-324) (inc) {default val for decimal values}
--> boolean ->  true OR false
--> short -> -32,768 TO 32,767 (inc)
-
-*-*-*-*-*-*-*-*-*-*-Keywords related to control structure-*-*-*-*-*-*-*-*-*-*
-if
-else
-break
-continue
-while
-do
-for
-switch
-case
-default
-
-*-*-*-*-*-*-*-*-*-*-Keywords related to modifiers-*-*-*-*-*-*-*-*-*-*
-public
-private
-protected
-abstract
-final
-static
-transient
-volatile
-synchronized
-
-*-*-*-*-*-*-*-*-*-*-Keywords related to classes-*-*-*-*-*-*-*-*-*-*
-class
-interface
-enum
-
-*-*-*-*-*-*-*-*-*-*-Keywords related to inheritance-*-*-*-*-*-*-*-*-*-*
-extends
-implements
-
-*-*-*-*-*-*-*-*-*-*-Keywords related to package-*-*-*-*-*-*-*-*-*-*
-package
-import
-
-*-*-*-*-*-*-*-*-*-*-Keywords related to exceptional handelling-*-*-*-*-*-*-*-*-*-*
-try
-catch
-throw
-finally
-
-*-*-*-*-*-*-*-*-*-*-Keywords related to references-*-*-*-*-*-*-*-*-*-*
-this
-super
-
-
-*-*-*-*-*-*-*-*-*-*-NOTE-*-*-*-*-*-*-*-*-*-*
-goto is unused keyword because
-    goto makes program unstructured
-    goto never lets program to stored in cache
-    if goto is used in program then it will not work with cache memory
-
-
-*-*-*-*-*-*-*-*-*-*-Identifiers-*-*-*-*-*-*-*-*-*-*
-> Identifiers are user defined words. 
-> In Java, Identifiers contain alphabets, digits, and two special char ($, _)
-> Rules for naming identifiers :
-        > Class name should start with capital letter (PascalNotation)
-            > If class name have multiple words, then saparate with capital letters
-        > Variable names should start with small letters (var)
-            > If variable name has multiple words, then saparate with capital letter (varName)
-        > Method name should start with small letter
-            > If method name has multiple word then saparate with cpital letters
-        > Constant name must be given in capital letters
-            > If constant name has multiple word, saparate with underscore(_)
-
-
-*-*-*-*-*-*-*-*-*-*-Data Type-*-*-*-*-*-*-*-*-*-*
-Data type reserve memory for data. They define two things:
-    > Size 
-    > Type
-Datatype in Java
--> byte -> -128 TO 127 (inc)  -> 1 byte
--> short -> -32,768 TO 32,767 (inc)  -> 2 bytes
--> long -> 9,223,372,036,854,775,807 TO 9,223,372,036,854,775,807 (inc) [(2^63) TO (2^63)-1]  -> 8 bytes
--> int -> 2147483647 TO 2147483647 (inc) [(2^31) TO (2^31)-1]  -> 4 bytes
--> float -> 3.40282347x10^(38) TO 1.40239846x10^(-45) (inc)  -> 4 bytes
--> char -> '\u0000' OR 0 TO '\uffff' OR 65,535 (inc)  -> 2 bytes
--> Double -> 1.79769313486x10^(308) TO 4.94065645841x10^(-324) (inc) {default val for decimal values}  -> 8 bytes
--> boolean ->  true OR false  -> 1 bit
-    key: (inc: included)
-
-*-*-*-*-*-*-*-*-*-*-NOTE-*-*-*-*-*-*-*-*-*-*
-> In Java, there is no signed, unsigned data type because by default here signed is there
-> Size of data type does not change from one OS to another OS
-> (byte, short, int, long) belongs to integer type
-> (Double) belongs to float type
-    > In float, 7 decimal digits after decimal point are displayed
-    > In Double, 15 decimal digits after decimal point are displayed
-> (char) belongs to character type
-    > In Java, size of char is 2 byte; because of this, it supports large range of characters
-    > In Java, we can use 18 international languages because of large range of characters
-> (boolean) belongs to boolean type
-    > It is used for storing logical values, i.e. either true or false.
-    > Java Boolean datatype takes 0 byte of main memory space because it is implemented with general purpose register
-        which allows to store 1 bit of information where (1 for true) and (0 for false)
-
-Default values of datatypes (category wise)
-integer === 0
-float === 0.0
-character === null
-boolean === false
-
-Type of Applications
-    Standalone Applications 
-        These are applications which run on the local disk and whose results are not sharable. 
-        All the applications of system software are example of standalone applications.
-    Distributed Applications
-        These are the applications which run in the context of browser/server and whose
-        results are sharable across the globe.
-        E.g.: google.com, gmail.com, yahoo.com, Zoom app
-    
-History of Java
-    Java is one of the programming language created for development of distributed applications
-    Java software is developed at SunMicro Systems by James Arthur Gosling
-    Java development was started in the year 1990 and completed in the middle of 1991
-Guardians of Java
-    SunMicro System has handed over entire rights of Java to Oracle
-In the real industry, Java software is present in 3 categories:
-    > J2SE (Java to Standard Edition)
-        used for developing client side applications
-    > J2EE (Java to Enterprise Edition)
-        used for developing server side applications
-    > J2ME (Java to Micro Edition)
-        used for developing mobile applications
-
-NOTE
-Java software is available in the form of JDK (Java Development Kit)
-
-
-
diff --git a/Java keywords.md b/Java keywords.md
deleted file mode 100644
index 8de51c9..0000000
--- a/Java keywords.md	
+++ /dev/null
@@ -1,98 +0,0 @@
-
-# Java reserved words
-
-<pre>
-        keywords                        reserved literals
-___________|____________               (true, false, null)
-|                       |
-Used keywords       unused keywords
-                    (goto, const)
-
-</pre>
-
-## Keywords related to data types
-
-+ byte -> -128 TO 127 (inc)
-+ int -> 2147483647 TO 2147483647 (inc) [(2^31) TO (2^31)-1]
-+ float -> 3.40282347x10^(38) TO 1.40239846x10^(-45) (inc)
-+ long -> 9,223,372,036,854,775,807 TO 9,223,372,036,854,775,807 (inc) [(2^63) TO (2^63)-1]
-+ char -> '\u0000' OR 0 TO '\uffff' OR 65,535 (inc)
-+ Double -> 1.79769313486x10^(308) TO 4.94065645841x10^(-324) (inc) {default val for decimal values}
-+ boolean ->  true OR false
-+ short -> -32,768 TO 32,767 (inc)
-
-## Keywords related to control structure
-
-+ if
-+ else
-+ break
-+ continue
-+ while
-+ do
-+ for
-+ switch
-+ case
-+ default
-
-## Keywords related to modifiers
-
-+ public
-+ private
-+ protected
-+ abstract
-+ final
-+ static
-+ transient
-+ volatile
-+ synchronized
-
-## Keywords related to classes
-
-+ class
-+ interface
-+ enum
-
-## Keywords related to inheritance
-
-+ extends
-+ implements
-
-## Keywords related to package
-
-+ package
-+ import
-
-## Keywords related to exceptional handelling
-
-+ try
-+ catch
-+ throw
-+ finally
-
-## Keywords related to references
-
-+ this
-+ super
-
-### NOTE
-
-#### goto is unused keyword because
-
-+ goto makes program unstructured
-+ goto never lets program to stored in cache
-+ if goto is used in program then it will not work with cache memory
-
-## Identifiers
-
-### Identifiers are user defined words
-
-+ In Java, Identifiers contain alphabets, digits, and two special char ($, _)
-+ Rules for naming identifiers :
-  + Class name should start with capital letter (PascalNotation)
-    + If class name have multiple words, then separate with capital letters
-  + Variable names should start with small letters (var)
-    + If variable name has multiple words, then separate with capital letter (varName)
-  + Method name should start with small letter
-    + If method name has multiple word then separate with capital letters
-  + Constant name must be given in capital letters
-    + If constant name has multiple word, separate with underscore(_)
diff --git a/OOPsConcept.md b/OOPsConcept.md
deleted file mode 100644
index c771c29..0000000
--- a/OOPsConcept.md
+++ /dev/null
@@ -1,78 +0,0 @@
-# Encapsulation
-
-## Wrapping of data and methods in a single unit is called **Encapsulation**
-
-```java
-class Sample{
-    int x = 10;
-    int y = 20;
-}
-
-class Demo{
-    public static void main(String args[]){
-        Sample obj = new Sample();
-        System.out.println(obj.x);
-        System.out.println(obj.y);
-    }
-}  // output: 10 20
-```
-
-### A class is called encapsulated if all the data members are private and setter and getter methods are available for all the data members
-
-```java
-class Sample{
-    private int x = 10;
-    private int y = 20;
-
-    void setX(int a){
-        x = a;
-    }
-    void setY(int b){
-        y = b;
-    }
-    int getX(){
-        return x;
-    }
-    int getY(){
-        return y;
-    }
-}
-
-class Demo{
-    public static void main(String args[]){
-        Sample obj = new Sample();
-        obj.setX(100);
-        obj.setY(200);
-        System.out.println(obj.getX());
-        System.out.println(obj.getY);
-        // System.out.println(obj.x);  // would through an error
-    }
-}  // output: 100 200
-```
-
-<!-- Wap to create a class called Student which contain 3 data members {ID, marks, mobile number}. This class must be
-encapsulated. -->
-
-# POLYMORPHISM
-
-## writing the method with same name by changing the signature is called method overloading
-
-### Signature means either no of param or types of param or order of param
-
-```java
-class Sample{
-    void fun1(int a){
-        System.out.println("This is fun1");
-    }
-    void fun1(int a, int b){
-        System.out.println("This is fun2");
-    }
-}
-
-class main{
-    public static void main(String args[]){
-        sample1 obj = obj.fun1(100);
-        sample1 obj = obj.fun1(200, 300);
-    }
-}
-```
diff --git a/README.md b/README.md
deleted file mode 100644
index c6081a6..0000000
--- a/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# Learn Java
-
-## Handy Digital Notes for Learning Java
-
-&nbsp;
-
-# Contribution
-
-## Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change
-
-<hr>
-
-<h1 align="center">Thanks for being here<a href="http://harshsoni.me/Portfolio2022" target="blank">Code blooded animals</a> !
diff --git a/conditionals.md b/conditionals.md
deleted file mode 100644
index e710dbd..0000000
--- a/conditionals.md
+++ /dev/null
@@ -1,41 +0,0 @@
-# Java `if... else...` statement
-
-## Java if statement is used to test the condition
-
-```java
-// program to check if the age is greater than 18
-
-class conditional{
-    public static void main(){
-        int age = 20;
-        if (age > 18){
-            System.out.Println("Age is greater than 18");
-        }
-    }
-}
-```
-
-### Write a program to find greatest of two numbers using if...else
-
-```java
-// Program to find greatest of two number
-
-class Greater{
-    public static void main(String args[]){
-        int a = 10;
-        int b = 20;
-        
-        if (a > b){
-            System.out.println("a is greater");
-        } else {
-            System.out.println("b is greater");
-        }
-    }
-}
-```
-
-## Programs ToDo
-
-### Write a program to find greatest of 3 numbers using nested if...else... <br>
-
-### Write a program to find greatest of 3 numbers using else if ladder
diff --git a/inheritance.md b/inheritance.md
deleted file mode 100644
index a8ecc10..0000000
--- a/inheritance.md
+++ /dev/null
@@ -1,139 +0,0 @@
-# Inheritance in Java
-
-## The mechanism of getting the data members and methods of base class into derived class is called **Inheritance**
-
-## Syntax
-
-```java
-class ChildClassName extends BaseClassName
-```
-
-## `extends` is a keyword used for inheriting the features of base class into child class
-
-```java
-// inheriting properties of class A into class B
-class A{
-    // code here
-}
-class B extends A{
-    // code here
-}
-```
-
-## Multiple inheritance in Java is not allowed
-
-```java
-// Multiple inheritance in Java is not allowed
-class A{
-    // code here
-}
-class B{
-    // code here
-}
-class C extends A, B{  // !ERROR!
-    // code here
-}
-```
-
-### The above program gives an error because multiple inheritance is not supported
-
-+ ### If you don't want to give the features of BaseClass to the DerivedClass then the definition of the BaseClass must be made as Final. Hence, Final class never participates in Inheritance
-
-```java
-final class A{
-    // code here
-}
-class B extends A{
-    // code here
-}  // Error: final class cannot be inherited
-```
-
-+ ### If you don't want to give some of the features to the ChildClass then it should be made `private`
-
-```java
-class A{
-    private int dataMember;
-}
-class B extends A{
-    // code here
-}  // var dataMember of class A can't be accessed by class B, being private
-```
-
-### **Note:** For every class of Java, there exists some predefined SuperClass whose name is called `java.lang.object`
-
-+ ### The object class provides the garbage collection facility and many other functions to its sub-classes
-
-```java
-class A{
-    int a;
-    void display(){
-        System.out.println("Base Class");
-    }
-}
-class B extends A{
-    int b;
-    void display1(){
-        System.out.println("Derived Class");
-        a = 100;
-        b = 200;
-        System.out.println(a + b));
-    }
-}
-class Demo{
-    public static void main(String args[]){
-        B obj = new B();
-        obj.display();
-        obj.display1();
-        /* ParentClass can't access ChildClass properties
-        A obj = new A();
-        obj.display();
-        obj.display1();  // Error!
-        */
-    }
-}  // Output: Base Class \n Derive Class \n 300
-```
-
-## Types if Inheritance
-
-+ ### rt
-
-+ ### rty
-
-+ ### Hierarchical Inheritance
-
-+ ### Hybrid Inheritance
-
-### Note: **Multiple Inheritance** in not supported in Java
-
-```java
-// Multiple Inheritance in Java
-class A{
-    int a;
-    display(){
-        a = 100;
-        System.out.println(a);
-    }
-}
-class B extends A{
-    int b;
-    display2(){
-        b = 100;
-        System.out.println(b);
-    }
-}
-class C extends B{
-    int c;
-    display3(){
-        c = 100;
-        System.out.println(c);
-    }
-}
-class Demo{
-    public static void main(String args[]){
-        C obj = new C();
-        obj.display();
-        obj.display2();
-        obj.display3();
-    }
-} // Output 100 \n 100 \n 100
-```
diff --git a/loops.md b/loops.md
deleted file mode 100644
index ac21652..0000000
--- a/loops.md
+++ /dev/null
@@ -1,43 +0,0 @@
-# write a program to print numbers from 1 to 10 using `for loop`
-
-```java
-class OneTOTen{
-    public static void main(String args[]){
-
-        for (int i = 1; i<10; i++){
-            System.out.println(i);
-        }
-    }
-}
-```
-
-Write a program to display numbers from 1 to 10 using while loop and do while loop
-Reading of for, while, do while loop from java T point
-
-# foreach loop
-
-## for-each loop is used to traverse array or collection in Java
-
-+ ### It is easier to use than simple for loop because we do not need to increment the value
-
-+ ### It works on element basis
-
-+ ### It returns element one-by-one in the defined variable
-
-```java
-class ForEach{
-    public static void main(){
-        int arr[] = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
-
-        for(int i : arr){
-            System.out.println(i);
-        }
-    }
-}
-```
-
-## ToDo
-
-### write a prog to check if the given no is prime or not in java
-
-### write a prog to check given no is armstrong or not
diff --git a/operators.md b/operators.md
deleted file mode 100644
index a53c384..0000000
--- a/operators.md
+++ /dev/null
@@ -1,122 +0,0 @@
-# Operators in Java
-
-## Types of Operators in Java
-
-+ ### Unary Operator
-  + ### Increment Operator
-  + ### Decrement Operator
-+ ### Arithmetic Operator
-+ ### Shift Operator
-+ ### Relational Operator
-+ ### Bitwise Operator
-+ ### Logical Operator
-+ ### Ternary Operator
-+ ### Assignment Operator
-
-# Operator
-
-| Operator   | Category             | Precedence                              |
-|------------|----------------------|-----------------------------------------|
-| Unary      | postfix              | expr++ expr--                           |
-|            | prefix               | ++expr --expr +expr -expr ~ !           |
-| Arithmetic | multiplicative       | * / %                                   |
-|            | additive             | + -                                     |
-| Shift      | shift                | << >> >>>                               |
-| Relational | comparison           | < > <= >= instanceof                    |
-|            | equality             | == !=                                   |
-| Bitwise    | bitwise AND          | &                                       |
-|            | bitwise exclusive OR | ^                                       |
-|            | bitwise inclusive OR | \|                                      |
-| Logical    | logical AND          | &&                                      |
-|            | logical OR           | \|\|                                    |
-| Ternary    | ternary              | ? :                                     |
-| Assignment | assignment           | = += -= *= /= %= &= ^= \|= <<= >>= >>>= |
-
-## Increment/Decrement Operator
-
-```java
-class Demo(){
-    public static void main(){
-        int x = 10;
-        System.out.println(x++);
-        System.out.println(++x);
-    }
-    /* Output:
-    10
-    12
-    */
-}
-```
-
-## Arithmetic Operators
-
-Arithmetic Operators are:
-
-+ Addition`+`
-+ Subtraction `-`
-+ Multiplication `*`
-+ Division `/`
-+ Modulus `%`
-
-```java
-class Arithmetic{
-    public static void main(){
-        int a = 10;
-        int b = 5;
-        System.out.println(a+b);
-        System.out.println(a-b);
-        System.out.println(a*b);
-        System.out.println(a/b);
-        System.out.println(a%b);
-    }
-    /* Output:
-    15
-    5
-    50
-    2
-    0
-    */
-}
-```
-
-## Relational Operator
-
-### Relational operators are **<, >, <=, >=, !=, instanceOf()**
-
-```java
-class Relational{
-    public static void main(String [] args){
-        int a, b, c;
-        a = 10;
-        b = 20;
-        c = 25; 
-        System.out.println(a > b);  // false
-        System.out.println(a < b);  // true
-        System.out.println(a = b);  // 20
-        System.out.println(a != b);  // false
-        System.out.println(a <= b);  // true
-        System.out.println(a >= b);  // true
-    }
-}
-```
-
-## Logical Operators
-
-```java
-class Logical{
-    public static void main(String [] args){
-    // && operator
-    System.out.println((5 > 3) && (8 > 5));  // true
-    System.out.println((5 > 3) && (8 < 5));  // false
-
-    // || operator
-    System.out.println((5 < 3) || (8 > 5));  // true
-    System.out.println((5 > 3) || (8 < 5));  // true
-    System.out.println((5 < 3) || (8 < 5));  // false
-
-    // ! operator
-    System.out.println(!(5 == 3));  // true
-    System.out.println(!(5 > 3));  // false
-    }
-}
-```
diff --git a/super_keyword.md b/super_keyword.md
deleted file mode 100644
index 1d3b8b2..0000000
--- a/super_keyword.md
+++ /dev/null
@@ -1,104 +0,0 @@
-# `super` keyword
-
-### `super` is a keyword created by JVM and supplied to each and every Java program to differentiate between BaseClass feature and DerivedClass feature
-
-### If BaseClass feature and DerivedClass feature is same, then `super` keyword is used
-
-## `super` at variable level
-
-### If data member of BaseClass and DerivedClass are same then JVM gets an ambiguity. To solve the above problem `super` keyword is used
-
-```java
-class A{
-    int a;
-}
-class B extends A{
-    int a;
-    int b;
-    void set(int x, int y){
-        // a = x;  // base class variable
-        super.a = x;  // parent class variable
-        a = y;  // child class variable
-    }
-    void add(){
-        // b = a + a;  // adds the a's of 
-        b = super.a + a;  // ParentClassVar + ChildClassVar
-        System.out.println(b);
-    }
-}
-class Demo{
-    public static void main(String args[]){
-        B obj = new B();
-        obj.set(100, 200);
-        obj.add();
-    }
-}
-```
-
-## `super` at method level
-
-```code here```
-
-## `super` at constructor level
-
-### Whenever we create an object of ChildClass then first memory space for BaseClass is created
-
-### First the data member of BaseClass will be initialized then data member of ChildClass will be initialized
-
-### So, constructor of BaseClass is executed first and then constructor of ChildClass would be executed
-
-```java
-class A{  // constructor
-    A(){
-        System.out.println("Base Class");
-    }
-}
-class B extends A{
-    B(){
-        System.out.println("Child Class");
-    }
-}
-class Demo{
-    public static void main(String args[]){
-        B obj = new B();
-    }
-}
-```
-
-```java
-class A{
-    A(){
-        System.out.println("Base default");
-    }
-    A(int a){
-        System.out.println("Base Class Parameter");
-    }
-class B extends A{
-    B(){
-        Super(100);
-        System.out.println("Child default");
-    }
-    B(int a){
-        this(100, 200)
-        System.out.println("Child single parameter");
-    }
-    B(int x, int y){
-        System.out.println("Child double parameter");
-    }
-
-}
-}
-class Demo{
-    public static void main(String args[]){
-        B obj = new B(100);
-        B obj = new B();
-    }
-}
-/* Output
-Base default
-Child double parameter
-Child single parameter
-Base Class Parameter
-Child default
-*/
-```
diff --git a/this_Keyword.md b/this_Keyword.md
deleted file mode 100644
index 4613e83..0000000
--- a/this_Keyword.md
+++ /dev/null
@@ -1,47 +0,0 @@
-# `this` Keyword
-
-```java
-// Programme without this keyword
-class Sample{
-    int a, b;
-    Sample(int a, int b){  // constructor
-        a = a;
-        b = b;
-    }
-    void display(){
-        System.out.println("a is " + a + " b is " + b);
-    }
-}
-class Demo{
-    public static void main(String args[]){
-        Sample obj = new Sample(100, 200);  // object of class Sample
-        obj.display();
-    }  // Output: a is 0 b is 0
-}
-```
-
-### In the above example, data members of a class are not initialized because the name of local variable and data members are same. To solve the above problem, `this` keyword is used
-
-+ ## `this` is a keyword created by JVM and supplied to each and every java program
-
-+ ## `this` keyword is used to point current class object whenever the formal parameter and data member of the class are same
-
-```java
-// Programme with this keyword
-class Sample{
-    int a, b;
-    Sample(int a, int b){  // constructor
-        this.a = a;
-        this.b = b;
-    }
-    void display(){
-        System.out.println("a is " + a + " b is " + b);
-    }
-}
-class Demo{
-    public static void main(String args[]){
-        Sample obj = new Sample(100, 200);  // object of class Sample
-        obj.display();
-    }  // Output: a is 100 b is 200
-}
-```
