<h2>Basics</h2>
<p>Basic syntax and functions from the Java programming language.</p>
<h3>Boilerplate</h3>
<pre class="language-java"><code>class HelloWorld{ 
public static void main(String args[]){ 
System.out.println("Hello World"); 
} 
}</code></pre>
<h3>Showing Output</h3>
<p>It will print something to the output console.</p>
<pre class="language-java"><code>System.out.println([text])</code></pre>
<h3>Taking Input</h3>
<p>It will take string input from the user</p>
<pre class="language-java"><code>import java.util.Scanner; //import scanner class

// create an object of Scanner class
Scanner input = new Scanner(System.in);

// take input from the user
String varName = input.nextLine();</code></pre>
<h2>Primitive Type Variables</h2>
<p>The eight primitives defined in Java are int, byte, short, long, float, double, boolean, and char those aren't considered objects and represent raw values.</p>
<h3>byte</h3>
<p>byte is a primitive data type it only takes up 8 bits of memory.</p>
<pre class="language-java"><code>age = 18;</code></pre>
<h3>long</h3>
<p>long is another primitive data type related to integers. long takes up 64 bits of memory.</p>
<pre class="language-java"><code>viewsCount = 3_123_456L;</code></pre>
<h3>float</h3>
<p>We represent basic fractional numbers in Java using the float type. This is a single-precision decimal number. Which means if we get past six decimal points, this number becomes less precise and more of an estimate.</p>
<pre class="language-java"><code>price = 100INR;</code></pre>
<h3>char</h3>
<p>Char is a 16-bit integer representing a Unicode-encoded character.</p>
<pre class="language-java"><code>letter = 'A';</code></pre>
<h3>boolean</h3>
<p>The simplest primitive data type is boolean. It can contain only two values: true or false. It stores its value in a single bit.</p>
<pre class="language-java"><code>isEligible = true;</code></pre>
<h3>int</h3>
<p>int holds a wide range of non-fractional number values.</p>
<pre class="language-java"><code>var1 = 256;</code></pre>
<h3>short</h3>
<p>If we want to save memory and byte is too small, we can use short.</p>
<pre class="language-java"><code>short var2 = 786;</code></pre>
<h2>Comments</h2>
<p>A comment is the code that is not executed by the compiler, and the programmer uses it to keep track of the code.</p>
<h3>Single line comment</h3>
<pre class="language-java"><code>// It's a single line comment</code></pre>
<h3>Multi-line comment</h3>
<pre class="language-java"><code>/* It's a 
multi-line
comment
*/</code></pre>
<h2>Constants</h2>
<p>Constants are like a variable, except that their value never changes during program execution.</p>
<pre class="language-java"><code>final float INTEREST_RATE = 0.04;</code></pre>
<p>&lt;|AD|&gt;</p>
<h2>Arithmetic Expressions</h2>
<p>These are the collection of literals and arithmetic operators.</p>
<h3>Addition</h3>
<p>It can be used to add two numbers</p>
<pre class="language-java"><code>int x = 10 + 3;</code></pre>
<h3>Subtraction</h3>
<p>It can be used to subtract two numbers</p>
<pre class="language-java"><code>int x = 10 - 3;</code></pre>
<h3>Multiplication</h3>
<p>It can be used to multiply add two numbers</p>
<pre class="language-java"><code>int x = 10 * 3;</code></pre>
<h3>Division</h3>
<p>It can be used to divide two numbers</p>
<pre class="language-java"><code>int x = 10 / 3;
float x = (float)10 / (float)3;</code></pre>
<h3>Modulo Remainder</h3>
<p>It returns the remainder of the two numbers after division</p>
<pre class="language-java"><code>int x = 10 % 3;</code></pre>
<h2>Augmented Operators</h2>
<h3>Addition assignment</h3>
<pre class="language-java"><code>var += 10 // var = var + 10</code></pre>
<h3>Subtraction assignment</h3>
<pre class="language-java"><code>var -= 10 // var = var - 10</code></pre>
<h3>Multiplication assignment</h3>
<pre class="language-java"><code>var *= 10 // var = var * 10</code></pre>
<h3>Division assignment</h3>
<pre class="language-java"><code>var /= 10 // var = var / 10</code></pre>
<h3>Modulus assignment</h3>
<pre class="language-java"><code>var %= 10 // var = var % 10</code></pre>
<h2>Escape Sequences</h2>
<p>It is a sequence of characters starting with a backslash, and it doesn't represent itself when used inside string literal.</p>
<h3>Tab</h3>
<p>It gives a tab space</p>
<pre class="language-java"><code>\t</code></pre>
<h3>Backslash</h3>
<p>It adds a backslash</p>
<pre class="language-java"><code>\\</code></pre>
<h3>Single quote</h3>
<p>It adds a single quotation mark</p>
<pre class="language-java"><code>\'</code></pre>
<h3>Question mark</h3>
<p>It adds a question mark</p>
<pre class="language-java"><code>\?</code></pre>
<h3>Carriage return</h3>
<p>Inserts a carriage return in the text at this point.</p>
<pre class="language-java"><code>\r</code></pre>
<h3>Double quote</h3>
<p>It adds a double quotation mark</p>
<pre class="language-java"><code>\"</code></pre>
<h2>Type Casting</h2>
<p>Type Casting is a process of converting one data type into another</p>
<h3>Widening Type Casting</h3>
<p>It means converting a lower data type into a higher</p>
<pre class="language-java"><code>// int x = 45;
double var_name = x;</code></pre>
<h3>Narrowing Type Casting</h3>
<p>It means converting a higher data type into a lower</p>
<pre class="language-java"><code>double x = 165.48
int var_name = (int)x;</code></pre>
<p>&lt;|AD|&gt;</p>
<h2>Decision Control Statements</h2>
<p>Conditional statements are used to perform operations based on some condition.</p>
<h3>if Statement</h3>
<pre class="language-java"><code>if (condition) {
// block of code to be executed if the condition is true
}</code></pre>
<h3>if-else Statement</h3>
<pre class="language-java"><code>if (condition) {
// If condition is True then this block will get executed
} else {
// If condition is False then this block will get executed
}</code></pre>
<h3>if else-if Statement</h3>
<pre class="language-java"><code>if (condition1) {
// Codes
}
else if(condition2) {
// Codes
}
else if (condition3) {
// Codes
}
else {
// Codes
}</code></pre>
<h3>Ternary Operator</h3>
<p>It is shorthand of an if-else statement.</p>
<pre class="language-java"><code>variable = (condition) ? expressionTrue : expressionFalse;</code></pre>
<h3>Switch Statements</h3>
<p>It allows a variable to be tested for equality against a list of values (cases).</p>
<pre class="language-java"><code>switch(expression) {
case a:
// code block
break;
case b:
// code block
break;
default:
// code block
}</code></pre>
<h2>Iterative Statements</h2>
<p>Iterative statements facilitate programmers to execute any block of code lines repeatedly and can be controlled as per conditions added by the coder.</p>
<h3>while Loop</h3>
<p>It iterates the block of code as long as a specified condition is True</p>
<pre class="language-java"><code>while (condition) {
// code block
}</code></pre>
<h3>for Loop</h3>
<p>for loop is used to run a block of code several times</p>
<pre class="language-java"><code>for (initialization; termination; increment) {
statement(s)
}</code></pre>
<h3>for-each Loop</h3>
<pre class="language-java"><code>for(dataType item : array) {
...
}</code></pre>
<h3>do-while Loop</h3>
<p>It is an exit controlled loop. It is very similar to the while loop with one difference, i.e., the body of the do-while loop is executed at least once even if the condition is False</p>
<pre class="language-java"><code>do {
// body of loop
} while(textExpression)</code></pre>
<h3>Break statement</h3>
<p>break keyword inside the loop is used to terminate the loop</p>
<pre class="language-java"><code>break;</code></pre>
<h3>Continue statement</h3>
<p>continue keyword skips the rest of the current iteration of the loop and returns to the starting point of the loop</p>
<pre class="language-java"><code>continue;</code></pre>
<h2>Arrays</h2>
<p>Arrays are used to store multiple values in a single variable</p>
<h3>Declaring an array</h3>
<p>Declaration of an array</p>
<pre class="language-java"><code>String[] var_name;</code></pre>
<h3>Defining an array</h3>
<p>Defining an array</p>
<pre class="language-java"><code>String[] var_name = {''Harry", "Rohan", "Aakash"};</code></pre>
<h3>Accessing an array</h3>
<p>Accessing the elements of an array</p>
<pre class="language-java"><code>String[] var_name = {''Harry", "Rohan", "Aakash"};
System.out.println(var_name[index]);</code></pre>
<h3>Changing an element</h3>
<p>Changing any element in an array</p>
<pre class="language-java"><code>String[] var_name = {''Harry", "Rohan", "Aakash"};
var_name[2] = "Shubham";</code></pre>
<h3>Array length</h3>
<p>It gives the length of the array</p>
<pre class="language-java"><code>System.out.println(var_name.length);</code></pre>
<h3>Loop through an array</h3>
<p>It allows us to iterate through each array element</p>
<pre class="language-java"><code>String[] var_name = {''Harry", "Rohan", "Aakash"};
for (int i = 0; i &lt; var_name.length; i++) {
System.out.println(var_name[i]);
}</code></pre>
<h3>Multi-dimensional Arrays</h3>
<p>Arrays can be 1-D, 2-D or multi-dimensional.</p>
<pre class="language-java"><code>// Creating a 2x3 array (two rows, three columns) 
int[2][3] matrix = new int[2][3]; 
matrix[0][0] = 10; 
// Shortcut 
int[2][3] matrix = { 
{ 1, 2, 3 }, 
{ 4, 5, 6 } 
};</code></pre>
<p>&lt;|AD|&gt;</p>
<h2>Methods</h2>
<p>Methods are used to divide an extensive program into smaller pieces. It can be called multiple times to provide reusability to the program.</p>
<h3>Declaration</h3>
<p>Declaration of a method</p>
<pre class="language-java"><code>returnType methodName(parameters) {
//statements
}</code></pre>
<h3>Calling a method</h3>
<p>Calling a method</p>
<pre class="language-java"><code>methodName(arguments);</code></pre>
<h3>Method Overloading</h3>
<p>Method overloading means having multiple methods with the same name, but different parameters.</p>
<pre class="language-java"><code>class Calculate
{
void sum (int x, int y)
{
System.out.println("Sum is: "+(a+b)) ;
}
void sum (float x, float y)
{
System.out.println("Sum is: "+(a+b));
}
Public static void main (String[] args)
{
Calculate calc = new Calculate();
calc.sum (5,4); //sum(int x, int y) is method is called.
calc.sum (1.2f, 5.6f); //sum(float x, float y) is called.
}
}</code></pre>
<h3>Recursion</h3>
<p>Recursion is when a function calls a copy of itself to work on a minor problem. And the function that calls itself is known as the Recursive function.</p>
<pre class="language-java"><code>void recurse()
{
... .. ...
recurse();
... .. ...
}</code></pre>
<h2>Strings</h2>
<p>It is a collection of characters surrounded by double quotes.</p>
<h3>Creating String Variable</h3>
<pre class="language-java"><code>String var_name = "Hello World";</code></pre>
<h3>String Length</h3>
<p>Returns the length of the string</p>
<pre class="language-java"><code>String var_name = "Harry";
System.out.println("The length of the string is: " + var_name.length());</code></pre>
<h3>String Methods toUpperCase()</h3>
<p>Convert the string into uppercase</p>
<pre class="language-java"><code>String var_name = "Harry";
System.out.println(var_name.toUpperCase());</code></pre>
<h3>toLowerCase()</h3>
<p>Convert the string into lowercase</p>
<pre class="language-java"><code>String var_name = ""Harry"";
System.out.println(var_name.toLowerCase());</code></pre>
<h3>indexOf()</h3>
<p>Returns the index of specified character from the string</p>
<pre class="language-java"><code>String var_name = "Harry";
System.out.println(var_name.indexOf("a"));</code></pre>
<h3>concat()</h3>
<p>Used to concatenate two strings</p>
<pre class="language-java"><code>String var1 = "Harry";
String var2 = "Bhai";
System.out.println(var1.concat(var2));</code></pre>
<h2>Math Class</h2>
<p>Math class allows you to perform mathematical operations.</p>
<h3>Methods max() method</h3>
<p>It is used to find the greater number among the two</p>
<pre class="language-java"><code>Math.max(25, 45);</code></pre>
<h3>min() method</h3>
<p>It is used to find the smaller number among the two</p>
<pre class="language-java"><code>Math.min(8, 7);</code></pre>
<h3>sqrt() method</h3>
<p>It returns the square root of the supplied value</p>
<pre class="language-java"><code>Math.sqrt(144);</code></pre>
<h3>random() method</h3>
<p>It is used to generate random numbers</p>
<pre class="language-java"><code>Math.random(); //It will produce random number b/w 0.0 and 1.0</code></pre>
<pre class="language-java"><code>int random_num = (int)(Math.random() * 101); //Random num b/w 0 and 100</code></pre>
<p>&lt;|AD|&gt;</p>
<h2>Object-Oriented Programming</h2>
<p>It is a programming approach that primarily focuses on using objects and classes. The objects can be any real-world entities.</p>
<h3>object</h3>
<p>An object is an instance of a Class.</p>
<pre class="language-java"><code>className object = new className();</code></pre>
<h3>class</h3>
<p>A class can be defined as a template/blueprint that describes the behavior/state that the object of its type support.</p>
<pre class="language-java"><code>class ClassName {
// Fields
// Methods
// Constructors
// Blocks
}</code></pre>
<h3>Encapsulation</h3>
<p>Encapsulation is a mechanism of wrapping the data and code acting on the data together as a single unit. In encapsulation, the variables of a class will be hidden from other classes and can be accessed only through the methods of their current class.</p>
<pre class="language-java"><code>public class Person { 
private String name; // using private access modifier 

// Getter 
public String getName() { 
return name; 
} 

// Setter 
public void setName(String newName) { 
this.name = newName; 
} 
}</code></pre>
<h3>Inheritance</h3>
<p>Inheritance can be defined as the process where one class acquires the properties of another. With the use of inheritance the information is made manageable in a hierarchical order.</p>
<pre class="language-java"><code>class Subclass-name extends Superclass-name 
{ 
//methods and fields 
}</code></pre>
<h3>Polymorphism</h3>
<p>Polymorphism is the ability of an object to take on many forms. The most common use of polymorphism in OOP occurs when a parent class reference is used to refer to a child class object.</p>
<pre class="language-java"><code>// A class with multiple methods with the same name 
public class Adder { 
// method 1 
public void add(int a, int b) { 
System.out.println(a + b); 
} 

// method 2 
public void add(int a, int b, int c) { 
System.out.println(a + b + c); 
} 

// method 3 
public void add(String a, String b) { 
System.out.println(a + " + " + b); 
} 
} 

// My main class 
class MyMainClass { 
public static void main(String[] args) { 
Adder adder = new Adder(); // create a Adder object 
adder.add(5, 4); // invoke method 1 
adder.add(5, 4, 3); // invoke method 2 
adder.add("5", "4"); // invoke method 3 
} 
}</code></pre>
<p>&lt;|AD|&gt;</p>
<h2>File Operations</h2>
<p>File handling refers to reading or writing data from files. Java provides some functions that allow us to manipulate data in the files.</p>
<h3>canRead method</h3>
<p>Checks whether the file is readable or not</p>
<pre class="language-java"><code>file.canRead()</code></pre>
<h3>createNewFile method</h3>
<p>It creates an empty file</p>
<pre class="language-java"><code>file.createNewFile()</code></pre>
<h3>canWrite method</h3>
<p>Checks whether the file is writable or not</p>
<pre class="language-java"><code>file.canWrite()</code></pre>
<h3>exists method</h3>
<p>Checks whether the file exists</p>
<pre class="language-java"><code>file.exists()</code></pre>
<h3>delete method</h3>
<p>It deletes a file</p>
<pre class="language-java"><code>file.delete()</code></pre>
<h3>getName method</h3>
<p>It returns the name of the file</p>
<pre class="language-java"><code>file.getName()</code></pre>
<h3>getAbsolutePath method</h3>
<p>It returns the absolute pathname of the file</p>
<pre class="language-java"><code>file.getAbsolutePath()</code></pre>
<h3>length Method</h3>
<p>It returns the size of the file in bytes</p>
<pre class="language-java"><code>file.length()</code></pre>
<h3>list Method</h3>
<p>It returns an array of the files in the directory</p>
<pre class="language-java"><code>file.list()</code></pre>
<h3>mkdir method</h3>
<p>It is used to create a new directory</p>
<pre class="language-java"><code>file.mkdir()</code></pre>
<h3>close method</h3>
<p>It is used to close the file</p>
<pre class="language-java"><code>file.close()</code></pre>
<h3>To write something in the file</h3>
<pre class="language-java"><code>import java.io.FileWriter; // Import the FileWriter class
import java.io.IOException; // Import the IOException class to handle errors

public class WriteToFile {
public static void main(String[] args) {
try {
FileWriter myWriter = new FileWriter("filename.txt");
myWriter.write("Laal Phool Neela Phool, Harry Bhaiya Beautiful");
myWriter.close();
System.out.println("Successfully wrote to the file.");
} catch (IOException e) {
System.out.println("An error occurred.");
e.printStackTrace();
}
}
}</code></pre>
<h2>Exception Handling</h2>
<p>An exception is an unusual condition that results in an interruption in the flow of the program.</p>
<h3>try-catch block</h3>
<p>try statement allow you to define a block of code to be tested for errors. catch block is used to handle the exception.</p>
<pre class="language-java"><code>try {
// Statements
}
catch(Exception e) {
// Statements
}</code></pre>
<h3>finally block</h3>
<p>finally code is executed whether an exception is handled or not.</p>
<pre class="language-java"><code>try {
//Statements
}
catch (ExceptionType1 e1) { 
// catch block
}
finally {
// finally block always executes
}</code></pre>
<p>&nbsp;</p>
<div><a class="btn btn-danger" role="button" href="https://api.codewithharry.com/media/blogFiles/java-cheatsheet/Java_Cheatsheet_CodeWithHarry.pdf" target="_blank" rel="noopener"> Download this Cheatsheet</a></div>
<div>&nbsp;</div>
<div>&nbsp;</div>

Java Cheatsheet

Add a new comment