Programming Languages‎ > ‎Java‎ > ‎

02. Java Basics

Java Identifiers

Rules for Identifiers (names of variables, constants, classes, labels, methods):

  • First character must be a letter ('a'-'z', 'A' - 'Z', or any Unicode** letter), underscore ('_') or dollar sign (')
  • All other characters can be letters, digits ('0'-'9'), underscore or dollar sign
  • Names are case-sensitive (e.g., FEET is different from Feet)
  • Names are language-sensitive (e.g., Latin letters are considered different from corresponding Greek letters)
  • All characters are significant
  • The length is unlimited
  • cannot be a Java keyword
Java naming conventions:
  • Class and interface names start with uppercase letter
  • Method and variable names start with a lowercase letter
  • If any name consists of more than one "word", then capitalize all words after the first (also known as "camel case")


Java DataTypes

Integral Types (values are pos. & neg. whole numbers and 0): int, short, long, byte

  • There are no unsigned integers (unlike C)
  • Integral literals are always stored as int unless otherwise specified

Floating Types (values can have a fraction and/or exponent):  float, double (unlike C, there's NO long double type)

  • Literals which have a decimal point or fraction are automatically stored as double, unless otherwise specified
char
  •  Size: 16 bits, Min. value: \u0000, (\u is used to indicate a unicode value in hexadecimal-- see p. 5) max. value: \uFFFF
  •  Character literals are always enclosed in single quotes (see next page)
  •  Java uses the *Unicode character set to accommodate international characters. The first 127 values are the standard ASCII character set

boolean

  • The only possible values are true or false (default value for a class-scope boolean variable is false)
  • println() will display true or false (not 1 or 0, as in C/C++)
  • No casting is allowed from boolean to int or vice-versa (unlike C/C++), so you cannot assign an int expression to a boolean variable nor a boolean expression to an int variable


BITWISE Operators

  • Bitwise operators (like the C/C++ bitwise operators) manipulate data bit by bit (i.e., the corresponding bits of the operands are operated on) and may be applied only to integral operands: byte, short, int or long.

&   bitwise AND (1 if both corresponding bits are 1)
|    bitwise OR ( 1 if at least one corresponding bit is 1)
^   bitwise exclusive OR (1 only if one corresponding bit is 1)
<< left shift (shifts left operand the # of bits specified by right operand
>> right shift with sign extension
>>>  right shift with zero extension
~   one's complement (unary: changes 1's to 0's and 0's to 1's)

/*
short num1, num2, mask;        // assume num1 has been assigned a number, doesn't matter what
Exercise 2.1 Write Java statements using the above variables to assign bits 4, 5, 6, and 7 (counting the left-most as bit 0) to num2, but in the least significant bits of num2 (bits 12, 13, 14 and 15). Hints: shift num1 so bit 4 is in position 12, then use a mask of 0x000F and the correct bitwise operator to get the result specified.
*/
public class Exercise_2_1
{

    public static void main(String[] args)
    {
        short num1, num2, mask;                       // 0123 4567 8901 2345
        num1 = 0x0573;                                // num1 = 0000 0101 0111 0011
        mask = 0x000F;                                // mask = 0000 0000 0000 1111
        num2 = (short) (mask & (num1 >>> 8));         // num2 = 0000 0000 0000 0101
        System.out.println("num1: " + Integer.toHexString(num1) + "\nmask: " + Integer.toHexString(mask) + "\nnum2: " + Integer.toHexString(num2));
    }
}

Arithmetic operators:

+       Addition
-        Subtraction
*        Multiplication
/        Division (integral result if both operands are integral)
%      Modulus (remainder of integer division)
 - (unary) Arithmetic negation         + (unary)

Cast Operator:

  • To change the type of an expression, you may give the type in parentheses in front of the expression: (type) expression
  • Examples:  d1 =(double) i1/i2;

                     i2 = (int)(d1+d2);

Shorthand Assignment Operators:

  • Any operation with an assignment such as: var = var operator operand
  • can be written as: var operator= operand

boolean Operators:

  • NOTE: ALL boolean operators result in true or false, unlike C (NOT 1 or 0).  Also, ALL boolean variables must be assigned a boolean expression (results in true or false, so unlike C, not any non-zero or zero value)!

Relational Operators:

  • evaluate to true or false

          OPERATORS:
                   <       less than
                   >       greater than
                   <=    less than or equal to
                   >=    greater than or equal to
                   ==    is equal to
                   !=      not equal to

Logical Operators:

Operators
  !        Unary negation (NOT)
            True if operand is False
  &&    Logical AND (short-circuited*)
            True only if both operands are True
   ||     Logical OR  (short-circuited*)
            True if at least one operand is True
  &       Logical AND (both operands eval.)
            True only if both operands are True
  |        Logical OR (both operands eval.)
            True if at least one operand is True
  ^       Logical Exclusive-OR
            True if ONLY ONE operand is True

Examples
!(a < b)

(ch>='a')&&(ch<='z')

(x==0) || (y==0)

(i1>0) & (i2>0)

i1++<10 | i2++<10

( n1!=0 ) ^ (n2!=0 )

/*Exercise 2.2 Change the following C/C++ code to legal Java code:
*    int inum1=5, inum2=8;
*    while( inum1-- ){ // OK in C, NOT in Java
*    printf("%d", inum1);
*    } // end while
*/
public class Exercise_2_2
{

    public static void main(String[] args)
    {
        int inum1=5, inum2=8;
        while( inum1-- != 0 )
        {
            System.out.println(inum1);
        } // end while
    }
}


/* Exercise 2.3 Change the following incorrect Java code (won't compile because you're trying to re-declare inum2):
    int inum1=10, inum2;
    for(int i=0, inum2=inum1; i < inum2; ++i, --inum2){
    System.out.println("i = " + i);
    } // end for
    System.out.println("The last value of inum2 = "+inum2);
 */
public class Exercise_2_3
{

    public static void main(String[] args)
    {

        int inum1 = 10, inum2;
        inum2 = inum1;
        for(int i=0; i < inum2; ++i, --inum2){
        System.out.println("i = " + i);
        } // end for
        System.out.println("The last value of inum2 = "+inum2);
    }
}


/* Exercise 2.4 Write Java code to print (lined up in columns) numbers from 2 to 20, their squares and their cubes, using a for loop (declare variables for the number as an int, and the square and cube as doubles). Use System.out.printf and right-justify the numbers.
*/
public class Exercise_2_4
{
    public static void main(String[] args)
    {
        int i_num = 2;
        double d_square, d_cube;
        for(int i=2; i <= 20; i++, i_num++)
        {
            d_square = i_num * i_num;
            d_cube = i_num * i_num * i_num;
            System.out.printf("%d %8.2f %8.2f \n", i_num, d_square, d_cube);
        }
    }
}



Comments