Member Accessibility Modifiers in Java

Member Accessibility Modifiers in Java

By specifying member accessibility modifiers, a class can control what information is accessible to clients (i.e., other classes). These modifiers help a class to define a contract so that clients know exactly what services are offered by the class.

Accessibility of members can be one of the following:

• public
• protected
• default (also called package accessibility)
• private

A member has package or default accessibility when no accessibility modifier is specified. The member accessibility modifier only has meaning if the class (or one of its sub classes) is accessible to the client. Also, note that only one accessibility modifier can be specified for a member.

public Members: Public accessibility is the least restrictive of all the accessibility modifiers. A public member is accessible from anywhere, both in the package containing its class and in other packages where this class is visible. This is true for both instance and static members.(eg SuperclassA, SubclassB)

protected Members: A protected member is accessible in all classes in the package containing its class, and by all subclasses of its class in any package where this class is visible. In other words, non-subclasses in other packages cannot access protected members from other packages. It is less restrictive than the default accessibility(eg SuperclassA1, SubclassB1).

Default Accessibility for Members: When no member accessibility modifier is specified, the member is only accessible by other classes in its class's package. Even if its class is visible in another (possibly nested) package, the member is not accessible there. Default member accessibility is more restrictive than protected member accessibility.(eg SuperclassA2, SubclassB2)

private Members: This is the most restrictive of all the accessibility modifiers. Private members are not accessible from any other class. This also applies to subclasses, whether they are in the same package or not. Since they are not accessible by simple name in a subclass, they are also not inherited by the subclass. (eg SuperclassA3)

Arrays in Java

Arrays in Java

An array is a data structure that defines an indexed collection of a fixed number of homogeneous data elements. All elements in the array have the same data type. A position in the array is indicated by a non-negative integer value called the index. An element at a given position in the array is accessed using the index. The size of an array is fixed and cannot increase to accommodate more elements.

• In Java, arrays are objects. Arrays can be of primitive data types or reference types.
• In the first case, all elements in the array are of a specific primitive data type. In the second case, all elements are references of a specific reference type. 
• Each array object has a final field called length, which specifies the array size, that is, the number of elements the array can accommodate. The first element is always at index 0 and the last element at index n-1, where n is the value of the length field in the array.
• Simple arrays are one-dimensional arrays.
• An array variable declaration has either the following syntax:<element type>[] <array name>;
  Or
  <element type> <array name>[];
  where <element type> can be a primitive data type or a reference type .

The declaration does not actually create an array. It only declares a reference that can denote an array object.

• Constructing an Array: An array can be constructed for a specific number of elements of the element type, using the new operator. The resulting array reference can be assigned to an array variable of the corresponding type.
  <array name> = new <element type> [<array size>];
• The array declaration and construction can be combined. <element type1>[] <array name> = new <element type2>[<array size>];
• Initializing an Array: Java provides the means of declaring, constructing, and explicitly initializing an array in one declaration statement:
  <element type>[] <array name> = { <array initialize list> };
• Using an Array: The whole array is referenced by the array name, but individual array elements are accessed by specifying an index with the [] operator. The array element access expression has the following syntax:
  <array name> [<index expression>]
• Anonymous Arrays:
  <element type>[] <array name> = new <element type>[] { <array initialize list> };
  can be used to declare an array for example
  int[] myArray = new int[] {1, 4, 6, 8}; 
• Multidimensional Arrays: An array element can be an object reference and arrays are objects, array elements can themselves reference other arrays. In Java, an array of arrays can be defined as follows:
  <element type>[][]...[] <array name>;
  or <element type> <array name>[][]...[];

Java Source File Structure

Java Source File Structure

A Java source file can have the following elements that, if present, must be specified in the following order

• An optional package declaration to specify a package name.
• Zero or more import declarations. Since import declarations introduce class and interface names in the source code, they must be placed before any type declarations.
• Any number of top-level class and interface declarations. Since these declarations belong to the same package, they are said to be defined at the top level, which is the package level.
• The classes and interfaces can be defined in any order. Class and interface declarations are collectively known as type declarations. Technically, a source file need not have any such definitions, but that is hardly useful.

The Java 2 SDK imposes the restriction that at the most one public class definition per source file can be defined. If a public class is defined, the file name must match this public class. If the public class name is MyApp, then the file name must be MyApp.java.

The main() Method 

• The Java interpreter executes a method called main in the class specified on the command line.
• Any class can have a main() method, but only the main() method of the class specified to the Java interpreter is executed to start a Java application.
• The main() method must have public accessibility so that the interpreter can call it.
• It is a static method belonging to the class, so that no object of the class is required to start the execution.
• It does not return a value, that is, it is declared void.
• It always has an array of String objects as its only formal parameter. This array contains any arguments passed to the program on the command line.
• All this adds up to the definition of the main() method:

public static void main(String[] args) { // ... }

Java Language Fundamentals

Java Language Fundamentals

Identifiers

• A name in a program is called an identifier.
• Identifiers can be used to denote classes, methods, variables, and labels.
• In Java an identifier is composed of a sequence of characters, where each character can be either a letter, a digit, a connecting punctuation (such as underscore _), or any currency symbol (such as $, ¢, ¥, or £). However, the first character in an identifier cannot be a digit.
• Identifiers in Java are case sensitive, for example, price and Price are two different identifiers.

Examples of Legal Identifiers: number, Number, sum_$, bingo, $$_100, mål, grüß 

Examples of Illegal Identifiers: 48chevy, all@hands, grand-sum

Keywords

• Keywords are reserved identifiers that are predefined in the language and cannot be used to denote other entities.
• All the keywords are in lowercase, and incorrect usage results in compilation errors.

Literals

• A literal denotes a constant value, that is, the value a literal represents remains unchanged in the program. Identifiers can be used to denote classes, methods, variables, and labels.
• Literals represent numerical (integer or floating-point), character, boolean or string values. In addition, there is the literal null that represents the null reference.

Examples of literals

• Integer 2000, 0, -7 
• Floating-point 3.14, -3.14, .5, 0.5
• Character 'a‘, 'A‘, '0‘, ':‘, '-‘, ')' 
• Boolean true, false 
• String "abba“, "3.14“, "for“, "a piece of the action“

Comments

A program can be documented by inserting comments at relevant places. These comments are for documentation purposes and are ignored by the compiler.

Java provides three types of comments to document a program:

• A single-line comment: // ... to the end of the line
• A multiple-line comment: /* ... */
• A documentation (Javadoc) comment: /** ... */

Primitive data types

Primitive data types in Java can be divided into three main categories:

• Integral types— represent signed integers (byte, short, int, long) and unsigned character values (char)
• Floating-point types (float, double)— represent fractional signed numbers
• Boolean type (boolean)— represent logical values

Primitive data values are not objects. Each primitive data type defines the range of values in the data type, and operations on these values are defined by special operators in the language.

Variable declaration

A variable stores a value of a particular type. A variable has a name, a type, and a value associated with it. In Java, variables can only store values of primitive data types and references to objects. Variables that store references to objects are called reference variables.

Declaring and Initializing Variables

Variable declarations are used to specify the type and the name of variables. This implicitly determines their memory allocation and the values that can be stored in them.

• char a, b, c; // a, b and c are character variables.
• double area; // area is a floating-point variable.
• boolean flag; // flag is a boolean variable.

A declaration can also include initialization code to specify an appropriate initial value for the variable:

• int i = 10; // i is an int variable with initial value 10.
• long big = 2147483648L; // big is a long variable with specified initial value.

Object Reference Variables, An object reference is a value that denotes an object in Java. Such reference values can be stored in variables and used to manipulate the object denoted by the reference value. Before we can use a reference variable to manipulate an object, it must be declared and initialized with the reference value of the object.

• Pizza yummyPizza; // Variable yummyPizza can reference objects of class Pizza.
• Hamburger bigOne; // Variable bigOne can reference objects of class Hamburger
• Pizza yummyPizza = new Pizza("Hot&Spicy"); // Declaration with initializer.

Basic elements of a Java Program

Basic elements of a Java Program

The basic elements of a Java application are introduced in this post.

Basic elements of a Java Program - Class

A class denotes a category of objects, and acts as a blueprint for creating such objects. A class models an abstraction by defining the properties and behaviors for the objects representing the abstraction. An object exhibits the properties and behaviors defined by its class. The properties of an object of a class are also called attributes, and are defined by fields in Java. A field in a class definition is a variable which can store a value that represents a particular property.  The behaviors of an object of a class are also known as operations, and are defined using methods in Java. Fields and methods in a class definition are collectively called members.

Basic elements of a Java Program - Object

The process of creating objects from a class is called instantiation. An object is an instance of a class. The object is constructed using the class as a blueprint and is a concrete instance of the abstraction that the class represents. An object must be created before it can be used in a program. In Java, objects are manipulated through object references. Each object has a unique identity and has its own copy of the fields declared in the class definition.

Instance Member

The fields of an object are called instance variables. The values of the instance variables in an object comprise its state. Two distinct objects can have the same state, if their instance variables have the same values. The methods of an object define its behavior. These methods are called instance methods. It is important to note that these methods pertain to each object of the class. Instance variables and instance methods, which belong to objects, are collectively called instance members.

Method invocation

Objects communicate by message passing. This means that an object can be made to exhibit a particular behavior by invoking the appropriate operation on the object. In Java, this is done by calling a method on the object using the dot '.' operator.  The dot '.' notation also can be used with a reference to access fields of an object.

Static member

In some cases, certain members should only belong to the class, and not be part of any object created from the class. Such a field is called a static variable. It belongs to the class, and not to any object of the class. A static variable is initialized when the class is loaded at runtime. Similarly, a class can have static methods that belong only to the class, and not to any objects of the class.  Static variables and static methods are collectively known as static members, and are distinguished from instance members in a class definition by the keyword static in their declaration.

Java Program

A Java program is a collection of one or more classes, with one of them containing the program's execution starting point. A Java source file can contain more than one class definition. The Java 2 SDK enforces the rule that at the most one class in the source file has public accessibility. The name of the source file is comprised of the name of this public class with .java as extension. Each class definition in a source file is compiled into a separate class file, containing Java byte code. The name of this file is comprised of the name of the class with .class as an extension. All programs must be compiled before they can be run. 

An application is what is normally called a program: source code that is compiled and directly executed. In order to create an application in Java, the program must have a class that defines a method called main. The main() method in the class is the starting point for the execution of any application.

public static void main(String [] args)

The main() method has public accessibility, that is, it is accessible from any class. The keyword static means the method belongs to the class. The keyword void means the method does not return any value. The parameter list, String[] args, is an array of strings used to pass information to the main() method when the application is started.

Introduction to Java

Introduction to Java

Java is a general-purpose computer programming language that is concurrent, class-based and object-oriented. Java is intended to let application developers "write once, run anywhere" (WORA) meaning that compiled Java code can run on all platforms that support Java without the need for recompilation. 

Java applications are typically compiled to bytecode that can run on any Java virtual machine (JVM) regardless of computer architecture. As of 2016, Java is one of the most popular programming languages in use, particularly for client-server web applications. 

Java was originally developed by James Gosling at Sun Microsystems (later acquired by Oracle Corporation) and released in 1995 as a core component of Sun Microsystems' Java platform. The language derives much of its syntax from C and C++, but it has fewer low-level facilities than either of them.

Principles

There were five primary goals in the creation of the Java language  

1. It must be "simple, object-oriented, and familiar".
2. It must be "robust and secure".
3. It must be "architecture-neutral and portable".
4. It must execute with "high performance".
5. It must be "interpreted, threaded, and dynamic".

Java Virtual Machine (JVM)

Oracle provides a set of programming tools such as javac, java and others in a bundle called Java SDK(JDK) for different platforms (Windows, Linux, etc)

Oracle also provides a runtime bundle with just the JVM (Java Virtual machine) when programming tools are not needed.

JVM is a program that runs on a given platform and takes the bytecode as input and interprets them just as if it were a physical processor executing machine code. javac compiler transforms the Java language source code to bytecode that runs in the JVM.

With most programming languages you either compile or interpret a program so that you can run it on your computer. The Java programming language is unusual in that a program is both compiled and interpreted. With the compiler, first you translate a program into an intermediate language called Java bytecodes – the platform independent codes interpreted by the interpreter on the Java platform. The interpreter parses and runs each Java bytecode instruction on the computer. Compilation happens just once; interpretation occurs each time the program is executed.

You can think of the Java bytecodes as the machine code instructions for the Java Virtual Machine(Java VM). Every JVM interpreter, whether it’s a development tool or a web browser that can run applets, is an implementation of the Java VM.

Java byte codes help make “write once, run anywhere” possible. You can compile your program into bytecodes on any platform that has a Java compiler. The bytecodes can then be put on any implementation of the Java VM. That means that as long as a computer has a Java VM, the same program written in the Java programming language can run on Windows, a Solaris workstation or an iMac.

Constructors in Java

Constructors in Java

A constructor in Java is a block of code similar to a method that’s called when an instance of an object is created. A constructor is a special method that is used to initialize an object. Every class has a constructor, if we don't explicitly declare a constructor for any java class the compiler builds a default constructor for that class. A constructor does not have any return type.

A constructor has same name as the class in which it resides. Constructor in Java cannot be abstract, static, final or synchronized. These modifiers are not allowed for constructor.

public class Student { int rollNumber; String name; public Student() {             rollNumber=0;             name="";             System.out.println("Inside Default Constructor"); } }

There are two types of Constructor

·         Default Constructor – is the one which does not have any parameters

·         Parameterized constructor – may contain 1 or more parameter list.

If we don't explicitly declare a constructor for any java class the compiler builds a default constructor for that class

public class Student { int rollNumber; String name; // Default Constructor public Student() {             rollNumber=0;             name="";             System.out.println("Inside Default Constructor"); } // parameterized constructor Student(int rno,String sname){             rollNumber=rno;             name=sname; System.out.println("Inside Parametrized Constructor"); } }

Constructor Overloading

Like methods, constructors can also be overloaded. Overloaded constructors are different on the basis of their type of parameters or number of parameters. Constructor overloading is not much different than method overloading. In case of method overloading you have multiple methods with same name but different signature, whereas in Constructor overloading you have multiple constructor with different signature.

Let’s create a class with the main method to class the Student Class

public class MainClass { public static void main(String[] args) {             // Default Constructor will be called             Student s1=new Student();                         // Calling Parametrized Constructor             Student s2=new Student(1,"Bond"); } }

Once we execute the above class, we get the following output

Inside Default Constructor Inside Parametrized Constructor

Some of the key points to remember regarding Constructors

·         A constructor doesn’t have a return type.

·         The name of the constructor must be the same as the name of the class.

·         Unlike methods, constructors are not considered members of a class.

·         A constructor is called automatically when a new instance of an object is created.

·         Constructors can be overloaded just like normal methods.

·         Constructors can be private. This facilitates Singleton Design Pattern.

Packages in Java

Use of packages in Java

Packages in Java helps resolve naming conflicts,  when your project have classes with the same names.

Java Packages helps you organize class files within your project.

If we to put all .java files into a single package,then it become a nightmare to manage all your files as the project gets bigger.

You can create a package with package keyword, which is the first keyword in any Java program

followed by import statements.

The java.lang package is imported implicitly by default and all the other packages must be explicitly imported.

package com.package01.util ;

java.io.BufferedReader;

import java.util.Date;

A package in Java is an encapsulation mechanism that can be used to group related classes, interfaces, and subpackages.

The dot (.) notation is used to uniquely identify package members in the package hierarchy. 

The class java.sql.Date is different from the class java.util.Date. The MyClass class can be easily identified by the name com.mypackage.MyClass. This is called the fully qualified name of the package member. 

It is not surprising that most Java programming environments map the fully qualified name of packages on the underlying (hierarchical) file system.

Defining Packages: A class or interface can indicate that its Java byte code be placed in a particular package, using a package declaration. 

The package statement has the following syntax: 

package <fully qualified package name>;

At most one package declaration can appear in a source file, and it must be the first statement in the unit.

If a package declaration is omitted in a compilation unit, the Java byte code for the declarations in the compilation unit will belong to an unnamed package, which is typically synonymous with the current working directory on the host system.

Using Packages

Given a reference type that is accessible from outside a package, the reference type can be accessed in two ways. 

• The first form uses the fully qualified name of the type. However, writing long names can become tedious. 
• The second form uses the import declaration to provide a shorthand notation for specifying the name of the type. 

The import declarations must be the first statement after any package declaration in a source file. The simple form of the import declaration has the following syntax: 

import <fully qualified type name>; or 

import <fully qualified package name>.*;

An import declaration does not recursively import subpackages.