Arrays

An array is a container object that holds a fixed number of values of a single type. The length of an array is established when the array is created. After creation, its length is fixed. In other words,you can say that an array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.

Ok! now after a short definition of an array, let me tell you that Arrays are basically classified into 3 types:

So,How to declare array in java?

One Dimensional Array

Syntax for default values:

int[] num = new int[5];

Syntax with values given:

int[] num = {1,2,3,4,5};

Multidimensional array

Declaration

int[][] num = new int[5][2];

For primitive types:

int[] myIntArray = new int[3];
int[] myIntArray = {1,2,3};
int[] myIntArray = new int[]{1,2,3};

For classes, for example String, it's the same:

String[] myStringArray = new String[3];
String[] myStringArray = {"a","b","c"};
String[] myStringArray = new String[]{"a","b","c"};

Apart from Syntaxs,keep the following array figures in your mind:

Basic array figure

This one denotes 1-D array

Data Types

The Eight Data Types of Java

The term data type refers to the type of data that can be stored in a variable. Sometimes, Java is called a “strongly typed language” because when you declare a variable, you must specify the variable’s type. Then the compiler ensures that you don’t try to assign data of the wrong type to the variable. The following example code generates a compiler error:

int x;
x = 3.1415;

Because x is declared as a variable of type int (which holds whole numbers), you can’t assign the value 3.1415 to it.

Java distinguishes between two kinds of data types: primitive types and reference types. Primitive types are the data types defined by the language itself. By contrast, reference types are types defined by classes in the Java application programming interface (API) or by classes you create rather than by the language itself.

Java defines eight primitive types:

Type	Explanation
int	A 32-bit (4-byte) integer value
short	A 16-bit (2-byte) integer value
long	A 64-bit (8-byte) integer value
byte	An 8-bit (1-byte) integer value
float	A 32-bit (4-byte) floating-point value
double	A 64-bit (8-byte) floating-point value
char	A 16-bit character using the Unicode encoding scheme
boolean	A true or false value

Class variable vs Instance Variable

What’s the difference between a class variable and an instance variable?

Knowing the terminology is important. Instance variables and class variables are both member variables. They are both member variables because they are both associated with a specific class. But, there are differences between instance variables and class variables.

Instance variables

Instance variables belong to an instance of a class. Another way of saying that is instance variables belong to an object, since an object is an instance of a class. Every object has it’s own copy of the instance variables. Here is what a declaration of an instance variable would look like:

Example of an instance variable:

class Taxes
{
  int count;
  /*...*/
}

Class variables – also known as static member variables

Class variables, however, only have one copy of the variable(s) shared with all instances of the class. It’s important to remember that class variables are also known as static member variables in C++, Java, and C#. Each object of the class does not have its own copy of a class variable. Instead, every object shares the one and only copy of that class variable – and any changes made to that copy are seen by all of the objects of that class. Here is what a class variable – or a static member variable – would look like in C++:

Example of a class variable:

class Taxes
{
  static int count;
  /*...*/
}

Difference between class and instance variables

Now, it should be clear what the difference between instance and class variables is. Class variables only have one copy that is shared by all the different objects of a class, whereas every object has it’s own personal copy of an instance variable. So, instance variables across different objects can have different values whereas class variables across different objects can have only one value.

Class and Instance variables are both Member variables

Here’s a little diagram to help you remember the differences between instance and class variables:

Variable types

This had to be my previous post(i.e. before methods) but never mind!!

A variable provides us with named storage that our programs can manipulate. Each variable in Java has a specific type, which determines the size and layout of the variable's memory; the range of values that can be stored within that memory; and the set of operations that can be applied to the variable.

You must declare all variables before they can be used. The basic form of a variable declaration is shown here:

data type variable [ = value][, variable [= value] ...] ;

Here data type is one of Java's datatypes and variable is the name of the variable. To declare more than one variable of the specified type, you can use a comma-separated list.

int a, b, c;         // Declares three ints, a, b, and c.
int a = 10, b = 10;  // Example of initialization
byte B = 22;         // initializes a byte type variable B.
double pi = 3.14159; // declares and assigns a value of PI.
char a = 'a';        // the char variable a is initialized with value 'a'

There are three kinds of variables in Java:

• Local variables: Local variables are declared in methods, constructors, or blocks(i'l discuss constructors in java later).There is no default value for local variables so local variables should be declared and an initial value should be assigned before the first use.

Example:

Here, age is a local variable. This is defined inside printAge() method and its scope is limited to this method only.

public class Test{ 
   public void printAge(){
      int age = 0;     // age is initialized
      age = age + 7;
      System.out.println("Age is : " + age);
   }
   
   public static void main(String args[]){
      Test test = new Test();
      test.printAge();
   }
}

This would produce the following result:

Age is: 7

Example:

Following example uses age without initializing it, so it would give an error at the time of compilation.

public class Test{ 
   public void printAge(){
      int age;  //age is not initialized
      age = age + 7;
      System.out.println("Age is : " + age);
   }
   
   public static void main(String args[]){
      Test test = new Test();
      test.printAge();
   }
}

This would produce the following error while compiling it:

Test.java:4:variable number might not have been initialized
age = age + 7;
         ^
1 error

• Instance variables: Instance variables are declared in a class, but outside a method, constructor or any block.
• Class/static variables: Class variables also known as static variables are declared with the static keyword in a class, but outside a method, constructor or a block.

I will write about Instance Variables and Static variables in my next post. 

Keep practicing!!

Methods in Java

Methods in Java are used to make code easier to read and to make sure that code is not duplicated. Code that needs to be run over and over again is placed in a method, which is just a sequence of instructions all placed together in one spot. This is basically what methods are, but it's important to make sure we've got the details nailed down. In other words, you need to know how methods in Java truly work so that you know how to best use them.
Methods in Java have their own scope. What is method scope? Scope is what you can see.
Anything inside of a method in Java is inside of the method's scope. When Java is executing code inside of a method, it's scope is limited to whatever is inside that method. It cannot look beyond the method. So what exactly do I mean?

Variables can be created anywhere in your program. You typically create variables inside of methods, such as the main method, or some other Java method that you create. Here's an example of a program with two methods, and it has variables being created inside of each method. We're going to see which variables a program can see depending on which part of the code your program is executing.

There are variables created in the main method, and there is a variable created in otherMethod(), another Java method. When the program is inside the main method, it can print out the values of num and pi, because they are still within the scope of the method. Try printing out the value of num inside  otherMethod().

Notice how in my example, my compiler in Eclipse is showing me that I have an error when I try to print out the value of num when I'm inside otherMethod(). This is because there is no way to see the variable num from within another method besides the main. So, it is said to be out of scope. The same is true if I try to print out the value of num2 inside of the main method.

Inside the main method, Java can't see any variables created in other methods.

Get rid of the lines of code that have errors in them, and run the program.

You'll see that only two of the println's actually worked. What happened to the third one? Remember, Java programs start at the top of the main method. This means that Java starts executing code beginning with the first line it finds inside of the main method. Java creates the num variable, the pi variable, prints out the num variable, prints out the pi variable, and then reaches the end of the main. When that happens, the program finishes. It never gets to the other method, so it never printed out the value of num2. It never even created the num2 variable!