Null Statement and Character Manipulation in JAVA

In Java programs, statements are terminated with a semicolon (;). The simplest statement of them all is the empty, or null statement.
; it is a null statement

A null statement is useful in those instances where the syntax of the language requires the presence of a statement but where the logic of the program does not. We will see it in loops and their bodies.

Character Manipulation

Consider the following code. What does it print?

        :
System.out.print(“H” + “a”);
System.out.print(‘H’ + ‘a’);
        :
Aren’t you thinking that it would produce output as:    HaHa
But if you the program, you’ll find that the output produced is:    Ha169

As expected, the first call to System.out.print prints Ha. Its argument is the expression “H” + “a”, which performs the obvious string concatenation.

The second call to system.out.print is another story. Its argument is the expression ‘H’ + ‘a’. The problem is that ‘H’ and ‘a’ are char literals. Because neither operand is of type string, the + operator performs addition rather than string concatenation. Thus it adds ‘H”s value i.e. 72 and ‘a”s value I.e. 97 and gives 169. (A-Z have values 65-90; a-z have values 97-122).

You can force the + operator to perform string concatenation rather than addition by ensuring that at least one of its operands is a string. The common idiom is to begin a sequence of concatenations with the empty string (“ “), as follows:
    System.out.print(“ “ + ‘H’ + ‘a’) ;

But this approach can lead to some confusions also. Can you guess what the following statement prints?
    System.out.println(“2 + 2 = “ + 2 + 2);
---------------------------------------------------

Yes, you are right. It produces:    2 + 2 = 22

To perform the addition of expression 2+2 shown above, you need to convert it to Expression by enclosing it in parenthesis i.e. as
(2+2): System.Out.Println(“2+2 = ”+ (2+2));

The + operator performs string concatenation if and only If at least one of its operands is of type string: otherwise, it performs addition with primitive types.

Type of Statements used in JAVA

Statements are roughly equivalent to sentences in natural languages. A statement forms a complete unit of execution. The following types of expressions can be made into a statement by terminating the expression with a semicolon ( ; )

• Assignment expressions
• Any use of ++ or - -
• Method calls
• Object creation expressions

These kinds of statement are called expression statement. Here are some example of expression statements :

Avalue = 8933.234;                                          // assignment statement
Avalue++ ;                                                        // increment statement
System . out . println (avalue);                         // method call statement
Integer integerobject = new integer (4);           // object creation statement

In addition to these kinds of expression statements, there are two other kinds of statements. A declaration statement declares a variable. You’ve seen many examples of declaration statement.
Double avalue = 8933.234;            // declaration statement

A control flow statement regulates the order in which statements get executed. For loop and  if statements are both examples of control flow statements.

Block

A block is group of zero or more statements between balanced braces and can be used anywhere a single statement is allowed. The following listing shows two blocks.

If  (character . I suppercase(achar))
{
    Labe l1 . settext (“the character” + achar + “is upper case .”) ;
}
Else
{
    Labe l1. Settext (“the character” + achar + “is lower case .”) ;
    Label2. Settext(“thank you”) ;
}

Character.isLowerCase( )    tests whether a character is in lowercase.
Character.isUpperCase( )        tests whether a character is in uppercase.
Character.toLowerCase( )        converts the case of a character to lowercase
Character.toUpperCase( )        converts the case of a character to uppercase

First Block:

 If (character.isUpperCase(achar))
{            // block1 begins
    Label1.Settext (“ The character “ + achar + “ is upper case.”) ;
}            // end of block 1
Else
 

Another Block:
{            // block2 begins
Label1.Settext(“ The character “ + achar + “ is lower case . “) ;
}            // end of block2

See, the beginning and end of blocks have been marked.

A Block is a group of zero or more statements between balanced braces and can be used anywhere a single statement is allowed.

In this book, we shall be following conventional style where opening brace of the block is not put in a separate line, rather it is placed in continuation with the previous statement (whose part the block is).

For instance, rather than showing
If (a > b) { : }

We shall be writing
If (a > b)   {     :  }
Opening brace of the block in continuation with previous statement

How to make Digital clock using ajax in asp.net

Using AJAX Technology you can change time at runtime in asp.net. So you can easily create web development in the asp.net. Here we will take a simple example, which shows time on the webpage also page will refreshed after 1 second .
ScriptManager : The ScriptManager control is the first AJAX server control in the toolbox. This control helps in implementing the ajax functionality in the asp.net website. You need to place this control on the webpage wherever AJAX functionality is required. In the absence of this control, no other Ajax server controls, such as Timer, UpdatePanel and UpdateProgress , can be added to the webpage. The ScriptManager control is responsible for managing client scripts for AJAX-enabled website . The Script Manager control use a ScriptManager class to manage AJAX script libraries and script files.

Timer Control :  Sometimes , there can be a situation when you want to update the contents of the page after a specific interval. for example , there is a web page showing the stock prices where the price of the stock changes frequently. you are asked to update the stock prices after every minute . In this scenario , you need to use the Timer control . The Timer control contains a property named interval and an event named Tick.. The Interval property of the timer control is used to specify the desired time limit in second.
lets take an Example

Copy this code and paste your web form ( Before copy you must add ajax control tool kit to your project )


<%@ Page Language="C#" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<script runat="server">



    protected void Timer1_Tick(object sender, EventArgs e)
    {
        Label1.Text = DateTime.Now.ToLongTimeString();
    }
</script>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
    
        <asp:ScriptManager ID="ScriptManager1" runat="server">
        </asp:ScriptManager>
        <br />
        <asp:UpdatePanel ID="UpdatePanel1" runat="server">

        <ContentTemplate >
            <asp:Label ID="Label1" runat="server" Text="Label"></asp:Label>
            <asp:Timer ID="Timer1" runat="server" Interval="1000" ontick="Timer1_Tick">
            </asp:Timer>
        
        </ContentTemplate>
        </asp:UpdatePanel>
    
    </div>
    </form>
</body>
</html>

OUTPUT

Create RadioButton list and Access Checked Value in Asp.Net MVC

List of Radio buttons are placed on the view when programmer need to checked only one value among a group by the user. Asp.Net MVC provides some simple steps to complete this task with few lines of code.

First, create an action in the controller and write a single line which will return that on the view. This type of view is called HttpGet method which only used to get the values on the page, in this case we don’t want any value from this action so we are returning only null view.

public ActionResult RadioList()
{
return View();
}

Add a view having the same name as in above action which have four radio buttons of same name and values defined sequentially, as written in below code:

<h2>RadioList</h2>
@using (Html.BeginForm())
{
    <div>
        <ul>
            <li>@Html.RadioButton("radioList", 1) RadioButton 1 </li>
            <li>@Html.RadioButton("radioList", 2) RadioButton 2 </li>
            <li>@Html.RadioButton("radioList", 3) RadioButton 3 </li>
            <li>@Html.RadioButton("radioList", 4) RadioButton 4 </li>
        </ul>

        <input type="submit" value="Submit" id="submitBtn" />
    </div>
}

All of these radio buttons have the same name “radioList” that may be changed. The last line of above code have a submit button which will submit the values of this page to the action written on the same controller and of course same name. This type of method is called HttpPost, written below:

[HttpPost]
public ActionResult RadioList(FormCollection collection)
{
ValueProviderResult result = collection.GetValue("radioList");
string checkedValue = result.AttemptedValue;
return View();
}

The parameter “collection” will have all the values input by the user on the view, now we have to access the checked value of the radiobutton list defined on the view. The class System.Web.Mvc.ValueProviderResult used to represents the result of binding a value (such as from a form post or query string) to an action-method argument property, or to the argument itself.

After getting the value from the collection the checked value is stored in AttemptedValue property of this class’s object. So we have simply accessed the checked value from the view.

Sorting and Searching in MVC

Expression Evaluation and Compound Expression in JAVA

As discussed in earlier articles, expressions can either be pure expressions or mixed expressions. Pure expressions have all operands of same datatypes, contrary to mixed expressions that have operands of mixed datatypes.

Evaluating Pure Expressions

Pure expressions produce the result having the same datatypes as that of its operands e.g.

Int a = 5, b = 2, c;
a + b will produce result 7 of int type.
a/b will produce result 2 of int type.
Notice that it will not produce 2.5, it will produce 2.

Evaluating Mixed Expressions

In Java, when a mixed expression is evaluated, it is first divided into component sub-expressions up to the level of two operands and an operator. Then the type of sub-expression is decided keeping in mind general conversion rules. Using the results of sub-expressions, the next higher level of expression is evaluated and its type is determined. This process is continued till you get the final result of the expression.

Boolean (Logical) Expressions

The expressions that result into false or true called Boolean expressions. The Boolean expressions are combination of constants, variables and logical and relational operators. The rule for writing Boolean expressions states :

A Boolean expression may contain just one signed or unsigned variable or a constant, or it may have two or more variable or/and constant, or two or more expressions joined by valid relational and/or logical operators. Two or more variable or operators should not occur in continuation.

The following are examples of some valid Boolean expressions :
(i) x > y (ii) (y + z) >= (x/z)
(iii) (a + b) > c&& (c + d) > a (iv) (y > x) || (z<y)
(v) x||y && z (vi) (x)
(vii) (-y) (viii) (x-y)
(ix) (x > y) && ( !y < z) (x) x <= !y && z

Compound Expression

A compound expression is the one which is made up by combining two or more simple expressions with the help of operator. For example,
(a +b)  / (c +d)
Is a compound expression.
(a > b)  || (b > c)
Is example of another compound expression.

Type Conversion and its Types used in JAVA

An implicit type conversion is a conversion performed by the compiler without programmer’s intervention. An implicit conversion is applied generally whenever differing data types are intermixed in an expression (mixed mode expression), so as not to lose information.

The Java compiler converts all operands up to the type of the largest operand, which is called type promotion. This is done operation by operation, as described in the following type conversion rules
If either operand is of type double, the other is converted to double.

• Otherwise, if either operand is of type float, the other is converted to float.
• Otherwise, if either operand is of type long, the other is converted to long.
• Otherwise, both operands are converted to type int.

Once these conversion rules have been applied, each pair of operands is of same type and the result of each operation is the same as the type of both operands.

The implicit type conversion wherein datatypes are promoted is known as Coercion.

Although coercion exempts the user from worrying about different datatype of operands, yet it has one disadvantage. Coercions decrease the type error detection ability of the compiler. You have already used the implicit type conversion unknowingly. Recall that you use “ “ + <number> (e.g., “ “ +5) to convert it to string.

Explicit type conversion

An explicit type conversion is user-defined that forces an expression to be specific type. The explicit conversion of an operand to a specific Type Casting. Type casting in Java is done as shown below :

(type) expression Where type is a valid Java data type to which the conversion is to be done. For example, to make sure that the expression (x + y/2) evaluates to type float, write it as: (float) (x +y /2)

Casts are often considered as operators. As an operators, a cast is unary and has the same precedence as any other unary operator.

Below is a table that indicates to which of the other primitive types a given primitive data type can be cast. The symbol C indicates that an explicit cast is required since the precision is decreasing. The symbol A indicates that the precision is increasing so an automatic cast occurs without the need for an explicit cast. N indicates that the conversion is not allowed.

The * asterisk indicates that the least significant digits, may be lost in the conversion even though the target type allows for bigger numbers. For example, a large value in an int type value that uses all 32 bits will lose some of the lower bits when converted to float since the exponent uses 8 bits of the 32 provided for float value.

Assigning a value to a type with a greater range (e.g. from short to long) poses no problem, however, assigning a value of larger data type to a smaller data type (e.g., from double to float) may result in losing some precision.

Programmer cannot typecast a Boolean type to another primitive type and viceversa. So, we cannot cast a primitive type to an object reference, or viceversa.  

Expression and its types

Expressions and its types used in JAVA

An expressions is composed of one or more operations. The objects of the operation(s) are referred to as operands. The operations are represented by operators. Therefore, operators, constants, and variables are the constituents of expressions.

An Expression in Java is any valid combination of operators, constants, and variables are the constituents of Java tokens. The expression in Java can be of any type

• Arithmetic expression
• Compound expression
• Relational (or logical) expression

Type of operators used in an expression determine the expression type. For instance, if an expression is formed using arithmetic operator, it is an arithmetic expression; if an expression has relational and/or Boolean operators, it is a Boolean expression. An arithmetic expression always results in a number (integer or real) and a logical expression always results in a logical value i.e., either true or false.

Arithmetic Expressions

Arithmetic expressions can either be pure integer expressions or pure real expressions. Sometimes a mixed expression can also be formed which is a mixture of real and integer expressions.

In pure expressions, all the operands are of same type. And in mixed expressions, the operands are of mixed or different data types.

Integer expressions are formed by connecting integer constants and/or integer variables using integer arithmetic operators.  The following are valid integer expression:

final int count = 30
int I, J, K, X, Y, Z
– J, K – X, K + X – Y + count, – J + K * Y, J/Z, Z % X

Real expression are formed by connecting real constants and/or real variables using real arithmetic operators. The following are valid real expression:

final float bal = 250.3f:
float qty, amount value;
double fin, inter;

Rule for these arithmetic expressions is the same and it states that:
An arithmetic expression may contain just one numeric variable or a constant, or it may have two or more variables or/and constants, or two or more expressions joined by valid arithmetic operators. Two or more variables or operators should not occur in continuation.

Apart from variables, constants and arithmetic operators, an arithmetic expression may consist of Java’s mathematical functions that are part of Java standard library and are available through Math class defined in java.lang package. The following image lists various math functions that are defined in the Math class of Java.lang package.

You can use these math functions as per following syntax:
Math.Function_name (argument list) ---- The arguments are the values required by a function to work upon. For example, to calculate ab, you may write: math.pow(a, b)

Following are examples of valid arithmetic expressions :
Given     int a, b, c ;  float, p, q, r ; double x, y, z ;
a/b, p/q +a-c, x/y + p*a/b, Math .sqrt (b)*a) – c, Math.ceil (p) + a)/c, Math. Max (c,b) +x/y – z/q +c  

Following are example of invalid arithmetic expressions :
Given int , a, b, c ;  float, p, q, r ;   double x, y, z ;
x + * r      two operators on continuation.
q(a + b – z/4)   operator missing between q and parenthesis.
Math.pow (0, - 1)  Domain error because if base = 0 then exp should not be <= 0.
n *log (-3) + p/q  Domain error because logarithm of negative number is not possible.