class ArrayElementsSum {

public static void main(String[] args){

int[] arrayOfIntegers = {2,9,8,56,6};

int sumOfElementsOfIntegerArray = 0;

for(int i = 0; i < arrayOfIntegers.length; i++) {

sumOfElementsOfIntegerArray += arrayOfIntegers[i];

}

System.out.println(“Sum of integer elements of array is : “ + sumOfElementsOfIntegerArray);

}

}

visit below for more such examples : — https://www.roseindia.net/java/

class StringDataIndexrelocation {

public static void main(String[] args) {

String mainStringData = “Evil engages us when we least expect it”, backwordIndexedStringData = “”;

for(int i = 0; i < mainStringData.length(); i++) {

backwordIndexedStringData = mainStringData.charAt(i) + backwordIndexedStringData;

}

System.out.println(backwordIndexedStringData);

}

}

visit below for more learning: — https://www.roseindia.net/java/

class WordsCount {

public static void main(String[] args){

String words = “I cant fight an enemy, which I don’t understand”;

int wordsCount = words.split(“\\s”).length;

System.out.println(wordsCount);

}

}

Getting user input read is done with a predefined method nextLn(). This method is executed with an Object instance of an imported class called Scanner. This has to be done as any predefined method inside a class can only be accessed with an object instance of that same class.

import java.util.Scanner; // Scanner class is getting imported in the code with import keyword

class Addition {
public static void main(String[] args){

int firstUserInput, secondUserInput, sumOfInputs;

Scanner scannerClassObject = new Scanner(System.in); // Creating a Scanner class object
System.out.println(“Type first number: “);
firstUserInput = scannerClassObject.nextInt(); // Here user first input is read and get assigned into variable firstUserInput;

System.out.println(“Type second number: “);
secondUserInput = scannerClassObject.nextInt(); // Second user input is getting read and specified

sumOfInputs = firstUserInput + secondUserInput; // with plus sign operator both input values are added up and the value is assigned into the variable sumOfInputs

System.out.println(“Sum of both inputs is :” + sumOfInputs);

}
}

In the code loop inside the loop and a ++ early value increment operator is used.

First a two-dimensional array is initialized with two square brackets. Now in the loops, first the initialized variable values of i and j are checked according to the conditions defined in the middle portion of the loop and then the control goes to next statement System.out.println(); and after that to the ++operator which increases the values of the variable by 1. The loop terminates when the condition defined returns boolean value false.

In the loop .length method returns the length of array.

public class myTableClass {

public static void main(String[] args) {

int[][] myNumbers = { {1, 2, 3, 4,5,6,7},{8,9,10}};

for (int i = 0; i < myNumbers.length; ++i) {

for(int j = 0; j < myNumbers[i].length; ++j) {

System.out.println(“10 * “ + myNumbers[i][j] + “ = “ + 10 * myNumbers[i][j]);

}

}

}

}

After compiling the above code, following out put shows on to console

10 * 1 = 10

10 * 2 = 20

10 * 3 = 30

10 * 4 = 40

10 * 5 = 50

10 * 6 = 60

10 * 7 = 70

10 * 8 = 80

10 * 9 = 90

10 * 10 = 100

Keep coding and visit below for more learning

https://www.roseindia.net/java/index.shtml #table #coding

Here is the syntax of creating an array.
Variable_dataType []; So, any datatype variable can be transformed in to an array by just placing square brackets along side with the data type. For example
String [] birds = {“crow”, “pigeon”, “ostrich”, “parrot”, “sparrow”};
Now every value position or index allocation in an array starts with 0 and goes on
Each bird name in the string array birds can only be accessed with specific index positions allotted. For example, to access bird name ostrich following syntax works.
System.out.println(“Bird at third index of array birds is : “ + birds[2] ); The thirds location in an array is counted as ,0, 1, 2.
This how a value in an array gets accessed also with the following syntax value can be altered too.
birds[3] = “eagle”;
System.out.println(“Now the value at third index of array birds is replaced with eagle:” + birds[3]);
All the multiple values allocated into an array, occupies the array volume. With the syntax below the total length of an array can be find out.
System.out.println(birds.length); .length() property just counts all the indexes allocations, it’s like counting all the number of safe storages allocated to customers near a ship yard. Here in the array the total length comes out to be 5 which is counted as 0,1,2,3,4;
Run the below code and see what happens
public class myArray {
public static void main(String[] args) {
String [] birds = {“crow”, “pigeon”, “ostrich”, “parrot”, “sparrow”};

System.out.println(“Bird at third index of array birds is : “ + birds[2] );

birds[3] = “eagle”;
System.out.println(birds.length);
}
}

Console shows following output
Bird at third index of array birds is : ostrich
5

It’s time to go dimensional, when an array goes dimensional means, now multiple arrays with equivalent data type values can be stored and accessed through a single array instance. And accessing the values of such array is like switching to cells of a row and column in MS Excel.
Here is an example of two-dimensional array below, observe each array along with the values are stored inside a single array with its own set of curly braces.
public class narayan {
public static void main(String[] args) {

String[][] godIncarnations = {{“jesus”, “prophet”, “mohammed”},{“ram”, “narayan”, “mahadev”}};
System.out.println(“incarnated name of god at the second position inside first array : “ + godIncarnations[0][1]); //
System.out.println(“incarnated name of god at the third position inside second array : “ + godIncarnations[1][2]);
}
}
After successful compilation console shows following output

incarnated name of god at the second position inside first array : prophet
incarnated name of god at the third position inside second array : mahadev

Let’s create a table program with array
public class main {
public static void main(String[] args) {
int[] numbers = {1,2,3,4,5,6,7,8,9,10};
int y = 1;
do{
System.out.println(“10 * “ + numbers[y-1] + “ = “ + 10*numbers[y-1]);
y++;

}while(y<=10);

}
}
Console shows following output
10 * 1 = 10
10 * 2 = 20
10 * 3 = 30
10 * 4 = 40
10 * 5 = 50
10 * 6 = 60
10 * 7 = 70
10 * 8 = 80
10 * 9 = 90
10 * 10 = 100

Keep coding and visit below for more practice tutorials
https://www.roseindia.net/java/ #javaarrays #arrays #coding

Method Description

nextBoolean() A boolean value gets read

nextByte() An input byte data gets read

nextDouble() An input double data gets read

nextFloat() An input float data gets read

nextInt() An input Integer data gets read

nextLine() An input float data gets read

nextLong() An long byte data gets read

nextShort() An input short data gets read

When an input data gets read, with the datatype read method, value is validated, and when input value data type validation fails, error or exception is thrown or generated by the java compiler.

In the code an instance of Scanner class object is created with name myScannerClassObject, so to use the class methods.

To maintain code stability exception catcher’s try and catch are defined. In the example below three different user input data type value are read by the scanner class methods. nextLine(), .nxtInt() and .nextDouble(). Whenever any input data mismatches its field data type, exception gets throwed, and try and catch works on the exception. In cases of exceptions, finally keyword command still gets executed regardless try and catch exception catcher’s work.

import java.util.Scanner; // bringing scanner class interface

class narayan {

public static void main(String[] args) {

try{

Scanner myScannerClassObject = new Scanner(System.in);

System.out.println(“Enter username”);

String stringVariable = myScannerClassObject.nextLine(); // Read user input

Integer myInt = myScannerClassObject.nextInt();

Double myDouble = myScannerClassObject.nextDouble();

System.out.println(“Username is: “ + stringVariable); // Output user input

System.out.println(“Roll No. is: “ + myInt); // Output user input

System.out.println(“Average Speed is: “ + myDouble + “m/s”); // Output user input

} catch (Exception e) {

System.out.println(“Data type mismatch”);

} finally {

System.out.println(“type correct data type value”);

}

}

}

When the code is compiled three user inputs are asked, go ahead and compile it. And visit below link for more practice tutorials.

https://www.roseindia.net/java/ #javaexceptions #javascannerclass #coding

Abstraction can be implemented in two shots, first one using abstract non access modifier keyword and the second one is with interfaces.

When a class is declared abstract, its attributes and itself access gets hindered to other classes. All the abstract methods of the class are accessible inside the class only, also abstract methods of an abstract class do not possess any code or in simple terms method does not contain any body. All the code will be defined inside the class that inherits the abstract class.

Interaction to abstract classes gets achieved only with inheritance using extend keyword as demonstrated in below code.

abstract class Creature {

public abstract void creatureSound();

public void meditating() {

System.out.println(“hmmm hoommmh”);

}

}

Creature myPet = new Creature();

//Now an object of class Creature, going to generate compile time error, as the class is abstract in nature

Now as stated above with inheritance, access to abstract class is possible. Check below code, how its done

abstract class Creature {

public abstract void myPetSounds();

public void meditating() {

System.out.println(“while mediatiting my pet buzo chanting sounds like ohmmmohhhmhmh”);

}

}

//Now an object of class Creature, gonna generate compile time error

//forming a Subclass inherited from class Creature

class Pet extends Creature {

public void myPetSounds() {

System.out.println(“when buzo shouts it sounds hears like wow wwoow”);

}

}

class narayan {

public static void main(String[] args){

Pet myPet = new Pet(); // creating a Pet class object

myPet.meditating();

myPet.myPetSounds();

}

}

After compilation successfully following output the console shows.

while mediatiting my pet buzo chanting sounds like ohmmmohhhmhmh

when buzo shouts it sounds hears like wow wwoow

Second way of applying abstraction into java code is with Interfaces, Interfaces are predefined abstract classes in java. Now same procedure of accessing goes on except instead of using “extend” keyword, “implement” keyword gets placed for a subclass to inherit the abstract parent class. Check out the code below, all is demonstrated.

interface Creature {

public void myPetSounds(); // interface methods doesnot possess body

public void speed();

}

class Pet implements Creature {

public void myPetSounds() {

System.out.println(“when buzo shouts it sounds hears like wow wwoow”);

}

public void speed () {

System.out.println(“buzo runs with incredible pace”); // defining body of interface class speed method

}

}

class narayan {

public static void main(String[] args){

Pet myPet = new Pet(); // creating a Pet class object

myPet.speed();

myPet.myPetSounds();

}

}

keep coding and visit below for more practice tutorials on java coding

https://www.roseindia.net/java/index.shtml?expand_article=1 #JavaAbstraction #Java #coding

All the coding is starts and encoded inside a java class. In the below code user defined two classes are built, FirstClass and First_SubClass. Now the noticeable point here is classes can be built inside a class also to make code more understandable and efficient.

Now every java code written must have a main class with name exactly of the java file has. Both classes created in the code have attributes one integer variables alpha and beta. Now any class attribute or member can be accessed with class object objects support, so two class objects with name myFirstClassObject and myFirstSubClassObject are created in the code. Check out the syntax for the class object generation, while generating subclass object, the need of FirstClass object is imperative.

Below code basically demonstrates how to create inner classes

class FirstClass {

int alpha = 20;

class First_SubClass {

int beta = 30;

}

}

public class narayan {

public static void main(String[] args){

FirstClass myFirstClassObject = new FirstClass();

FirstClass.First_SubClass myFirstSubClassObject = myFirstClassObject.new First_SubClass();

System.out.println(“sub class integer variable beta value is : “ + myFirstSubClassObject.beta + “\n” + “First class integer variable alpha value is : “ + myFirstClassObject.alpha);

}

}

After successful compilation

sub class integer variable beta value is : 30

First class integer variable alpha value is : 20

In the code, My First_SubClass is an inner class , and write now not above it is declared as a regular class. The thing is coder can restrict class or its attributes and members access by declaring classes as private or protected. Check out the code below, how such restriction is achieved.

Here in the code below the inner class is declared as private and prohibiting any outside class object access into inner class attributes and methods.

class FirstClass {

int alpha = 20;

private class First_SubClass {

int beta = 30;

}

}

public class narayan {

public static void main(String[] args){

FirstClass myFirstClassObject = new FirstClass();

FirstClass.First_SubClass myFirstSubClassObject = myFirstClassObject.new First_SubClass();

System.out.println(“sub class integer variable beta value is : “ + myFirstSubClassObject.beta + “\n” + “First class integer variable alpha value is : “ + myFirstClassObject.alpha);

}

}

During compilation the java compiler shouts out the following error. This compiler objection is because access to an inner private declared class is not allowed through any outer class.

narayan.java:13: error: FirstClass.First_SubClass has private access in FirstClass

FirstClass.First_SubClass myFirstSubClassObject = myFirstClassObject.new First_SubClass();

^

narayan.java:13: error: FirstClass.First_SubClass has private access in FirstClass

FirstClass.First_SubClass myFirstSubClassObject = myFirstClassObject.new First_SubClass();

^

2 errors

To access an inner class, the object instance of the super class is needed. But this can be dodged, with declaring the inner class static, as demonstrated below.

class FirstClass {

int alpha = 20;

static class First_SubClass {

int beta = 30;

}

}

public class narayan {

public static void main(String[] args){

// no need for an super class object instance

// FirstClass myFirstClassObject = new FirstClass();

FirstClass.First_SubClass myFirstSubClassObject = new FirstClass.First_SubClass();

System.out.println(“sub class integer variable beta value is : “ + myFirstSubClassObject.beta + “\n”);

}

}

After successful compilation following output shows up

sub class integer variable beta value is : 30

Inner class have an advantage over super classes as they can access attributes and members of their super classes, as mentioned below.

class FirstClass {

String gamma = “om namo bhagvate vasudevaaye”;

class First_SubClass {

public String myFirstSubClassMethod(){

return gamma;

}

}

}

public class narayan {

public static void main(String[] args){

FirstClass myFirstClassObject = new FirstClass();

FirstClass.First_SubClass myFirstSubClassObject = myFirstClassObject.new First_SubClass();

System.out.println(“Super Class String variable gamma value : “ + myFirstSubClassObject.myFirstSubClassMethod());

}

}

After successful compilation following output comes up to console

Super Class String variable gamma value : om namo bhagvate vasudevaaye

Keep coding and visit the below link for more practice tutorials

https://www.roseindia.net/java/index.shtml #javaclasses #javacoding #javatutorials

import java.io.FileReader;
import java.io.BufferedReader;

class narayan {
public static void main(String[] args){
char[] array_of_characters = new char[120]; // an array creation of 120 character size limit

try {
FileReader aFileReaderClassObject = new FileReader(“matrix.txt”); // creating an object of FileReader class
BufferedReader aBufferedReaderClassObject = new BufferedReader(aFileReaderClassObject); // creating a Buffered Reader class object and placing FileReader class object inside the parentheses value section of Buffered Reader Class object aBufferedReaderClassObject

aBufferedReaderClassObject.read(array_of_characters);
System.out.println(“Data content of file matrix.txt is”);
System.out.println(array_of_characters);

}

catch(Exception some_exception){
some_exception.getStackTrace();
}

}
}
After successful compilation following output comes up
Data content of file matrix.txt is
Dialogues from The Matrix:

“Welcome to the real world.” — Morpheus
Morpheus says this to Neo after he takes the red

Keep coding and visit the below link for more understanding and practice tutorials
https://www.roseindia.net/java/example/java/io/java-BufferedReader.shtml?expand_article=1 #javaBufferedReader #javatextfilereader #javacoding