Tangled JAVA elaborately

Members of datatype and DateTime, TimeSpan

noreply@blogger.com (Anonymous) — Thu, 14 Dec 2017 10:25:00 +0000

In this article we will see members of C# datatypes.

Members of datatype

Members of numerical datatype

Experimenting with the intrinsic C# data types, understand that the numerical types of .NET support MaxValue and MinValue properties that provide information regarding the range a given type can store. In addition to the MinValue/MaxValue properties, a given numerical system type may define further useful members. For example, the System.Double type allows you to obtain the values for epsilon and infinity which might be of interest to those of you with a mathematical flare.

Lets understand that by a simple program:

Program


using System;

public class ConsoleApp
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Members of numerical datatype:");
        Console.WriteLine("Max value of Int: {0}",int.MaxValue);
        Console.WriteLine("Min value of Int: {0}",int.MinValue);
        Console.WriteLine("Max value of Float: {0}", float.MaxValue);
        Console.WriteLine("Min value of Float: {0}", float.MinValue);
        Console.WriteLine("Max value of Double: {0}", double.MaxValue);
        Console.WriteLine("Min value of Double: {0}", double.MinValue);
        Console.WriteLine("Epsilon: {0}",double.Epsilon);
        Console.WriteLine("Positive infinity: {0}",double.PositiveInfinity);
        Console.WriteLine("Negative infinity: {0}",double.NegativeInfinity);
        Console.ReadLine();
    }
}

Output


Members of numerical datatype:
Max value of Int: 2147483647
Min value of Int: -2147483648
Max value of Float: 3.402823E+38
Min value of Float: -3.402823E+38
Max value of Double: 1.79769313486232E+308
Min value of Double: -1.79769313486232E+308
Epsilon: 4.94065645841247E-324
Positive infinity: Infinity
Negative infinity: -Infinity

Members of System.Boolean

Consider the System.Boolean data type. The only valid assignment a C# bool can take is from the set {true | false}. Given this point, it should be clear that System.Boolean does not support a MinValue/MaxValue property set but rather TrueString/FalseString (which yields the string "True" or "False", respectively). Here’s an example program:

Program


using System;

public class ConsoleApp
{
    public static void Main(string[] args)
    {
        //Members of System.Boolean
        Console.WriteLine("true string: {0}",bool.TrueString);
        //GetType() method returns datatype of variable
        Console.WriteLine("type of TrueString: {0}",bool.TrueString.GetType());
        Console.WriteLine("false string: {0}",bool.FalseString);
        Console.WriteLine("type of FalseString: {0}",bool.FalseString.GetType());
        Console.ReadLine();
    }
}

Output


true string: True
type of TrueString: System.String
false string: False
type of FalseString: System.String

Members of System.Char

C# textual data is represented by the string and char keywords, which are simple shorthand notations for System.String and System.Char, both of which are Unicode under the hood. As you might already know, a string represents a contiguous set of characters (e.g., "Hello"), while the char can represent a single slot in a string (e.g., 'H').

The System.Char type provides you with a great deal of functionality beyond the ability to hold a single point of character data. Using the static methods of System.Char, you are able to determine whether a given character is numerical, alphabetical, a point of punctuation, or whatnot. Consider the following program:

How to know that given character is digit or letter in C#?

Program


using System;

public class ConsoleApp
{
    public static void Main(string[] args)
    {
        //Members of System.Char
        char MyChar = 'H';
        Console.WriteLine("Is MyChar digit? => {0}",char.IsDigit(MyChar));
        Console.WriteLine("Is MyChar letter? => {0}",char.IsLetter(MyChar));
        Console.ReadLine();
    }
}

Output


Is MyChar digit? => False
Is MyChar letter? => True

Parsing values from string data

The .NET data types provide the ability to generate a variable of their underlying type given a textual equivalent (e.g., parsing). This technique can be extremely helpful when you want to convert some user input data (such as a selection from a GUI-based, drop-down list box) into a numerical value. Consider the following parsing logic:

How to parse data from string to other datatype?

Program


using System;

public class ConsoleApp
{
    public static void Main(string[] args)
    {
        //Parsing data from string
        //string to bool
        bool b = bool.Parse("True");
        Console.WriteLine("b: {0}",b);
        //string to double
        double d = double.Parse("96.656");
        Console.WriteLine("d: {0}",d);
        //string to int
        int i = int.Parse("987");
        Console.WriteLine("i: {0}",i);
        //string to char
        char c = char.Parse("c");
        Console.WriteLine("c: {0}",c);
        Console.ReadLine();
    }
}

Output


b: True
d: 96.656
i: 987
c: c

System.DateTime

The System namespace defines a few useful data types for which there are no C# keywords, such as the DateTime and TimeSpan structures.

The DateTime type contains data that represents a specific date (month, day, year) and time value, both of which may be formatted in a variety of ways using the supplied members.

Find day of week from DateTime instance in C#


DateTime dt = new DateTime(1997,09,27);
Console.WriteLine("day is {0}",dt.DayOfWeek);

How to extract day, month or year from DateTime instance?


DateTime dt = new DateTime(1997,09,27);
Console.WriteLine("Day is {0}",dt.Day);
Console.WriteLine("month is {0}",dt.Month);
Console.WriteLine("year is {0}",dt.Year);

How to add day, month or year in DateTime instance?


DateTime dt = new DateTime(1997,09,27);
dt = dt.AddDays(2);
dt = dt.AddMonths(1);
dt = dt.AddYears(4);

Sample program of DateTime


using System;

public class ConsoleApp
{
    public static void Main(string[] args)
    {
        DateTime dt = new DateTime(1997,09,27);
        Console.WriteLine("day of week is {0}",dt.DayOfWeek);
        Console.WriteLine("day of year is {0}",dt.DayOfYear);
        Console.WriteLine("date is {0}",dt.Date);
        //Extract day, month, year form DateTime
        Console.WriteLine("Day is {0}",dt.Day);
        Console.WriteLine("month is {0}",dt.Month);
        Console.WriteLine("year is {0}",dt.Year);
        //Add day, month, year form DateTime
        dt = dt.AddDays(2);
        dt = dt.AddMonths(1);
        dt = dt.AddYears(4);
        Console.WriteLine("After adding date is: {0}",dt.Date);
        Console.WriteLine("Is day light saving time: {0}",dt.IsDaylightSavingTime());
        Console.ReadLine();

    }
}

Output


day of week is Saturday
day of year is 270
date is 09/27/1997 00:00:00
Day is 27
month is 9
year is 1997
After adding date is: 10/29/2001 00:00:00
Is day light saving time: False

what is DayLightSavingTime() in C#?

It ndicates whether this instance of System.DateTime is within the daylight saving time range for the current time zone.

It returns true if the value of the System.DateTime.Kind property is System.DateTimeKind.Local or System.DateTimeKind.Unspecified and the value of this instance of System.DateTime is within the daylight saving time range for the local time zone; false if System.DateTime.Kind is System.DateTimeKind.Utc. To know more about what daylight saving time commonly know as DST go to
To know more about properties and methods of System.DateTime go to:

System.TimeSpan

The TimeSpan structure allows you to easily define and transform units of time using various members.

How to add or subtract time is TimeSpan instance ?


TimeSpan ts = new TimeSpan(8, 15, 0);
//to add or subtract time in TimeSpan instance
Console.WriteLine(ts.Add(new TimeSpan(2,30,0)));

TimeSpan.Add() and TimeSpan.Subtract(): returns A new object that represents the value of this instance plus/minus the value of ts.

How to extract hour, minute or second from TimeSpan instance ?


TimeSpan ts = new TimeSpan(8, 15, 0);
Console.WriteLine("Hour: {0}",ts.Hours);
Console.WriteLine("Minutes: {0}", ts.Minutes);
Console.WriteLine("Seconds: {0}", ts.Seconds);

Sample program of System.TimeSpan


using System;

public class ConsoleApp
{
    public static void Main(string[] args)
    {
        TimeSpan ts = new TimeSpan(8, 15, 0);
        //to add time in TimeSpan instance
        Console.WriteLine("After adding: {0}",ts.Add(new TimeSpan(2,30,0)));
        Console.WriteLine("After subtracting: {0}",ts.Subtract(new TimeSpan(1,23,45)));
        Console.WriteLine("Hour: {0}",ts.Hours);
        Console.WriteLine("Minutes: {0}", ts.Minutes);
        Console.WriteLine("Seconds: {0}", ts.Seconds);
        Console.ReadLine();
    }
}

Output


After adding: 10:45:00
After subtracting: 06:51:15
Hour: 8
Minutes: 15
Seconds: 0

Programers who are from JAVA remember that DateTime and TimeSpan are structers C# while in JAVA everything is class.

Datatype and keyword

noreply@blogger.com (Anonymous) — Wed, 13 Dec 2017 07:23:00 +0000

Like any programming language, C# defines keywords for fundamental data types, which are used to represent local variables, class data member variables, method return values, and parameters. Unlike other programming languages, however, these keywords are much more than simple compiler- recognized tokens. Rather, the C# data type keywords are actually shorthand notations for full-blown types in the System namespace.

Table lists each system data type, its range, the corresponding C# keyword, and the type’s compliance with the common language specification (CLS).

C# keyword	System type	Range	Meaning	CLS complaint?
bool	System.Boolean	true or false	Represents truth or falsity	Yes
sbyte	System.SByte	-128 to 127	signed 8-bit number	No
byte	System.Byte	0 to 255	Unsigned 8-bit number	Yes
short	System.Int16	-32768 to 32767	signed 16-bit number	Yes
ushort	System.UInt16	0 to 65535	Unsigned 16-bit number	No
int	System.Int32	–2,147,483,648 to 2,147,483,647	Signed 32-bit number	Yes
uint	System.UInt32	0 to 4,294,967,295	Unsigned 32-bit number	No
long	System.Int64	–9,223,372,036,854,775, 808 to 9,223,372,036,854,775,807	Signed 64-bit to number	Yes
ulong	System.UInt64	0 to 18,446,744,073,709,551,615	Unsigned 64-bit number	No
char	System.Char	U+0000 to U+ffff	Single 16-bit Unicode character	Yes
float	System.Single	-3.4 10³⁸ to +3.4 10³⁸	32-bit floating-point number	Yes
double	System.Double	±5.0 10^–324 to ±1.7 10³⁰⁸	64-bit floating-point number	Yes
decimal	System.Decimal	(-7.9 x 10²⁸ to 7.9 x 10²⁸)/(10^{0 to 28})	128-bit signed number	Yes
string	System.String	Limited by system memory	Represents a set of Unicode characters	Yes
object	System.Object	Can store any data type in an object variable	The base class of all types in the .NET universe	Yes

CLS-compliant .NET code can be used by any managed programming language. If you expose non–CLS-compliant data from your programs, other .NET languages might not be able to make use of it.

Variable declaration and initialization

When you are declaring a local variable (e.g., a variable within a member scope), you do so by specifying the data type followed by the variable’s name.

Syntax


datatype var_name;

Example


static void  Localvariable()
{
    int MyInt;
    double MyDouble;
    string MyString;
}

Be aware that it is a compiler error to make use of a local variable before assigning an initial value. Given this, it is good practice to assign an initial value to your local data points at the time of declaration. You may do so on a single line


static void  Localvariable()
{
    //datatype varName =  initialValue
    int MyInt = 0;
    double MyDouble = 10;
    string MyString = "my string";
}

or by separating the declaration and assignment into two code statements.


static void  Localvariable()
{
    //datatype varName;
    //varName = initialValue;
    int MyInt;
    Myint = 0;
    string MyString;
    MyString = "my string";
}

It is also permissible to declare multiple variables of the same underlying type on a single line of code, as in the following three bool variables:


static void  Localvariable()
{
    bool b1 = true, b2 = false, b3 = false;
}

Since the C# bool keyword is simply a shorthand notation for the System.Boolean structure, it is also possible to allocate any data type using its full name (of course, the same point holds true for any C# data type keyword). Here is the final implementation, which illustrates various ways to declare a local variable:


static void  Localvariable()
{
    System.Boolean b1 = true;
    System.String str = "system string";
}

Example program of local variable

Program


using System;

public class ConsoleApp
{
    public static void Main(string[] args)
    {
        Localvariable();
        Console.ReadLine();
    }

    static void  Localvariable()
    {
        //datatype varName
        int MyInt;
        double MyDouble;
        string MyString;
        //varName = initialValue
        MyInt = 5;
        MyDouble = 30;
        MyString = "my string";
        System.Boolean b1 = true;
        System.String str = "system string";
        Console.WriteLine("int: {0}",MyInt);
        Console.WriteLine("bool: {0}", b1);
        Console.WriteLine("string: {0}",str);
    }
}

Output


int: 5
bool: True
string: system string

Intrinsic datatype and the new operator

All intrinsic data types support what is known as a default constructor. This feature allows you to create a variable using the new keyword, which automatically sets the variable to its default value.

bool variables are set to false.

Numeric data is set to 0 (or 0.0 in the case of floating-point data types).
char variables are set to a single empty character.
Object references (including strings) are set to null.

It is more cumbersome to use the new keyword when creating a basic data type variable.

Program


using System;

public class ConsoleApp
{
    public static void Main(string[] args)
    {
        WithNew();
        Console.ReadLine();
    }

    static void  WithNew()
    {
        //create variable using new
        bool b = new bool();
        Console.WriteLine(b);
        int i = new int();
        Console.WriteLine(i);
        object o = new object();
        Console.WriteLine(o);
    }
}

Output


False
0
System.Object

Datatype class hierarchy

It is interesting to note that even the primitive .NET data types are arranged in a class hierarchy. The relationship between these core system types can be understood with below image: This hierarchy based on inhatitance concept. If you are new to inheritance see the inharitance article of c#.

Notice that each type ultimately derives from System.Object.

System.Console

noreply@blogger.com (Anonymous) — Tue, 12 Dec 2017 18:02:00 +0000

It is true that a console user interface (CUI) may not be as enticing as a graphical user interface (GUI) or web application, restricting the early examples to console programs will allow you to keep focused on the syntax of C# and the core aspects of the .NET platform, rather than dealing with the complexities of building desktop GUIs or web sites.As its name implies, the Console class encapsulates input, output, and error-stream manipulations for console-based applications.

As you can see in below table the Console class does provide some members that can spice up a simple command-line application, such as the ability to change background and foreground colors and issue beep noises in a variety of frequencies.

Members of System.Console

Member	Meaning
Beep()	This method forces the console to emit a beep of a specified frequency and duration.
BackgroundColor,ForegroundColor	These properties set the background/foreground colors for the current output.They may be assigned any member of the ConsoleColor enumeration.
BufferHeight,BufferWidth	These properties control the height/width of the console’s buffer area
Title	This property gets or sets the title of the current console.
WindowHeight, WindowWidth, WindowTop, WindowLeft	These properties control the dimensions of the console in relation to the established buffer.
Clear()	This method clears the established buffer and console display area.

Basic Input-Output

In addition to the members in above Table, the Console type defines a set of methods to capture input and output, all of which are static and are, therefore, called by prefixing the name of the class (Console) to the method name. As you know, WriteLine() pumps a text string (including a carriage return) to the output stream. The Write() method pumps text to the output stream without a carriage return. ReadLine() allows you to receive information from the input stream up until the Enter key is pressed, while Read() is used to capture a single character from the input stream.

Create a new Console Application project to understand basic I/O using the Console class and update your Main() method to call a helper method named GetInfo().Implement this method within the Program class with logic that prompts the user for some bits of information and echoes each item to the standard output stream. For example, you could ask the user for a name and age which will be treated as a text value for simplicity, rather than the expected numerical value for now.

Program


using System;

public class ConsoleApp
{
    public static void Main(string[] args)
    {
        GetInfo();
        Console.ReadLine();
    }

    static void GetInfo()
    {
        //read the data and store it in variable age and name
        Console.Write("Enter your name: ");
        string name = Console.ReadLine();
        Console.Write("Enter your age: ");
        string age = Console.ReadLine();

        //chnages the console color 
        ConsoleColor PrevColor = Console.BackgroundColor;
        Console.BackgroundColor = ConsoleColor.Red;

        Console.WriteLine("Name: {0}", name);
        Console.WriteLine("Age: {0}", age);

        //changes the console color again
        Console.BackgroundColor = ConsoleColor.Black;
    }
}

Output


Enter your name: Hansraj
Enter your age: 20
Name: Hansraj
Age: 20

Visual Studio supports a number of “code snippets” that will insert code once activated. The cw code snippet is quite useful. In that it will automatically expand to Console. WriteLine()! To test this for yourself, type in cw somewhere within your Main() method and hit the Tab key twice. sadly, there is no code snippet for Console.ReadLine()). To see all code snippets, right-click in a C# code file and choose the Insert Snippet menu option.

Formatting Console output

You might have noticed numerous occurrences of tokens such as {0} and {1} embedded within various string literals. The .NET platform supports a style of string formatting slightly akin to the printf() statement of C. Simply put, when you are defining a string literal that contains segments of data whose value is not known until runtime, you are able to specify a placeholder within the literal using this curly-bracket syntax. At runtime, the values passed into Console.WriteLine() are substituted for each placeholder. The first parameter to WriteLine() represents a string literal that contains optional placeholders designated by {0}, {1}, {2}, and so forth. Be aware that the first ordinal number of a curly-bracket placeholder always begins with 0. The remaining parameters to WriteLine() are simply the values to be inserted into the respective placeholders.

If you have more uniquely numbered curly-bracket placeholders than fill arguments, you will receive a format exception at runtime. However, if you have more fill arguments than placeholders, the unused fill arguments are ignored.

It is permissible for a given placeholder to repeat within a given string. For example

Program


using System;

public class ConsoleApp
{
    public static void Main(string[] args)
    {
        Console.WriteLine("{0}? I love {0}, I love to code in {0}", ".NET");
        Console.ReadLine();
    }
}

Output


.NET? I love .NET, I love to code in .NET

Also, know that it is possible to position each placeholder in any location within a string literal, and it need not follow an increasing sequence. For example,

Program


using System;

public class ConsoleApp
{
    public static void Main(string[] args)
    {
        Console.WriteLine("I am {1}.My age is {0}",20,"Hansraj");
        Console.ReadLine();
    }
}

Output


I am Hansraj.My age is 20

Formatting numerical data in C#

If you require more elaborate formatting for numerical data, each placeholder can optionally contain various format characters.Various format characters are given below:

Format character	Meaning
C or C	Used to format currency. By default, the flag will prefix the local cultural symbol (a dollar sign [$] for U.S. English)
D or d	Used to format decimal numbers. This flag may also specify the minimum number of digits used to pad the value
E or e	Used for exponential notation. Casing controls whether the exponential constant is uppercase (E) or lowercase (e)
F or f	Used for fixed-point formatting. This flag may also specify the minimum number of digits used to pad the value
G or g	Stands for general. This character can be used to format a number to fixed or exponential format
N or n	Used for basic numerical formatting (with commas)
X or x	Used for hexadecimal formatting. If you use an uppercase X, your hex format will also contain uppercase characters

Program


using System;

public class ConsoleApp
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Currency format: {0:c}", 1000);
        Console.WriteLine("Decimal format: {0:d6}", 9999);
        Console.WriteLine("Exponential upper: {0:E}", 9999);
        Console.WriteLine("Exponential lower: {0:e}", 9999);
        Console.WriteLine("Fixed point: {0:f3}",9999.12345);
        Console.WriteLine("Genralformat: {0:g3}",9999.12345);
        Console.WriteLine("Hex format upper: {0:X}",9999);
        Console.WriteLine("Hex format lower: {0:x}",9999);
        Console.ReadLine();
    }
}

Output


Currency format: ¤1,000.00
Decimal format: 009999
Exponential upper: 9.999000E+003
Exponential lower: 9.999000e+003
Fixed point: 9999.123
Genralformat: 1e+04
Hex format upper: 270F
Hex format lower: 270f

Be aware that the use of the .NET string formatting characters is not limited to console programs. This same formatting syntax can be used when calling the static string.Format() method. This can be helpful when you need to compose textual data at runtime for use in any application type (e.g., desktop GUI app, ASP.NET web app, and so forth).

The string.Format() method returns a new string object, which is formatted according to the provided flags. After this point, you are free to use the textual data as you see fit. For example, assume you are building a graphical WPF desktop application and need to format a string for display in a message box. The following code illustrates how to do so, but be aware that this code will not compile until you reference the PresentationFramework.dll assembly.

To reference PresentationFramework.dll click on Project>Add reference..>choose the library which you want to add in your program

For now add PresentationFramework.dll in your program.

Program


using System;

public class ConsoleApp
{
    public static void Main(string[] args)
    {
        //use string.Format() to format string literal
        string msg = string.Format("Hex value of 9999 is {0:f}",9999);
        /*You need to reference PresentationFramework.dll 
         * in order to compile this line of code! */
        System.Windows.MessageBox.Show(msg);
    }
}

To see the output copy this program in visual studio.Don't forget to add PresentationFramework.dll library and run the program.

System.Environment

noreply@blogger.com (Anonymous) — Sun, 10 Dec 2017 16:27:00 +0000

Environment class allows you to obtain a number of details regarding the operating system currently hosting your .NET application using various static members. To illustrate the usefulness of System.Environment, update your Main() method to call a helper method named EnvironmentDetails().

Properties	Meaning
ExitCode	Gets or sets the exit code for the application
Is64BitOperatingSystem	Returns a bool to represent whether the host machine is running a 64-bit OS
MachineName	Gets the name of the current machine
NewLine	Gets the newline symbol for the current environment
SystemDirectory	Returns the full path to the system directory
UserName	Returns the name of the user that started this application
Version	Returns a Version object that represents the version of the .NET platform

Create EnvironmentDetails() method in class under Main() method and call this method in Main() method.

Program

 
using System;

public class ConsoleApp
{
    public static void Main(string[] args)
    {
        //implement this method in this class
        EnvironmentDetails();
        Console.ReadLine();
    }

    static void EnvironmentDetails()
    {
        //prints current OS version
        Console.WriteLine("OS version: {0}", Environment.OSVersion);
        //prints all the drives of current machine
        foreach (string drive in Environment.GetLogicalDrives())
        {
            Console.WriteLine("drive {0}", drive);
        }
        //prints no of processor in current machine
        Console.WriteLine("No of processors: {0}", Environment.ProcessorCount);
        //prints current .NET version in which program is running
        Console.WriteLine(".NET version: {0}", Environment.Version);
        //Gets or sets the exit code for the application
        Console.WriteLine("exit code: {0}", Environment.ExitCode);
        //Returns a bool to represent whether the host machine is running a 64-bit OS
        Console.WriteLine("64 bit? : {0}", Environment.Is64BitOperatingSystem);
        //Gets the name of the current machine
        Console.WriteLine("Machine name: {0}", Environment.MachineName);
        //Gets the newline symbol for the current environment
        Console.WriteLine("New line symbol: {0}", Environment.NewLine);
        //Returns the full path to the system directory
        Console.WriteLine("System directory : {0}", Environment.SystemDirectory);
        //Returns the name of the user that started this application
        Console.WriteLine("Username : {0}", Environment.UserName);
    }
}

Output


OS version: Unix 4.8.0.41
drive /
drive /usr/lib/cache
drive /etc/resolv.conf
drive /etc/hostname
drive /etc/hosts
No of processors: 2
.NET version: 4.0.30319.42000
exit code: 0
64 bit? : True
Machine name: jdoodle
New line symbol: 

System directory : 
Username : root

How to make editor with live changes of HTML, CSS and JS?

noreply@blogger.com (Anonymous) — Sun, 10 Dec 2017 14:54:00 +0000

Have you heard about Text editor with live changes of HTML , CSS and JAVASCRIPT ?

Get a real-time connection to your output. Make changes to CSS and HTML and JS you'll instantly see those changes on screen.

Number of that kind of editors are available online.

In this article we will see how it works ?

code is given below:

HTML

 
<table>
 <tr>
  <td>
   <pre id="html" class="content" contenteditable>
    
   </pre>
  </td>
  <td rowspan="3" id="Output">
   <iframe id="output"></iframe>
  </td>
 </tr>
 <tr>
  <td>
   <pre id="css" class="content" contenteditable>
   
   </pre>
  </td>
 </tr>
 <tr>
  <td>
   <pre id="js" class="content" contenteditable>

   </pre>
  </td>
 </tr>
</table>

CSS

 
pre::before{
 font-size: 16px;
 content: attr(id);
 position: absolute;
 top: 0;
 background-color: #333;
 padding: 10px;
 left: 0;
 right: 0;
 color: #ccc;
 text-transform: uppercase;
 display: block;
 margin: 0 0 15px 0;
 font-weight: bold;
}
html,body,table,iframe{
 border:0;
 height:100%;
 margin:0;
 padding:0;
 width:100%;
}
iframe{
 min-width: 50%;
 position: fixed;
}
td{
 border:2px solid black;
 height:33.33%;
 padding:36px 5px 5px 5px;
 position:relative;
 vertical-align:top;
 width:50%;
 font-family: monospace;
 font-size: 17px;
 max-width: 50%;
}
pre{
 max-height: 100%;
 max-width: 100%;
 overflow: auto;
 margin-top: -0.5px;
 white-space: pre-wrap; 
}

JAVASCRIPT

 
window.onload=function(){
 var html=document.getElementById("html"),
  css=document.getElementById("css"),
  js=document.getElementById("js"),
  output=document.getElementById("output"),
  working=false,
  fill=function(){
   if(working){
    return false;
   }
   working=true;
   var document=output.contentDocument,
    style=document.createElement("style"),
    script=document.createElement("script");
   document.body.innerHTML=html.textContent;
   style.innerHTML=css.textContent.replace(/\s/g,"");
   script.innerHTML=js.textContent;
   document.body.appendChild(style);
   document.body.appendChild(script);
   working=false;
  };
 html.onkeyup=fill;
 css.onkeyup=fill;
 js.onkeyup=fill;
}

see output of this code: Type some code in HTML CSS and JS box in this output and see live preview.

Command line argument

noreply@blogger.com (Anonymous) — Sat, 09 Dec 2017 18:30:00 +0000

With the first introduction post of C# you can understand the return value of the Main() method, let’s examine the incoming array of string data. Assume that you now want to update your application to process any possible command-line parameters. One way to do so is using a C# for loop. We will see for loop in C# in later article.

Accessing command line arguments with for loop

Program


using System;

public class CLA
{
    public static void Main(string[] args)
    {
        //this loop prints any number of given command line arguments
        for(int i=0; i<args.Length; i++)
        {
            Console.WriteLine("arg-" + i + " = " + args[i]);
        }
    }
}

Output


F:\Code\Algorithm>csc CLA.cs

F:\Code\Algorithm>CLA tangled java elaborately
arg-0 = tangled
arg-1 = java
arg-2 = elaborately

Explanation

Here, you are checking to see whether the array of strings contains some number of items using the Length property of System.Array. As you’ll see in later article, all C# arrays actually alias the System.Array class and, therefore, share a common set of members. As you loop over each item in the array, its value is printed to the console window. Supplying the arguments at the command line is equally simple, as shown in output above.

Accessing command line arguments with foreach loop

As an alternative to the standard for loop, you may iterate over an incoming string array using the C# foreach keyword. Here is sample usage :

Program


using System;

public class CLA
{
    public static void Main(string[] args)
    {
        //you don't need to specify length property of array when using foreach loop
        foreach (string arg in args)
        {
            Console.WriteLine("Arg: {0}",arg);
        }
    }
}

Output


F:\Code\Algorithm>csc CLA.cs

F:\Code\Algorithm>CLA tangled java elaborately
Arg: tangled
Arg: java
Arg: elaborately

Accessing command line arguments with GetCommandLineArgs()

You are also able to access command-line arguments using the static GetCommandLineArgs() method of the System.Environment type. The return value of this method is an array of strings. The first index identifies the name of the application itself, while the remaining elements in the array contain the individual command-line arguments. Note that when using this approach, it is no longer necessary to define Main() as taking a string array as the input parameter, although there is no harm in doing so.

Program


using System;

public class CLA
{
    public static void Main()
    {
        //command line arguments are stored in string typed array args
        string[] args = Environment.GetCommandLineArgs();
        //remember when using this method in output first argument is always filename
        foreach(string arg in args)
        {
            Console.WriteLine("Args: {0}",arg);
        }
    }
}

Output


F:\Code\Algorithm>csc CLA.cs

F:\Code\Algorithm>CLA tangled java elaborately
Args: CLA
Args: tangled
Args: java
Args: elaborately

Explanation

It is up to you to determine which command-line arguments your program will respond to (if any) and how they must be formatted.

Specifying Command-Line Arguments with Visual Studio

During the development cycle, you might want to specify possible command-line flags for testing purposes. To do so with Visual Studio, double-click the Properties icon in Solution Explorer and select the Debug tab on the left side. From there, specify values using the command-line arguments text box and save your changes.

Program


using System;

public class ConsoleApp
{  
    public static void Main(string[] args)
    {
        for(int i=0; i<args.Length; i++)
        {
            Console.WriteLine("Arg-{0} = {1}",i,args[i]);
        }
        Console.ReadLine();
    }
}

Output


Arg-0 = tangled
Arg-1 = java
Arg-2 = elaborately

Building blocks of .NET

noreply@blogger.com (Anonymous) — Fri, 08 Dec 2017 15:59:00 +0000

In this article we view three key (and interrelated) topics that make it all possible: the CLR, CTS, and CLS.

Common Language Runtime

From a programmer’s point of view, .NET can be understood as a runtime environment and a comprehensive base class library. The runtime layer is properly referred to as the Common Language Runtime, or CLR. The primary role of the CLR is to locate, load, and manage .NET objects on your behalf. The CLR also takes care of a number of low-level details such as memory management, application hosting, coordinating threads, and performing basic security checks (among other low-level details).

Common Type System

Another building block of the .NET platform is the Common Type System, or CTS. The CTS specification fully describes all possible data types and all programming constructs supported by the runtime, specifies how these entities can interact with each other, and details how they are represented in the .NET metadata format.

Common Language Specification

Understand that a given .NET-aware language might not support every feature defined by the CTS. The Common Language Specification, or CLS, is a related specification that defines a subset of common types and programming constructs that all .NET programming languages can agree on. Thus, if you build .NET types that expose only CLS-compliant features, you can rest assured that all .NET-aware languages can consume them. Conversely, if you make use of a data type or programming construct that is outside of the bounds of the CLS, you cannot guarantee that every .NET programming language can interact with your .NET code library. Thankfully, as you will see later, it is simple to tell your C# compiler to check all of your code for CLS compliance.

Role of the base class libraries

In addition to the CLR, CTS, and CLS specifications, the .NET platform provides a base class library that is available to all .NET programming languages. Not only does this base class library encapsulate various primitives such as threads, file input/output (I/O), graphical rendering systems, and interaction with various external hardware devices, but it also provides support for a number of services required by most real-world applications.

The base class libraries define types that can be used to build any type of software application. For example, you can use ASP.NET to build web sites and REST services, WCF to build distributed systems, WPF to build desktop GUI applications, and so forth. As well, the base class libraries provide types to interact with XML documents, the directory and file system on a given computer, communicate with a relational databases (via ADO.NET), and so forth. From a high level, you can visualize the relationship between the CLR, CTS, CLS, and the base class library, as shown in image:

What's new in C#?

C# is a programming language whose core syntax looks very similar to the syntax of Java. However, calling C# a Java clone is inaccurate. In reality, both C# and Java are members of the C family of programming languages (e.g., C, Objective C, C++) and, therefore, share a similar syntax. The truth of the matter is that many of C#’s syntactic constructs are modeled after various aspects of Visual Basic (VB) and C++. For example, like VB, C# supports the notion of class properties (as opposed to traditional getter and setter methods) and optional parameters. Like C++, C# allows you to overload operators, as well as create structures, enumerations, and callback functions (via delegates). Moreover, as you work through this text, you will quickly see that C# supports a number of features traditionally found in various functional languages such as lambda expressions and anonymous types. Furthermore, with the advent of Language Integrated Query (LINQ), C# supports a number of constructs that make it quite unique in the programming landscape. Nevertheless, the bulk of C# is indeed influenced by C-based languages.

Because C# is a hybrid of numerous languages, the result is a product that is as syntactically clean (if not cleaner) as Java, is about as simple as VB, and provides just about as much power and flexibility as C++. Here is a partial list of core C# features that are found in all versions of the language:

No pointers required! C# programs typically have no need for direct pointer manipulation (although you are free to drop down to that level if absolutely necessary).
Automatic memory management through garbage collection. Given this, C# does not support a delete keyword.
Formal syntactic constructs for classes, interfaces, structures, enumerations, and delegates.
The C++-like ability to overload operators for a custom type, without the complexity.
Support for attribute-based programming. This brand of development allows you to annotate types and their members to further qualify their behavior. For example, if you mark a method with the Obsolete attribute, programmers will see your custom warning message print out if they attempt to make use of the decorated member.

With the release of .NET 2.0 (circa 2005), the C# programming language was updated to support numerous new bells and whistles, most notability the following:

The ability to build generic types and generic members. Using generics, you are able to build efficient and type-safe code that defines numerous placeholders specified at the time you interact with the generic item.
Support for anonymous methods, which allow you to supply an inline function anywhere a delegate type is required.
The ability to define a single type across multiple code files (or if necessary, as an inmemory representation) using the partial keyword,

Support for strongly typed queries (e.g., LINQ) used to interact with various forms of data.
Support for anonymous types that allow you to model the structure of a type (rather than its behavior) on the fly in code.
The ability to extend the functionality of an existing type (without subclassing) using extension methods.
Inclusion of a lambda operator (=>), which even further simplifies working with .NET delegate types.
A new object initialization syntax, which allows you to set property values at the time of object creation.

.NET 4.0 (released in 2010) updated C# yet again with a handful of features.

Support for optional method parameters, as well as named method arguments.
Support for dynamic lookup of members at runtime via the dynamic keyword.this provides a unified approach to invoking members on the fly, regardless of which framework the member implemented (COM, IronRuby, IronPython, or via .NET reflection services).
Working with generic types is much more intuitive, given that you can easily map generic data to and from general System.Object collections via covariance and contravariance.

With the release of .NET 4.5, C# received a pair of new keywords (async and await), which greatly simplify multithreaded and asynchronous programming. If you have worked with previous versions of C#, you might recall that calling methods via secondary threads required a fair amount of cryptic code and the use of various .NET namespaces. Given that C# now supports language keywords that handle this complexity for you, the process of calling methods asynchronously is almost as easy as calling a method in a synchronous manner. This brings us to the current version of C# and .NET 4.6, which introduces a number of minor features that help streamline your codebase. You will see a number of details as you go through; however, here is a quick rundown of some of the new features found in C#:

Inline initialization for automatic properties as well as support for read-only automatic properties
Single-line method implementations using the C# lambda operator
Support of “static imports” to provide direct access to static members within a namespace
A null conditional operator, which helps check for null parameters in a method implementation
A new string formatting syntax termed string interpolation
The ability to filter exceptions using the new when keyword

Colourful console program in C#

Program


using System;

namespace csharp
{
    public class ConsoleApp
    {  
        public static void Main(string[] args)
        {
            Console.Title = "My Application";
            Console.ForegroundColor = ConsoleColor.Red;
            Console.BackgroundColor = ConsoleColor.Gray;
            Console.WriteLine("Colourful learning");
            Console.ReadKey();
        }
    }
}

Output


Colourful learning

Introduction to c#

noreply@blogger.com (Anonymous) — Wed, 06 Dec 2017 06:00:00 +0000

C# is an elegant and type-safe object-oriented language that enables developers to build a variety of secure and robust applications that run on the .NET Framework. You can use C# to create Windows client applications, XML Web services, distributed components, client-server applications, database applications, and much, much more. Visual C# provides an advanced code editor, convenient user interface designers, integrated debugger, and many other tools to make it easier to develop applications based on the C# language and the .NET Framework.

C# Language

C# syntax is highly expressive, yet it is also simple and easy to learn. The curly-brace syntax of C# will be instantly recognizable to anyone familiar with C, C++ or Java. Developers who know any of these languages are typically able to begin to work productively in C# within a very short time. C# syntax simplifies many of the complexities of C++ and provides powerful features such as nullable value types, enumerations, delegates, lambda expressions and direct memory access, which are not found in Java. C# supports generic methods and types, which provide increased type safety and performance, and iterators, which enable implementers of collection classes to define custom iteration behaviors that are simple to use by client code. Language-Integrated Query (LINQ) expressions make the strongly-typed query a first-class language construct.

As an object-oriented language, C# supports the concepts of encapsulation, inheritance, and polymorphism. All variables and methods, including the Main method, the application's entry point, are encapsulated within class definitions. A class may inherit directly from one parent class, but it may implement any number of interfaces. Methods that override virtual methods in a parent class require the override keyword as a way to avoid accidental redefinition. In C#, a struct is like a lightweight class; it is a stack-allocated type that can implement interfaces but does not support inheritance.

In addition to these basic object-oriented principles, C# makes it easy to develop software components through several innovative language constructs, including the following:

Encapsulated method signatures called delegates, which enable type-safe event notifications. Properties, which serve as accessors for private member variables. Attributes, which provide declarative metadata about types at run time.

Language-Integrated Query (LINQ) which provides built-in query capabilities across a variety of data sources. If you have to interact with other Windows software such as COM objects or native Win32 DLLs, you can do this in C# through a process called "Interop." Interop enables C# programs to do almost anything that a native C++ application can do. C# even supports pointers and the concept of "unsafe" code for those cases in which direct memory access is absolutely critical.

The C# build process is simple compared to C and C++ and more flexible than in Java. There are no separate header files, and no requirement that methods and types be declared in a particular order. A C# source file may define any number of classes, structs, interfaces, and events.

.NET Framework Platform Architecture

C# programs run on the .NET Framework, an integral component of Windows that includes a virtual execution system called the common language runtime (CLR) and a unified set of class libraries. The CLR is the commercial implementation by Microsoft of the common language infrastructure (CLI), an international standard that is the basis for creating execution and development environments in which languages and libraries work together seamlessly.

Source code written in C# is compiled into an intermediate language (IL) that conforms to the CLI specification. The IL code and resources, such as bitmaps and strings, are stored on disk in an executable file called an assembly, typically with an extension of .exe or .dll. An assembly contains a manifest that provides information about the assembly's types, version, culture, and security requirements.

When the C# program is executed, the assembly is loaded into the CLR, which might take various actions based on the information in the manifest. Then, if the security requirements are met, the CLR performs just in time (JIT) compilation to convert the IL code to native machine instructions. The CLR also provides other services related to automatic garbage collection, exception handling, and resource management. Code that is executed by the CLR is sometimes referred to as "managed code," in contrast to "unmanaged code" which is compiled into native machine language that targets a specific system. The following diagram illustrates the compile-time and run-time relationships of C# source code files, the .NET Framework class libraries, assemblies, and the CLR.

From C# source code to machine execution

Language interoperability is a key feature of the .NET Framework. Because the IL code produced by the C# compiler conforms to the Common Type Specification (CTS), IL code generated from C# can interact with code that was generated from the .NET versions of Visual Basic, Visual C++, or any of more than 20 other CTS-compliant languages. A single assembly may contain multiple modules written in different .NET languages, and the types can reference each other just as if they were written in the same language. In addition to the run time services, the .NET Framework also includes an extensive library of over 4000 classes organized into namespaces that provide a wide variety of useful functionality for everything from file input and output to string manipulation to XML parsing, to Windows Forms controls. The typical C# application uses the .NET Framework class library extensively to handle common "plumbing" chores.

hello world program in C#

Start Visual Studio.
On the menu bar, choose File, New, Project.
The New Project dialog box opens.
Expand Installed, expand Templates, expand Visual C#, and then choose Console Application.
In the Name box, specify a name for your project, and then choose the OK button.
The new project appears in Solution Explorer.
If Program.cs isn't open in the Code Editor, open the shortcut menu for Program.cs in Solution Explorer, and then choose View Code.

Program


//C# hello world program
using System;

namespace Hello_World
{
    class Hello
    {
        static void Main()
        {
            Console.WriteLine("Hello World");
            //keep the console window open
            Console.ReadKey();
        }
    }
}

Output


Hello World

Explanation

The first line contains a comment. The characters // convert the rest of the line to a comment.


//C# hello world program

You can also comment out a block of text by enclosing it between the /* and */ characters.

Main method

A C# console application must contain a Main method, in which control starts and ends. The Main method is where you create objects and execute other methods. The Main method is a static method that resides inside a class or a struct. In the previous "Hello World" example, it resides in a class named Hello. You can declare the Main method in one of the following ways: 1.It can return void.


static void Main()
{
    //...
}

2.It can also return an integer.


static int Main()
{
    //...
    return 0;
}

3.With either of the return types, it can take arguments.


static void Main(string[] args)
{
    //...
}


static int Main(string[] args)
{
    //...
    return 0;
}

The parameter of the Main method, args, is a string array that contains the command-line arguments used to invoke the program. Unlike in C++, the array does not include the name of the executable (exe) file.

The call to ReadKey at the end of the Main method prevents the console window from closing before you have a chance to read the output.

C# programs generally use the input/output services provided by the run-time library of the .NET Framework. The statement System.Console.WriteLine("Hello World!"); uses the WriteLine method. This is one of the output methods of the Console class in the run-time library. It displays its string parameter on the standard output stream followed by a new line. Other Console methods are available for different input and output operations. If you include the using System; directive at the beginning of the program, you can directly use the System classes and methods without fully qualifying them. For example, you can call Console.WriteLine instead of System.Console.WriteLine

Command-Line Compilation and Execution

You can compile the "Hello World!" program by using the command line instead of the Visual Studio Integrated Development Environment (IDE). To compile and run from a command prompt

Paste the code , and then save the file as a text file. Name the file Hello.cs. C# source code files use the extension .cs.
Perform one of the following steps to open a command-prompt window: In Windows 10, on the Start menu, search for Developer Command Prompt, and then tap or choose Developer Command Prompt for VS 2017.

A Developer Command Prompt window appears.
In the command-prompt window, navigate to the folder that contains your Hello.cs file. Enter the following command to compile Hello.cs.

csc Hello.cs

If your program has no compilation errors, an executable file that is named Hello.exe is created. In the command-prompt window, enter the following command to run the program:

Hello

Association, Aggregation & Composition,

noreply@blogger.com (Anonymous) — Tue, 05 Dec 2017 16:28:00 +0000

Association

Association is relation between two separate classes which establishes through their Objects. Association can be one-to-one, one-to-many, many-to-one, many-to-many. In Object-Oriented programming, an Object communicates to other Object to use functionality and services provided by that object. Composition and Aggregation are the two forms of association.

Program


//Java program to understand the concept of association
class School
{
    private String school_name;
    School(String school_name)
    {
        this.school_name = school_name;
    }
    public String getSchoolName()
    {
        return this.school_name;
    }
}

class Student
{
    private String student_name;
    Student(String student_name)
    {
        this.student_name = student_name;
    }
    public String getStudentName()
    {
        return this.student_name;
    }
}

public class Main
{
    public static void main(String args[])
    {
        School s = new School("Sarsvati Vidyalaya");
        Student st = new Student("Hansraj Rami");
        System.out.println(st.getStudentName() + " is student of " + s.getSchoolName());
        //school can have many number of students so it is one to many relationship
    }
}

Output


Hansraj Rami is student of Sarsvati Vidyalaya

Explanation

In above exmaple we have created two separate classes School and Student. school can have many number students so it is one to many relationship.

Aggregation

It is a special form of Association where:

It represents Has-A relationship.
It is a unidirectional association i.e. a one way relationship. For example, school can have students but vice versa is not possible and thus unidirectional in nature.
In Aggregation, both the entries can survive individually which means ending one entity will not effect the other entity

Program


//java program to understand the concept of composition
class Circle
{
    // aggregation
    Square_operation s;
    double PI = 3.14;
    double area(int radius)
    {
        s = new Square_operation();
        int r_sq = s.square(radius);
        return PI*r_sq;
    }
}

class Square_operation
{
    int square(int r)
    {
        return r*r;
    }
}

public class Main
{
    public static void main(String args[])
    {
        Circle c = new Circle();
        System.out.println(c.area(10));
    }
}

Output


314.0

Explanation

Consider above example, Circle object contains informations such as PI. It contains one more object named Square_operation, which contains its own information such as radius.So, there is a HAS-A relationship between class Circle and Square_operation.

Why and when do we use Aggregation?

Code reuse is best achieved by aggregation. Inheritance should be used only if the relationship IS-A is maintained throughout the lifetime of the objects involved; otherwise, aggregation is the best choice.

Composition

Composition is a restricted form of Aggregation in which two entities are highly dependent on each other.

It represents part-of relationship.
In composition, both the entities are dependent on each other.
When there is a composition between two entities, the composed object cannot exist without the other entity.

Program


//java program to understand the concept of composition
class Library
{
    //library can have no of books
    //book does not exist without library 
    // so there is strong relationship it is called composition
    Book b;
    Library(String bookname)
    {
        b = new Book(bookname);
        b.getBookInfo();
    }
}

class Book
{
    String bookname;

    Book(String bookname)
    {
        this.bookname = bookname;
    }

    public void getBookInfo()
    {
        System.out.println(bookname);
    }
}

public class Main
{
    public static void main(String args[])
    {
        Library l = new Library("Hemlet");
    }
}

Output


Hemlet

Explanation

In above example a library can have no. of books on same or different subjects. So, If Library gets destroyed then All books within that particular library will be destroyed. i.e. book can not exist without library. That’s why it is composition.

Difference between Association, Aggregation and Composition

In Object-oriented programming, one object is related to other to use functionality and service provided by that object. This relationship between two objects is known as the association in object oriented general software design and depicted by an arrow in Unified Modelling language or UML. Both Composition and Aggregation are the form of association between two objects, but there is a subtle difference between composition and aggregation, which is also reflected by their UML notation. We refer association between two objects as Composition, when one class owns other class and other class can not meaningfully exist, when it's owner destroyed, for example, Human class is a composition of several body parts including Hand, Leg and Heart. When human object dies, all it's body part ceased to exist meaningfully, this is one example of Composition.

Programmers often confuse between Association, Composition and Aggregation in Object oriented design discussions, this confusion also makes the difference between Association, Composition and Aggregation one of the popular questions in Java Interviews, only after the difference between abstract class and interface .

Another example of Composition is Car and it's part e.g. engines, wheels etc. Individual parts of the car can not function when a car is destroyed. While in the case of Aggregation, including object can exists without being part of the main object e.g. a Player which is part of a Team, can exist without a team and can become part of other teams as well.

Another example of Aggregation is Student in School class, when School closed, Student still exist and then can join another School or so. In UML notation, a composition is denoted by a filled diamond, while aggregation is denoted by an empty diamond, which shows their obvious difference in terms of strength of the relationship.

The composition is stronger than Aggregation. In Short, a relationship between two objects is referred as an association, and an association is known as composition when one object owns other while an association is known as aggregation when one object uses another object.

Inheritance

noreply@blogger.com (Anonymous) — Sun, 03 Dec 2017 19:50:00 +0000

Inheritance in Java

Classes in Java exist in a hierarchy. A class in Java can be declared as a subclass of another class using the extends keyword. A subclass inherits variables and methods from its superclass and can use them as if they were declared within the subclass itself:

Important terminology in inheritance

Super Class: The class whose features are inherited is known as super class(or a base class or a paren class).

Sub Class: The class that inherits the other class is known as sub class(or a derived class, extended class, or child class). The subclass can add its own fields and methods in addition to the superclass fields and methods.

Reusability: Inheritance supports the concept of “reusability”, i.e. when we want to create a new class and there is already a class that includes some of the code that we want, we can derive our new class from the existing class. By doing this, we are reusing the fields and methods of the existing class.

Inheritance represents the IS-A relationship, also known as parent-child relationship.The keyword used for inheritance is extends.

Syntax


class derived-class extends base-class  
{  
   //methods and fields  
}

The extends keyword indicates that you are making a new class that derives from an existing class. The meaning of "extends" is to increase the functionality.

Use of inheritance in Java

1. For Method Overriding (so runtime polymorphism can be achieved).

2. For Code Reusability.

Program


class Animal
{
    int weight;
    String name;

    void walking()
    {
        System.out.println("Animal is walking");
    }
}

//extends the properties of superclass Animal
class Cat extends Animal
{
    
}

public class Main
{
    public static void main(String args[])
    {
        Cat c = new Cat();
        // Accessing variable of superclass with instance of subclass
        c.name = "minii";
        c.weight = 8;
        System.out.println("name = " + c.name + " weight = " + c.weight);
        // Accessing method of superclass with instance of subclass
        c.walking();
    }
}

Output


name = minii weight = 8
Animal is walking

Explanation

As displayed in the above program, Cat is the subclass and Animal is the superclass. Relationship between two classes is Cat IS-A Animal.It means that Cat is a type of Animal.

In the above example, Cat object can access the field and method of own class as well as of Animal class i.e. code reusability.

Types of inheritance in Java

Below are the different types of inheritance which is supported by Java. 1. Single Inheritance : In single inheritance, subclasses inherit the features of one superclass. In image below, the class A serves as a base class for the derived class B.

Single inheritance example in Java

Program


class Creature
{
    void eating()
    {
        System.out.println("Eating...");
    }
}

//extends the properties of superclass Creature
class Cat extends Creature
{
    void walking()
    {
        System.out.println("Walking...");
    }
}

public class Main
{
    public static void main(String args[])
    {
        Cat c = new Cat();
        // Accessing method of superclass with instance of subclass
        c.eating();
        c.walking();
    }
}

Output


Eating...
Walking...

2. Multilevel Inheritance : In Multilevel Inheritance, a derived class will be inheriting a base class and as well as the derived class also act as the base class to other class. In below image, the class A serves as a base class for the derived class B, which in turn serves as a base class for the derived class C. In Java, a class cannot directly access the grandparent’s members.

Multlevel inheritance example in Java

Program


class grand_parent
{
    void gp()
    {
        System.out.println("I am grand parent");
    }
}

//extends the properties of superclass grand_parent
class parent extends grand_parent
{
    void p()
    {
        System.out.println("I am parent");
    }
}

//extends the properties of superclass parent
class child extends parent
{
    void c()
    {
        System.out.println("I am child");
    }
}

public class Main
{
    public static void main(String args[])
    {
        child c = new child();
        // Accessing method of superclass with instance of subclass
        c.c();
        c.p();
        c.gp();
    }
}

Output


I am child
I am parent
I am grand parent

3. Hierarchical Inheritance : In Hierarchical Inheritance, one class serves as a superclass (base class) for more than one sub class.In below image, the class A serves as a base class for the derived class B and C.

Program


class Creature
{
    void eating()
    {
        System.out.println("Eating...");
    }
}

//extends the properties of superclass Creature
class Cat extends Creature
{
    void walking()
    {
        System.out.println("Walking...");
    }
}

//extends the properties of superclass Creature
class crow extends Creature
{
    void flying()
    {
        System.out.println("Flying...");
    }
}

public class Main
{
    public static void main(String args[])
    {
        Cat c = new Cat();
        crow c2 = new crow();
        // Accessing method of superclass with instance of subclass
        c.eating();
        c.walking();
        c2.eating();
        c2.flying();
    }
}

Output


Eating...
Walking...
Eating...
Flying...

4. Multiple Inheritance (Through Interfaces) : In Multiple inheritance ,one class can have more than one superclass and inherit features from all parent classes. Please note that Java does not support multiple inheritance with classes. In java, we can achieve multiple inheritance only through Interfaces. In image below, Class C is derived from interface A and B.

Why multiple inheritance is not supported in Java?

To reduce the complexity and simplify the language, multiple inheritance is not supported in java. Consider a scenario where A, B and C are three classes. The C class inherits A and B classes. If A and B classes have same method and you call it from child class object, there will be ambiguity to call method of A or B class. Since compile time errors are better than runtime errors, java renders compile time error if you inherit 2 classes. So whether you have same method or different, there will be compile time error now.

Program


class Creature
{
    void eating()
    {
        System.out.println("Creature");
    }
}

class Animal
{
    void walking()
    {
        System.out.println("Animal");
    }
}

//for example purpose
class crow extends Creature,Animal
{
    void bird()
    {
        System.out.println("Animal and Creature");
    }
}

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

Output


compile time error occurs

5.Hybrid Inheritance(Through Interfaces) : It is a mix of two or more of the above types of inheritance. Since java doesn’t support multiple inheritance with classes, the hybrid inheritance is also not possible with classes. In java, we can achieve hybrid inheritance only through Interfaces.

Important facts about inheritance in Java

Default superclass: Except Object class, which has no superclass, every class has one and only one direct superclass (single inheritance). In the absence of any other explicit superclass, every class is implicitly a subclass of Object class.

Superclass can only be one: A superclass can have any number of subclasses. But a subclass can have only one superclass. This is because Java does not support multiple inheritance with classes. Although with interfaces, multiple inheritance is supported by java.

Inheriting Constructors: A subclass inherits all the members (fields, methods, and nested classes) from its superclass. Constructors are not members, so they are not inherited by subclasses, but the constructor of the superclass can be invoked from the subclass.

Private member inheritance: A subclass does not inherit the private members of its parent class. However, if the superclass has public or protected methods(like getters and setters) for accessing its private fields, these can also be used by the subclass.

static keyword in Java

noreply@blogger.com (Anonymous) — Sat, 02 Dec 2017 18:10:00 +0000

static keyword in Java

The static keyword in java is used for memory management mainly. We can apply java static keyword with variables, methods, blocks and nested class. The static keyword belongs to the class than instance of the class.

static members

Instance variables and methods are associated with and accessed through an instance of the class (i.e., through a particular object). In contrast, members that are declared with the static modifier live in the class and are shared by all instances of the class. Variables declared with the static modifier are called static variables or class variables; similarly, these kinds of methods are called static methods or class methods.

The static variable can be used to refer the common property of all objects (that is not unique for each object) e.g. company name of employees,college name of students etc. The static variable gets memory only once in class area at the time of class loading.static keyword saves memory reasources and make program more efficient.

Without static variable


class Employee
{  
     int emp_no;  
     String name;  
     String department="IT";  
}

Suppose there are 1000 employees in my department, now all instance data members will get memory each time when object is created.All employee have its unique emp_no and name so instance data member is good.Here, department refers to the common property of all objects.If we make it static,this field will get memory only once.

Example of static variable

Program


class Employee
{  
   int emp_no;  
   String name;  
   // department is static variable so it will allocate
   //memory only once at compile time
   static String department ="IT";  
     
   Employee(int e,String n)
   {  
        emp_no = e;  
        name = n;  
   }  
    void display ()
    {
        System.out.println("emp_no " + emp_no + " department = " + department);
    }  
}

public class Main
{
     public static void main(String args[])
     {  
         Employee e1 = new Employee(111,"raj");  
         Employee e2 = new Employee(222,"aditya");  
         e1.display();  
         e2.display();  
     }  
}

Output


emp_no = 111 department = IT
emp_no = 222 department = IT

Explanation

Static members can be accessed like instance members. Inside our class, we can refer to it like any other variables.However, since static members exist in the class itself, independent of any instance, we can also access them directly through the class. We don’t need a object to get or set the variable; instead, we can use the class to select the variable.

Program


public class Main
{
    //initialize counter variable
    static int counter = 0;
    
    Main()
    {
        counter++;
    }
    
    public static void main (String[] args) 
    {
        new Main();
        new Main();
        new Main();
        new Main();
        // accessing static member through classname
        System.out.println(Main.counter);
    }
}

Output

Explanation

In this example, we have created an instance variable named counter which is incremented in the constructor. Since this is variable so gets the memory at the compile time , each object is sharing the instance variable, if it is incremented, it will reflect to other objects. So each objects will increment the value of shared variable in the counter variable.Static variables are, essentially, global variables.

We can create static variables at class-level only.see below code:


class Main
{
   public static void main(String args[]) 
   { 
        System.out.println(fun());
   }
   static int fun()
   {
       //static variables are allowed at class level only
        static int x= 10;  //Error: Static local variables are not allowed
        return x--;
   }
}

Explanation

The above code will give the error.

static block

static block and static variables are executed in order they are present in a program.

Program


// static blocks and variables
class Main
{
    // static variable
    static int a = m1(); // 2
     
    // static block
    static // 5
    {
        System.out.println("We are inside static block"); // 6
    }
     
    // static method
    static int m1() // 3
    {
        System.out.println("We are inside method m1"); .// 4
        return 20; // 7
    }

    // static main method
    public static void main(String[] args)
    {
       System.out.println("Value of a : "+ a); // 1 // 9
       System.out.println("We are inside main method"); // 8
    }
}

Output


We are inside method m1
We are inside static block
Value of a : 20
We are inside main method

static methods

When a method is declared with static keyword, it is known as static method. The most common example of a static method is main( ) method.As discussed above, Any static member can be accessed before any objects of its class are created, and without reference to any object.Methods declared as static have several restrictions:

They can only directly call other static methods.
They can only directly access static data.
They cannot refer to this or super in any way.

Program


class cl
{
    int a = 10;
}

// java program to demonstrate restriction on static methods
class Test extends cl
{
    // static variable
    static int a = 10;
     
    // instance variable
    int b = 20;
     
    // static method
    static void m1()
    {
        //method m1 is static so it can access it and modify it
        a = 20;
        System.out.println("inside m1");
         
         // Cannot make a static reference to the non-static field b
         b = 10; // compilation error
                 
         // Cannot make a static reference to the 
        // non-static method m2() from the type Test
         m2();  // compilation error
          
         //  Cannot use super in a static context
         System.out.println(super.a); // compiler error 
    }
     
    // instance method
    void m2()
    {    
        System.out.println("from m2");
    }

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

Output


Main.java:23: error: non-static variable b cannot be referenced from a static context
         b = 10; // compilation error
         ^
Main.java:27: error: non-static method m2() cannot be referenced from a static context
         m2();  // compilation error
         ^
Main.java:30: error: non-static variable super cannot be referenced from a static context
         System.out.println(super.a); // compiler error
                            ^
3 errors

extends keyword which is used in above program we will learn about this when we see inheritance.

static final variable in Java

In Java, non-static final variables can be assigned a value either in constructor or with the declaration. But, static final variables cannot be assigned value in constructor; they must be assigned a value with their declaration.Such behavior is obvious as static variables are shared among all the objects of a class; creating a new object would change the same static variable which is not allowed if the static variable is final.

Program


class Main
{
    //since this variable is not static
    final int a;
    Main()
    {
        //it can be initialize by constructor
        a = 10;
    }

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

Explanation

The above program works fine but if variable is static final it can not be initialized by constructor.see program below...

Program


class Main
{
    //since this variable is static
    static final int a;
    Main()
    {
        //it can not be initialize by constructor
        a = 10;
    }

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

Output


Main.java:8: error: cannot assign a value to final variable a
        a = 10;
        ^
1 error

Why java main method is static ?

Main method in Java is entry point for any core Java program. In core Java program, execution starts from main method when you type java main-class-name, JVM search for public static void main(String args[]) method in that class and if it doesn't find that method it throws error NoSuchMethodError:main and terminates.

Now come to the main point "Why the main method is static in Java", there are quite a few reasons around but here are few reasons which make sense to me:

1. Since the main method is static Java virtual Machine can call it without creating any instance of a class which contains the main method.

2. If main method were not declared static than JVM has to create instance of main Class and since constructor can be overloaded and can have arguments there would not be any certain and consistent way for JVM to find main method in Java.

3. Anything which is declared in class in Java comes under reference type and requires object to be created before using them but static method and static data are loaded into separate memory inside JVM called context which is created when a class is loaded. If main method is static than it will be loaded in JVM context and are available to execution.

difference of static keyword in c++ and Java

Static keyword is used for almost same purpose in both C++ and Java. There are some differences though.

1. Unlike C++, Java supports a special block, called static block (also called static clause) which can be used for static initialization of a class. The code inside static block is executed only once. See Static blocks in Java for details.

2. Unlike C++, Java doesn’t support static local variables.

this keyword in Java

noreply@blogger.com (Anonymous) — Sat, 02 Dec 2017 15:43:00 +0000

In this article we will see this keyword in Java.

this keyword in Java

this keyword in Java is a special keyword which can be used to represent current object or instance of any class in Java. “this” keyword can also call constructor of same class in Java and used to call overloaded constructor. In this article we will see how to use this keyword in Java and different examples. this sometime also associate with super keyword which is used to denote instance of super class in Java and can be used to call overloaded constructor in Java.

6 usage of this keyword

1. to refer current class instance variable

Program


//Java code for using 'this' keyword to
//refer current class instance variables
class demo
{
    int a;
    int b;
     
    // parameterized constructor
    demo(int a, int b)
    {
        this.a = a;
        this.b = b;
    }
 
    void display()
    {
        //displays the value of variables a and b
        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
}

public class Main
    {
        public static void main(String[] args)
        {
            demo object = new demo(10, 20);
            object.display();
        }
}

Output


a = 10
b = 20

Explanation

The this keyword can be used to refer current class instance variable. If there is ambiguity between the instance variables and parameters, this keyword resolves the problem of ambiguity. In the above example, parameters (formal arguments) and instance variables are same. So, we are using this keyword to distinguish local variable and instance variable.If local variables(formal arguments) and instance variables are different, there is no need to use this keyword like in the following program.It is better approach to use meaningful names for variables. So we use same name for instance variables and parameters in real time, and always use this keyword.

2. to invoke current class method

Program


// this keyword in class method
class demo 
{
    void display() // 3
    {
        // calling fuction show()
        this.show(); // 4
       System.out.println("We are inside display function"); // 7
    }
     
    void show()  // 5
    { 
        System.out.println("We are inside show funcion"); // 6
    }
}

public class Main
{
    public static void main(String args[]) 
    {
        demo t1 = new demo();  // 1
        t1.display(); // 2
    }
}

Output


We are inside show funcion
We are inside display function

3. to invoke current class constructor

Program


class demo
{
    int a;
    int b;
 
    //2. Default constructor
    demo()
    {  
        //3. calling parameterized constructor of this class
        this(10, 20);
        //5. back in default constructor
        System.out.println("We are inside  default constructor \n");
    }
     
    //4. Parameterized constructor
    demo(int a, int b)
    {
        this.a = a;
        this.b = b;
        System.out.println("We are inside parameterized constructor");
    }
}

public class Main
{
    public static void main(String[] args)
    {
        //1. calls default constructor
        demo object = new demo();
    }
}

Output


We are inside parameterized constructor
We are inside  default constructor

4. as an argument in the method call

Program


// this keyword in method parameter
class demo
{
    int a;
    int b;
     
    // Default constructor
    demo()
    {
        a = 10;
        b = 20;
    }
     
    // Method that receives 'this' keyword as parameter
    void display(demo obj) // 5
    {
        System.out.println("a = " + a + "  b = " + b); // 6
    }
  
    // Method that returns current class instance
    void get() // 3
    {
        display(this); // 4
    }
}

public class Main
{ 
    public static void main(String[] args)
    {
        demo object = new demo(); // 1
        object.get(); // 2
    }
}

Output


a = 10 b = 20

5. as argument in the constructor call

Program


class A
{
    B obj;
     
    // Parameterized constructor with object of B as a parameter
    A(B obj) // 4
    {
        this.obj = obj; // 5
        
     // calling display method of class B
        obj.display(); // 6
    }
     
}
 
class B
{
    int x = 5;
     
    // Default Contructor that create a object of A  with passing this as an argument in the constructor
    B() // 2
    {
        A obj = new A(this); // 3
    }
     
    // method to show value of x 
    void display()  // 7
    {
        System.out.println("Value of x in Class B is " + x); // 8
    }
     
    public static void main(String[] args) {
        B obj = new B();
    }
}

public class Main
{
    public static void main(String[] args) 
    {
        B obj = new B(); // 1
    }
}

Output


Value of x in Class B is 5

6. to return the current class instance from the method

Program


//to return the current class instance
class demo
{
    int a;
    int b;
 
    //Default constructor
    demo()
    {
        a = 10;
        b = 20;
    }
     
    //Method that returns current class instance
    // 3
    demo get()
    {
        // 4. returns the instance of class demo
        return this;
    }
     
    //Displaying value of variables a and b
    void display() // 6
    {
        System.out.println("a = " + a + "  b = " + b);  // 7
    }
}

public class Main
{
    public static void main(String[] args)
    {
        //1. create object of class demo
        demo object = new demo();
        object.get().display(); // 2 // 5
    }
}

Output


a = 10 b = 20

Method in Java

noreply@blogger.com (Anonymous) — Thu, 30 Nov 2017 09:43:00 +0000

Methods appear inside class bodies. They contain local variable declarations and other Java statements that are executed when the method is invoked. Methods may return a value to the caller. They always specify a return type, which can be a primitive type, a reference type, or the type void , which indicates no returned value. Methods may take arguments, which are values supplied by the caller of the method. Lets see example:

Program


class multiply
{
    int num1;
    int num2;
    int mul(int x,int y)
    {
        int result;
        num1 = x;
        num2 = y;
        result = num1*num2;
        return result;
    }
}

public class Main
{
    public static void main (String[] args) 
    {
        multiply m = new multiply();
        System.out.println("multiplication of 3 and 5 is " + m.mul(3,5));
    }
}

Output


multiplication of 3 and 5 is 15

Explanation

In this example, the class multiply defines a method, mul(), that takes as arguments two integers: x and y. It returns a int type value as a result, using the return keyword. Our method has a fixed number of arguments (two); however, methods can have variable-length argument lists, which allow the method to specify that it can take any number of arguments and sort them itself at runtime.

Local variables

Our mul() method declares a local variable called result, which it uses to compute the multiplication of two numbers. A local variable is temporary; it exists only within the scope (the block) of its method. Local variables are allocated when a method is invoked; they are normally destroyed when the method returns. They can’t be referenced from outside the method itself. If the method is executing concurrently in different threads, each thread has its own version of the method’s local variables. A method’s arguments also serve as local variables within the scope of the method; the only difference is that they are initialized by being passed in from the caller of the method.

A varibale created within a method and assigned to a local variable may or may not persist after the method has returned. As with all variable in Java, it depends on whether any references to the variable remain. If an variable is created, assigned to a local variable, and never used anywhere else, that variable is no longer referenced when the local variable disappears from scope, so garbage collection removes the variable. If, however, we assign the variable to an instance variable of an object, pass it as an argument to another method, or pass it back as a return value, it may be saved by another variable holding its reference.

Difference between local variable and instance variable

Now let's see the difference between instance variable and local variable. local variables are local in scope and they are not visible or accessible outside there scope which is determined by {} while instance variables are visible on all part of code based on there access modifier e.g. public , private or protected. The only public can be accessed from outside while protected and private can be accessed from subclass and class itself. Access modifier can not be applied to a local variable and you can not even make them static. The only modifier which is applicable to a local variable is final and only final local variables are visible inside the anonymous class. the value of instance variable is limited to an instance, one instance can not access the value of other instance in Java.

Shadowing of instance variable by local variable

If a local variable and an instance variable have the same name, the local variable shadows or hides the name of the instance variable within the scope of the method. In the following example, the local variables num1 and num2 hide the instance variables of the same name:

Program


class multiply
{
    //instance variable
    int num1;
    int num2;
    int mul(int x,int y)
    {
        //local variable
        int result;
        //assigning x and y to local variable 
        int num1 = x;
        int num2 = y;
        result = num1*num2;
        return result;
    }
}

public class Main
{
    public static void main (String[] args) 
    {
        multiply m = new multiply();
        System.out.println("multiplication of 3 and 5 is " + m.mul(5,3));
        //we have assigned x and y to local variable so we can't access the value of x and y outside method
        System.out.println("num1 = " + m.num1 + " num2 = " + m.num2);
    }
}

Output


multiplication of 3 and 5 is 15
num1 = 0 num2 = 0

Explanation

When we set the values of the local variables in mul(), it has no effect on the values of the instance variables.So they are zero.So, this is also example of a varibale created within a method and assigned to a local variable may or may not persist after the method has returned. As with all variable in Java, it depends on whether any references to the variable remain.

Now lets see the example without shadowing.

Program


class multiply
{
    //instance variable
    int num1;
    int num2;
    int mul(int x,int y)
    {
        //local variable
        int result;
        //assigning x and y to instance variable 
        num1 = x;
        num2 = y;
        result = num1*num2;
        return result;
    }
}

public class Main
{
    public static void main (String[] args) 
    {
        multiply m = new multiply();
        System.out.println("multiplication of 3 and 5 is " + m.mul(5,3));
        //we have assigned x and y to instance variable so we can access the value of x and y outside method
        System.out.println("num1 = " + m.num1 + " num2 = " + m.num2);
    }
}

Output


multiplication of 3 and 5 is 15
num1 = 5 num2 = 3

Explanation

Like I said- If, however, we assign the variable to an instance variable of an object, pass it as an argument to another method, or pass it back as a return value, it may be saved by another variable holding its reference.

Method overloading

Method overloading is the ability to define multiple methods with the same name in a class; when the method is invoked, the compiler picks the correct one based on the arguments passed to the method. This implies that overloaded methods must have different numbers or types of arguments.

Method overloading (also called ad-hoc polymorphism ) is a powerful and useful feature. The idea is to create methods that act in the same way on different types of arguments. This creates the illusion that a single method can operate on many types of arguments. The print() method in the standard PrintStream class is a good example of method overloading in action. As you’ve probably deduced by now, you can print a string representation of just about anything using this expression:


System.out.print( argument );

The variable out is a reference to an object (a PrintStream) that defines nine different, “overloaded” versions of the print() method. The versions take arguments of the following types: Object, String, char[], char, int, long, float, double, and boolean.

You can invoke the print() method with any of these types as an argument, and it’s printed in an appropriate way. In a language without method overloading, this requires something more cumbersome, such as a uniquely named method for printing each type of object. In that case, it’s your responsibility to figure out what method to use for each data type.

What if there’s more than one possible match? For example, we try to print a subclass of String called MyString. (The String class is final so it can’t really be subclassed, but let’s use our imaginations.) MyString is assignable to either String or to Object. Here, the compiler makes a determination as to which match is “better” and selects that method. In this case, it’s the String method.

The intuitive explanation for this is that the String class is "closer" to MyString in the inheritance hierarchy. It is a more specific match. A slightly more rigorous way of specifying it would be to say that a given method is more specific than another method if the argument types of the first method are all assignable to the argument types of the second method. In this case, the String method is more specific to a subclass of String than the Object method because type String is assignable to type Object. The reverse is not true.

Method overloading is not something that happens at runtime; this is an important distinction. It means that the selected method is chosen once, when the code is compiled. Once the overloaded method is selected, the choice is fixed until the code is recompiled.

Example of method overloading with changing no of arguments

Program


class SUM
{  
    //two arguments
    int add(int a, int b)
    {
        return a+b;
    }  
    //three arguments
    int add(int a,int b,int c)
    {
        return a+b+c;
    }  
}  
class Main{  
    public static void main(String[] args)
    {  
        SUM s = new SUM();
        System.out.println(s.add(11,12));  
        System.out.println(s.add(12,1,15));  
    }
}

Output


23
28

Explanation

In this example, we have created two methods, first add() method performs addition of two numbers and second add method performs addition of three numbers.

Example of method overloading with changing data type of arguments

Program


class SUM
{  
    //int argument
    int add(int a, int b)
    {
        return a+b;
    }  
    //double argument
    double add(double a, double b)
    {
        return a+b;
    }  
}  
class Main{  
    public static void main(String[] args)
    {  
        SUM s = new SUM();
        System.out.println(s.add(11,12));  
        System.out.println(s.add(12.3,1.6));  
    }
}

Output


23
13.9

Explanation

In this example, we have created two methods that differs in data type. The first add method receives two integer arguments and second add method receives two double arguments.

Constructor in Java

noreply@blogger.com (Anonymous) — Wed, 29 Nov 2017 18:52:00 +0000

Objects in Java are allocated on a system “heap” memory space. Unlike other languages, however, we needn’t manage that memory ourselves. Java takes care of memory allocation and deallocation for you. Java explicitly allocates storage for an object when you create it with the new operator. More importantly, objects are removed by garbage collection when they’re no longer referenced.

Constructors

Objects are allocated with the new operator using an object constructor. A constructor is a special method with the same name as its class and no return type. It’s called when a new class instance is created, which gives the class an opportunity to set up the object for use. Constructors, like other methods, can accept arguments and can be overloaded. they are not, however, inherited like other methods.

There are two types of constructors:

1. Default constructor (no-arg constructor)

A constructor that has no parameter is known as default constructor. If we don’t define a constructor in a class, then compiler creates default constructor(with no arguments) for the class. And if we write a constructor with arguments or no-argument then compiler does not create default constructor. Default constructor provides the default values to the object like 0, null etc. depending on the type.

Syntax


class_name()
{

}

Program


class Car 
{
    //car constructor
    Car()
    {
        System.out.println("new car is ready.");
    }
}

public class Default_Constructer
{
    public static void main(String args[])
    {
        //object creation
        Car swift = new Car();
    }
}

Output


new car is ready.

Explanation

In this example, the class Car has one constructors. which takes no arguments; it’s known as the default constructor. Default constructors play a special role: if we don’t define any constructors for a class, an empty default constructor is supplied for us. The default constructor is what gets called whenever you create an object by calling its constructor with no arguments. Here we have implemented the default constructor so that it sets the instance swift.

If there is no constructor in a class, compiler automatically creates a default constructor.Default constructor provides the default values to the object like 0, null etc. depending on the type.

let see example of default constructor with default value.

default constructor with default value

Program


class Car 
{
    int speed;
    String model;
    
    void display()
    {
        System.out.println(model + " " + speed);
    }
}

public class default_value
{
    public static void main(String args[])
    {
        //object creation
        Car swift = new Car();
        swift.display();
        
        Car eco = new Car();
        eco.speed = 500;
        //it will display speed but not model
        eco.display();
    }
}

Output


null 0
null 500

Explanation

In the above class,you are not creating any constructor so compiler provides you a default constructor.Here 0 and null values are provided by default constructor.In second object we have defined speed of that object so, it will display speed but not model.

2. Parameterized constructor

A constructor that has parameters is known as parameterized constructor. If we want to initialize fields of the class with your own values, then use parameterized constructor.

Syntax


class_name(parameters...)
{

}

Program


class Car 
{
    int speed;
    String model;
    
    //parametarized constructor
    Car(int s,String m)
    {
        speed = s;
        model = m;
    }
    
    void display()
    {
        System.out.println(model + " " + speed);
    }
}

public class para_constructor
{
    public static void main(String args[])
    {
        //object creation
        Car swift = new Car(500,"swift");
        swift.display();
    }
}

Output


swift 500

Example program with default and parametarized constructor

Program


class Car
{
    Car() 
    {
        System.out.println("default constructor");
    }

    Car(int speed) 
    {
        System.out.println("parametarized constructor");
    }
}

public class para_def
{
    public static void main (String[] args) 
    {
        Car def = new Car();
        Car par = new Car(500);
    }
}

Output


default constructor
parametarized constructor

Explanation

In this example, the class Car has two constructors. The first takes no arguments; it’s known as the default constructor. Default constructors play a special role: if we don’t define any constructors for a class, an empty default constructor is supplied for us. The default constructor is what gets called whenever you create an object by calling its constructor with no arguments. The second constructor takes a int argument. Given the constructors in the previous example, we create two Car objects.

In each case, Java chooses the appropriate constructor at compile time based on the rules for overloaded method selection.

copy constructor in Java

There is no copy constructor in java. But, we can copy the values of one object to another like copy constructor in C++.

There are many ways to copy the values of one object into another in java. They are:

By constructor
By assigning the values of one object into another
By clone() method of Object class

In this example, we are going to copy the values of one object into another using java constructor.

Program


class Car
{
    int speed;
    String model;
    
    Car(int s,String m) 
    {
        speed = s;
        model = m;
    }
    
    //copy constructor
    Car(Car c) 
    {
        speed = c.speed;
        model = c.model;
    }
    
    void display()
    {
        System.out.println(speed + " " + model);
    }
}

public class copy_constructor
{
    public static void main (String[] args) 
    {
        Car c1 = new Car(500,"eco");
        //assigning parameter of c1 to c2
        Car c2 = new Car(c1);
        c1.display();
        c2.display();
    }
}

Output


500 eco
500 eco

difference between constructor and method

Java Constructor	Java Method
Constructor is used to initialize the state of an object.	Method is used to expose behaviour of an object.
Constructor must not have return type.	Method must have return type.
Constructor is invoked implicitly.	Method is invoked explicitly.
The java compiler provides a default constructor if you don't have any constructor.	Method is not provided by compiler in any case.
Constructor name must be same as the class name.	Method name may or may not be same as class name.

Class and Objects

noreply@blogger.com (Anonymous) — Tue, 28 Nov 2017 19:33:00 +0000

From this article we are starting to do object oriented programing in Java.
In object-oriented programming technique, we design a program using objects and classes.Object is the physical as well as logical entity whereas class is the logical entity only.

Objects in Java

An entity that has state and behavior is known as an object e.g. chair, bike, marker, pen, table, car etc. It can be physical or logical.t is a basic unit of Object Oriented Programming and represents the real life entities.A typical Java program creates many objects, which interact by invoking methods. An object consist of :

1. State : It is represented by attributes of an object. It also reflect the properties of an object.

2. Behavior : It is represented by methods of an object. It also reflects the response of an object with other objects.

3. Identity : It gives a unique name to an object and enables one object to interact with other objects.

If you compare the software object with a real-world object, they have very similar characteristics. Software objects also have a state and a behavior. A software object's state is stored in fields and behavior is shown via methods.So in software development, methods operate on the internal state of an object and the object-to-object communication is done via methods.

For Example: Pen is an object. Its name is Reynolds, color is white etc. known as its state. It is used to write, so writing is its behavior.

Declaring objects

When an object of a class is created, the class is said to be instantiated. All the instances share the attributes and the behavior of the class. But the values of those attributes, i.e. the state are unique for each object. A single class may have any number of instances.Object is an instance of a class. Class is a template or blueprint from which objects are created. So object is the instance(result) of a class.

Syntax for declaring object


 Person somebody;

As we declare variables like (type name;). This notifies the compiler that we will use name to refer to data whose type is type. With a primitive variable, this declaration also reserves the proper amount of memory for the variable. So for reference variable, type must be strictly a concrete class name.

Class in Java

A class is a user defined blueprint or prototype from which objects are created. It represents the set of properties or methods that are common to all objects of one type.A class in Java can contain:

fields
methods
constructors
blocks
nested class and interface

Constructors are used for initializing new objects. Fields are variables that provides the state of the class and its objects, and methods are used to implement the behavior of the class and its objects.There are various types of classes that are used in real time applications such as nested classes, anonymous classes, lambda expressions.

Syntax for declaring class


class {  
    field;  
    method;  
}

A class can contain any of the following variable types.

Local variables − Variables defined inside methods, constructors or blocks are called local variables. The variable will be declared and initialized within the method and the variable will be destroyed when the method has completed.

Instance variables − Instance variables are variables within a class but outside any method. These variables are initialized when the class is instantiated. Instance variables can be accessed from inside any method, constructor or blocks of that particular class.

Class variables − Class variables are variables declared within a class, outside any method, with the static keyword.

A variable which is created inside the class but outside the method, is known as instance variable. Instance variable doesn't get memory at compile time. It gets memory at run time when object(instance) is created. That is why, it is known as instance variable.

Creating an object

As mentioned previously, a class provides the blueprints for objects. So basically, an object is created from a class. In Java, the new keyword is used to create new objects.There are three steps when creating an object from a class −
Declaration − A variable declaration with a variable name with an object type.As we shown above


Person somebody;

Instantiation − The 'new' keyword is used to create the object.


new Person();

Initialization − The 'new' keyword is followed by a call to a constructor. This call initializes the new object.


Person Hansraj = new Person();

Object and class example

Program


//declaring class
class Employee
{
    int emp_id;
    String name;
}

public class Main
{
    public static void main(String args[])
    {
        //make instance of Employee class through refrence
        Employee e1 = new Employee();
        e1.emp_id = 1234;
        e1.name = "Raj";
        System.out.println(e1.name + " \'s employee id is " +  e1.emp_id);
    }
}

Output


Raj's employee id is 1234

Explanation

Here, Employee is a class name. It has two properties emp_id and name. e1 is a reference for object of class Employee.

OOPs concepts

noreply@blogger.com (Anonymous) — Mon, 27 Nov 2017 09:43:00 +0000

In this article we will learn about OOP ( Object oriented programing ) concepts. If you want to learn further lessons about objects, classes, inheritance, polymorphism, how objects interact with each other then you must read these lesson carefully.

There are total 7 core OOPs concepts.

1. Abstraction

Abstraction is the concept of hiding the internal details and describing things in simple terms. For example, a method that adds two integers. The method internal processing is hidden from outer world. There are many ways to achieve abstraction in object oriented programming, such as encapsulation and inheritance.

A java program is also a great example of abstraction. Here java takes care of converting simple statements to machine language and hides the inner implementation details from outer world.

2. Encapsulation

Encapsulation is the technique used to implement abstraction in object oriented programming. Encapsulation is used for access restriction to a class members and methods.

Access modifier keywords are used for encapsulation in object oriented programming. For example, encapsulation in java is achieved using private, protected and public keywords.

3. Inheritance

Inheritance is the object oriented programming concept where an object is based on another object. Inheritance is the mechanism of code reuse. The object that is getting inherited is called superclass and the object that inherits the superclass is called subclass.

We use extends keyword in java to implement inheritance.

4. Polymorphism

Polymorphism is the concept where an object behaves differently in different situations. There are two types of polymorphism – compile time polymorphism and runtime polymorphism.

Compile time polymorphism is achieved by method overloading.

Runtime polymorphism is implemented when we have “IS-A” relationship between objects. This is also called as method overriding because subclass has to override the superclass method for runtime polymorphism. If we are working in terms of superclass, the actual implementation class is decided at runtime. Compiler is not able to decide which class method will be invoked. This decision is done at runtime, hence the name as runtime polymorphism or dynamic method dispatch.

5. Association

Association is the OOPS concept to define the relationship between objects. Association defines the multiplicity between objects. For example Teacher and Student objects. There is one to many relationship between a teacher and students. Similarly a student can have one to many relationship with teacher objects. However both student and teacher objects are independent of each other.

6. Aggregation

Aggregation is a special type of association. In aggregation, objects have their own life cycle but there is an ownership. Whenever we have “HAS-A” relationship between objects and ownership then it’s a case of aggregation.

For example consider two classes Student class and Address class. Every student has an address so the relationship between student and address is a Has-A relationship. But if you consider its vice versa then it would not make any sense as an Address doesn’t need to have a Student necessarily.

7. Composition

Composition is a special case of aggregation. Composition is a more restrictive form of aggregation. When the contained object in “HAS-A” relationship can’t exist on it’s own, then it’s a case of composition. For example, House has-a Room. Here room can’t exist without house.

Setup JAVA in your PC

noreply@blogger.com (Anonymous) — Mon, 27 Nov 2017 08:06:00 +0000

1. Download JDK from http://www.oracle.com/technetwork/java/javase/downloads/index.html

2. Install the JDK.

3. Go to path C:\Program Files (x86)\Java\jdk1.8.0_131\bin in your PC and copy it.

4. Now go to control panel

5. Click on system

6. Click on advance system settings

7. Click on environment variables

8. Click on new and name it as path and copy path which is in your pc as shown above in red colour

9. Click on OK

10. Now open CMD and type javac and press enter if it shows messy long list then congratulation java is installed in your PC.

11. Now go to next article for Hello World program.

About JAVA

noreply@blogger.com (Anonymous) — Mon, 27 Nov 2017 03:50:00 +0000

The greatest challenges and most exciting opportunities for software developers today lie in harnessing the power of networks. Applications created today, whatever their intended scope or audience, will almost certainly run on machines linked by a global network of computing resources. The increasing importance of networks is placing new demands on existing tools and fueling the demand for a rapidly growing list of completely new kinds of applications.

We want software that works—consistently, anywhere, on any platform—and that plays well with other applications. We want dynamic applications that take advantage of a connected world, capable of accessing disparate and distributed information sources. We want truly distributed software that can be extended and upgraded seamlessly. We want intelligent applications that can roam the Net for us, ferreting out information and serving as electronic emissaries. We have known for some time what kind of software we want, but it is really only in the past few years that we have begun to get it.

The problem, historically, has been that the tools for building these applications have fallen short. The requirements of speed and portability have been, for the most part, mutually exclusive, and security has been largely ignored or misunderstood. In the past, truly portable languages were bulky, interpreted, and slow. These languages were popular as much for their high-level functionality as for their portability. Fast languages usually provided speed by binding themselves to particular platforms, so they met the portability issue only halfway. There were even a few safe languages, but they were primarily offshoots of the portable languages and suffered from the same problems. Java is a modern language that addresses all three of these fronts: portability, speed, and security. This is why it has been a dominant language in the world of programming for more than a decade and a half.

About Java

The Java programming language, developed at Sun Microsystems under the guidance of Net luminaries James Gosling and Bill Joy, was designed to be a machine-independent programming language that is both safe enough to traverse networks and powerful enough to replace native executable code. Java addresses the issues raised here and played a starring role in the growth of the Internet, leading to where we are today.

Initially, most of the enthusiasm for Java centered on its capabilities for building embedded applications for the Web called applets. But in the early days, applets and other client-side GUI applications written in Java were limited. Today, Java has Swing, one of the most sophisticated toolkits for building graphical user interfaces (GUIs) in any language. This development has allowed Java to become a popular platform for developing traditional client-side application software.

Of even more importance, however, Java has become the premier platform for web-based applications and web services. These applications use technologies including the Java Servlet API, Java web services, and many popular open source and commercial Java application servers and frameworks. Java’s portability and speed make it the platform of choice for modern business applications. Java servers running on open source Linux platforms are at the heart of the business and financial world today.

This book will show you how to use Java to accomplish real-world programming tasks. In the coming chapters we’ll cover everything from text processing to networking, building rich client-side GUI applications with Swing and lightweight web-based applications and services.

History of Java

The seeds of Java were planted in 1990 by Sun Microsystems patriarch and chief researcher Bill Joy. At the time, Sun was competing in a relatively small workstation market while Microsoft was beginning its domination of the more mainstream, Intel-based PC world. When Sun missed the boat on the PC revolution, Joy retreated to Aspen, Colorado, to work on advanced research. He was committed to the idea of accomplishing complex tasks with simple software and founded the aptly named Sun Aspen Smallworks.

Of the original members of the small team of programmers assembled in Aspen, James Gosling will be remembered as the father of Java. Gosling first made a name for himself in the early 80s as the author of Gosling Emacs, the first version of the popular Emacs editor that was written in C and ran under Unix. Gosling Emacs became popular but was soon eclipsed by a free version, GNU Emacs, written by Emacs’s original designer. By that time, Gosling had moved on to design Sun’s NeWS, which briefly contended with the X Window System for control of the Unix GUI desktop in 1987. Although some people would argue that NeWS was superior to X, NeWS lost because Sun kept it proprietary and didn’t publish source code while the primary developers of X formed the X Consortium and took the opposite approach.

Designing NeWS taught Gosling the power of integrating an expressive language with a network-aware windowing GUI. It also taught Sun that the Internet programming community will ultimately refuse to accept proprietary standards, no matter how good they may be. The seeds of Java’s licensing scheme and open (if not quite “open source”) code were sown by NeWS’s failure. Gosling brought what he had learned to Bill Joy’s nascent Aspen project. In 1992, work on the project led to the founding of the Sun subsidiary FirstPerson, Inc. Its mission was to lead Sun into the world of consumer electronics.

The FirstPerson team worked on developing software for information appliances, such as cellular phones and personal digital assistants (PDAs). The goal was to enable the transfer of information and real-time applications over cheap infrared and traditional packet-based networks. Memory and bandwidth limitations dictated small, efficient code. The nature of the applications also demanded they be safe and robust. Gosling and his teammates began programming in C++, but they soon found themselves confounded by a language that was too complex, unwieldy, and insecure for the task. They decided to start from scratch, and Gosling began working on something he dubbed “C++ minus minus.”

With the foundering of the Apple Newton (Apple’s earliest handheld computer), it became apparent that the PDA’s ship had not yet come in, so Sun shifted FirstPerson’s efforts to interactive TV (ITV). The programming language of choice for ITV set-top boxes was to be the near ancestor of Java, a language called Oak. Even with its elegance and ability to provide safe interactivity, Oak could not salvage the lost cause of ITV at that time. Customers didn’t want it, and Sun soon abandoned the concept.

At that time, Joy and Gosling got together to decide on a new strategy for their innovative language. It was 1993, and the explosion of interest in the Web presented a new opportunity. Oak was small, safe, architecture-independent, and object-oriented. As it happens, these are also some of the requirements for a universal, Internet-savvy programming language. Sun quickly changed focus, and, with a little retooling, Oak became Java.

Growing up Java

It would not be overstating it to say that Java caught on like wildfire. Even before its first official release when Java was still a nonproduct, nearly every major industry player had jumped on the Java bandwagon. Java licensees included Microsoft, Intel, IBM, and virtually all major hardware and software vendors. However, even with all this support Java took a lot of knocks and experienced some growing pains during its first few years.

A series of breach of contract and antitrust lawsuits between Sun and Microsoft over the distribution of Java and its use in Internet Explorer hampered its deployment on the world’s most common desktop operating system—Windows. Microsoft’s involvement with Java also become one focus of a larger federal lawsuit over serious anticompetitive practices at the company, with court testimony revealing concerted efforts by the software giant to undermine Java by introducing incompatibilities in its version of the language. Meanwhile, Microsoft introduced its own Java-derived language called C# (C-sharp) as part of its .NET initiative and dropped Java from inclusion in Windows. C# has gone on to become a very good language in its own right, enjoying more innovation in recent years than has Java.

But Java continues to spread on a wide variety of platforms. As we begin looking at the Java architecture, you’ll see that much of what is exciting about Java comes from the self-contained, virtual machine environment in which Java applications run. Java was carefully designed so that this supporting architecture can be implemented either in software, for existing computer platforms, or in customized hardware. Hardware implementations of Java are used in some smart cards and other embedded systems. You can even buy “wearable” devices, such as rings and dog tags, that have Java interpreters embedded in them. Software implementations of Java are available for all modern computer platforms down to portable computing devices. Today, an offshoot of the Java platform is the basis for Google’s Android operating system that powers billions of phones and other mobile devices.

In 2010, Oracle corporation bought Sun Microsystems and became the steward of the Java language. In a somewhat rocky start to its tenure, Oracle sued Google over its use of the Java language in Android and lost. In July of 2011, Oracle released Java SE 7, a significant Java release.

switch statement

noreply@blogger.com (Anonymous) — Sat, 18 Nov 2017 14:44:00 +0000

The Java switch statement executes one statement from multiple conditions. It is like if-else-if ladder statement.

switch statement

Syntax


switch(expression){    
case value1:    
 //code to be executed;    
 break;  //optional  
case value2:    
 //code to be executed;    
 break;  //optional  
......    
    
default:     
 code to be executed if all cases are not matched;    
}

Program


public class switch_example
{
    public static void main(String args[])
    {
        int age = 20;
        switch(age)
        {
            case 10:
                System.out.println("You are child.");
            break;
            case 20:
                System.out.println("You are teenager.");
            break;
            case 30:
                System.out.println("You are matured.");
            break;
            case 40:
                System.out.println("You are old.");
            break;
            default:
                System.out.println("You are ageless.");
        }
    }
}

Output


You are teenager.

Explanation

The switch statement is a multi-way branch statement. It provides an easy way to dispatch execution to different parts of code based on the value of the expression. Basically, the expression can be byte, short, char, and int primitive data types. Beginning with JDK7, it also works with enumerated types ( Enums in java), the String class and Wrapper classes.

Some Important rules for switch statements :

Duplicate case values are not allowed.
The value for a case must be the same data type as the variable in the switch.
The value for a case must be a constant or a literal.Variables are not allowed.
The break statement is used inside the switch to terminate a statement sequence.
The break statement is optional. If omitted, execution will continue on into the next case.
The default statement is optional, and it must appear at the end of the switch.

We will see break and continue keyword in other lesson.

If - Else control statement

noreply@blogger.com (Anonymous) — Sat, 18 Nov 2017 14:32:00 +0000

In this article we will learn about If-else control statement. There are four types of if-else control statement.

if statement

Syntax


if(condition)
{  
    //code to be executed  
}

Program


public class If_Example
{
    public static void main(String args[])
    {
        int age = 20;
        if(age > 18)
        {
            System.out.println("You can give vote.");
        }
    }
}

Output


You can give vote.

Explanation

If statement executes the block if the condition becomes true.

if-else statement

Syntax


if(condition)
{  
    //code if condition is true  
}
else
{  
    //code if condition is false  
}

Program


public class IfElse_Example
{
    public static void main(String args[])
    {
        int age = 17;
        if(age > 18)
        {
            System.out.println("You can give vote.");
        }
        else
        {
            System.out.println("You can't give vote.");
        }
    }
}

Output


You can't give vote.

Explanation

If condition becomes true then if block will be executed. otherwise else block will be executed.

nested if statement

Syntax


if (condition1) 
{
   // Executes when condition1 is true
   if (condition2) 
   {
      // Executes when condition2 is true
   }
   else
   {
       // Executes when condition2 is false
   }
}

Program


public class Nested_If
{
    public static void main(String args[])
    {
        int age = 20;
        if(age > 18)
        {
            System.out.println("You can give vote.");
            if(age % 2 == 0)
            {
                System.out.println("Your age is even.");
            }
            else
            {
                System.out.println("Your age is odd.");
            }
        }
    }
}

Output


You can give vote.
Your age is even.

Explanation

If condition becomes true it executes statement of if block. if there is another if block exists it checks condition if condition becomes true then if block will be executed otherwise else block will be executed.

if-else-if ladder

Syntax


if(condition1){  
//code to be executed if condition1 is true  
}else if(condition2){  
//code to be executed if condition2 is true  
}  
else if(condition3){  
//code to be executed if condition3 is true  
}  
...  
else{  
//code to be executed if all the conditions are false  
}

Program


public class IfElse_leader
{
    public static void main(String args[])
    {
        int age = 22;
        if(age < 12)
        {
            System.out.println("You are child.");
        }
        else if(age > 12 && age < 20)
        {
            System.out.println("You are teenager.");
        }
        else if(age > 20 && age < 50)
        {
            System.out.println("You are mature.");
        }
        else
        {
            System.out.println("You are old.");
        }
    }
}

Output


You are mature.

Explanation

Here, if condition becomes true then it's block will be executed and rest of the condition will be ignored. If all conditions become false then else block will be executed.

Comments in Java

noreply@blogger.com (Anonymous) — Sat, 18 Nov 2017 11:14:00 +0000

The java comments are statements that are not executed by the compiler and interpreter. The comments can be used to provide information or explanation about the variable, method, class or any statement. It can also be used to hide program code for specific time.

Three types of comment in Java

1. Single line comment

Syntax


// This is single line comment

// This line won't be executed

Program

 
public class SingleLineComment

{

    public static void main(String args[])

    {

        // break keyword example

        for(int i=1; i<=10; i++)

        {

            if(i==6)

            {

                break;

            }

            System.out.println(i);

        }

    }

}

Output

2. Multi line comment

Syntax


/* This is multi 

line commment

 This line won't 

 be executed */

Program

 
public class MultiLineComment

{

    public static void main(String args[])

    {

        for(int i=1; i<=10; i++)

        {

            /* Exmple of

            break

            keyword */

            if(i==6)

            {

                break;

            }

            System.out.println(i);

        }

    }

}

Output

3. Documentation comment

Syntax


/** This is 

 documentation

  comment */

Program

 
public class DocComment

{

    public static void main(String args[])

    {

        

    }

    /** The add() method returns addition of given numbers.*/  

    public static int add(int a, int b)

    {

        return a+b;

    }  

    /** The div() method returns divison of given numbers.*/  

    public static int div(int a, int b)

    {

        return a/b;

    }  

}

Output


javac DocComment.java

javadoc DocComment.java

Explanation

The documentation comment is used to create documentation API. To create documentation API, you need to use javadoc tool. Now, there will be HTML files created for your Calculator class in the current directory. Open the HTML files and see the explanation of Calculator class provided through documentation comment.

continue keyword in Java

noreply@blogger.com (Anonymous) — Sat, 18 Nov 2017 07:28:00 +0000

continue keyword in Java

Syntax


// condition  

    continue;

Program

 
public class continue_demo

{

    public static void main(String args[])

    {

        for(int i=1; i<=10; i++)

        {

            if(i==6)

            {

                continue;

            }

            System.out.println(i);

        }

    }

}

Output

Explanation

The Java continue statement is used to continue loop. It continues the current flow of the program and skips the remaining code at specified condition.

continue keyword in innerloop

Program

 
public class continue_inner

{

    public static void main(String args[])

    {

        for(int i=1; i<=5; i++)

        {

            for(int j=1; j<=5; j++)

            {

                if(i==3 && j==3)

                {

                    continue;

                }

                System.out.println(i + "-" + j);

            }

        }

    }

}

Output

Explanation

It continues inner loop only if you use continue statement inside the inner loop.

break keyword

noreply@blogger.com (Anonymous) — Sat, 18 Nov 2017 06:29:00 +0000

break keyword in Java

Syntax


// condition

    break;

Program

 
public class break_demo

{

    public static void main(String args[])

    {

        for(int i=1; i<=10; i++)

        {

            if(i==6)

            {

                break;

            }

            System.out.println(i);

        }

    }

}

Output

Explanation

The Java break is used to break loop or switch statement. It breaks the current flow of the program at specified condition.

break keyword in inner loop

Program

 
public class break_inner

{

    public static void main(String args[])

    {

        for(int i=1; i<=5; i++)

        {

            for(int j=1; j<=5; j++)

            {

                if(i==3 && j==3)

                {

                    break;

                }

                System.out.println(i + "-" + j);

            }

        }

    }

}

Output

Explanation

It breaks inner loop only if you use break statement inside the inner loop.Outer loop will continue to iterate.

Do-while loop

noreply@blogger.com (Anonymous) — Fri, 17 Nov 2017 13:28:00 +0000

Do-while loop in Java

Syntax


do{  

//code to be executed  

}while(condition);

Program

 
public class do_while

{

    public static void main(String args[])

    {

        int i = 1;

        do

        {

            System.out.println(i);

            i++;

        }while(i <= 10);

    }

}

Output

Explanation

The Java do-while loop is used to iterate a part of the program several times. If the number of iteration is not fixed and you must have to execute the loop at least once, it is recommended to use do-while loop.
The Java do-while loop is executed at least once because condition is checked after loop body.
do while loop starts with the execution of the statement(s). There is no checking of any condition for the first time.
After the execution of the statements, and update of the variable value, the condition is checked for true or false value. If it is evaluated to true, next iteration of loop starts.
When the condition becomes false, the loop terminates which marks the end of its life cycle.
It is important to note that the do-while loop will execute its statements atleast once before any condition is checked, and therefore is an example of exit control loop.

Infinite do-while loop

Syntax

 
do{  

//code to be executed  

}while(true);

Program

 
public class infinite_dowhile

{

    public static void main(String args[])

    {

        do

        {

            System.out.println("Infinite while loop");

        }while(true);

    }

}

Output

 

Infinite while loop

Infinite while loop

Infinite while loop

Infinite while loop

Infinite while loop

Infinite while loop

Explanation

If you pass true in the do-while loop, it will be infinitive do-while loop.
You have to press ctrl+c to stop this program otherwise it will run continuously.

While loop

noreply@blogger.com (Anonymous) — Fri, 17 Nov 2017 07:06:00 +0000

While loop in JAVA

Syntax


while(condition){  

//code to be executed  

}

Program

 
public class while_loop

{

    public static void main(String args[])

    {

        int i = 1;

        while(i <= 10)

        {

            System.out.println(i);

            i++;

        }

    }

}

Output

Explanation

The Java while loop is used to iterate a part of the program several times. If the number of iteration is not fixed, it is recommended to use while loop.

While loop starts with the checking of condition. If it evaluated to true, then the loop body statements are executed otherwise first statement following the loop is executed. For this reason it is also called Entry control loop.
Once the condition is evaluated to true, the statements in the loop body are executed. Normally the statements contain an update value for the variable being processed for the next iteration.
When the condition becomes false, the loop terminates which marks the end of its life cycle.

Infinite while loop

Syntax


while(true){  

//code to be executed  

}

Program

 
public class infinite_while

{

    public static void main(String args[])

    {

        while(true)

        {

            System.out.println("Infinite while loop");

        }

    }

}

Output

 

Infinite while loop

Infinite while loop

Infinite while loop

Infinite while loop

Infinite while loop

Infinite while loop

Infinite while loop

Infinite while loop

Explanation

If you pass true in the while loop, it will be infinitive while loop.
Here, condition is always true so program runs continuously. You have to press ctrl+c to stop the program.
Remember true and false are keywords in Java.