{"id":64,"date":"2019-01-16T15:49:48","date_gmt":"2019-01-16T15:49:48","guid":{"rendered":"https:\/\/www.kindsonthegenius.com\/java\/?p=64"},"modified":"2019-03-02T04:36:11","modified_gmt":"2019-03-02T04:36:11","slug":"11-java-basic-operators","status":"publish","type":"post","link":"https:\/\/kindsonthegenius.com\/java\/11-java-basic-operators\/","title":{"rendered":"Java – Basic Operators"},"content":{"rendered":"

Basic Java Operators includes the following:<\/p>\n

    \n
  1. Arithmetic Operators<\/a><\/li>\n
  2. Relational Operators<\/a><\/li>\n
  3. Bitwise Operators<\/a><\/li>\n
  4. Logical Operators<\/a><\/li>\n
  5. Assignment Operators<\/a><\/li>\n
  6. Miscellaneous Operators<\/a><\/li>\n<\/ol>\n

     <\/p>\n

    1. Arithmetic Operators<\/strong><\/h4>\n

    You use arithmetic operators for math statements. Hence, they are used when you need to to some calculation. I provide a list of arithmetic operators below. Also, a brief explanation of each of them.<\/p>\n

    Let X = 10 and Y = 20<\/p>\n\n\n\n\n\n\n\n\n\n\n
    Operator<\/th>\nBrief description<\/th>\nAn example<\/th>\n<\/tr>\n
    + (Addition)<\/td>\nAdds values on both sides of the operator.<\/td>\nX + Y will give 30<\/td>\n<\/tr>\n
    – (Subtraction)<\/td>\nSubtracts right-side operand from left-side operand.<\/td>\nX – Y will give -10<\/td>\n<\/tr>\n
    * (Multiplication)<\/td>\nMultiplies values on both side of the operator.<\/td>\nX * Y will give 200<\/td>\n<\/tr>\n
    \/ (Division)<\/td>\nDivides left-side operand by right-side operand.<\/td>\nY \/ X will give 2<\/td>\n<\/tr>\n
    % (Modulus)<\/td>\nDivides left-side operand by right-side operand and produces the remainder.<\/td>\nY % X will give 0<\/td>\n<\/tr>\n
    ++ (Increment)<\/td>\nReduces the value of operand by 1.<\/td>\nY++ gives 21<\/td>\n<\/tr>\n
    — (Decrement)<\/td>\nReduces the value of operand by 1.<\/td>\nY– gives 19<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    Table 1.0: List of Arithmetic Operators<\/p>\n

     <\/p>\n

    2. Relational Operators<\/strong><\/h4>\n

    You use relational operator to test for conditions. Therefore, you see them in conditional statements. Normally with if statements. Table 1.1 gives list of relational operators.<\/p>\n

    Here X = 10 and Y = 20<\/p>\n\n\n\n\n\n\n\n\n\n
    Operator<\/th>\nBrief description<\/th>\nAn example<\/th>\n<\/tr>\n
    == (is equal to)<\/td>\nTests if the values of two operands are equal or not, if true then condition returns true.<\/td>\n(X == Y) is not true.<\/td>\n<\/tr>\n
    != (is not equal to)<\/td>\nTests if the values of two operands are equal or not, if values are not equal then condition returns true.<\/td>\n(X != Y) is true.<\/td>\n<\/tr>\n
    > (is greater than)<\/td>\nTests if the value of left operand is greater than the value of right operand, if true then condition returns true.<\/td>\n(X > Y) is not true.<\/td>\n<\/tr>\n
    < (is less than)<\/td>\nTests if the value of left operand is less than the value of right operand, if true then condition returns true.<\/td>\n(X < Y) is true.<\/td>\n<\/tr>\n
    >= (is greater than or equal to)<\/td>\nTests if the value of left operand is greater than or equal to the value of right operand, if true then condition returns true.<\/td>\n(X >= Y) is not true.<\/td>\n<\/tr>\n
    <= (is less than or equal to)<\/td>\nTests if the value of left operand is less than or equal to the value of right operand, if true then condition returns true.<\/td>\n(X <= Y) is true.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    Table 1.1: List of Relational Operators<\/p>\n

     <\/p>\n

    3. Bitwise Operators<\/strong><\/h4>\n

    We use Bitwise Operators to perform bit-by-bit operations. For that reason, the operands need to be binary numbers.<\/p>\n

    Let x = 60 and y = 13. Converting them to binary, we then have:<\/p>\n

    x = 00111100<\/p>\n

    y = 00001101<\/p>\n

      \n
    • x&y = 0000 1100<\/li>\n
    • x|y = 0011 1101<\/li>\n
    • x^y = 0011 0001<\/li>\n
    • ~x\u00a0 = 1100 0011<\/li>\n<\/ul>\n

      Table 1.3 provides a list of bitwise operators<\/p>\n\n\n\n\n\n\n\n\n\n\n
      Operator<\/th>\nBrief description<\/th>\nAn example<\/th>\n<\/tr>\n
      & (bitwise and)<\/td>\nBinary AND Operator produces a bit in the result if it exists in both operands.<\/td>\n(x & y) will yield 12 which is 0000 1100<\/td>\n<\/tr>\n
      | (bitwise or)<\/td>\nBinary OR Operator produces a bit if it exists in either operand.<\/td>\n(x | y) will yield 61 which is 0011 1101<\/td>\n<\/tr>\n
      ^ (bitwise XOR)<\/td>\nBinary XOR Operator produces the bit if it is set in one operand but not both.<\/td>\n(x ^ y) will yield 49 which is 0011 0001<\/td>\n<\/tr>\n
      ~ (bitwise compliment)<\/td>\nBinary Ones Complement Operator is a unary operator and has the effect of ‘switching’ the\u00a0 bits.<\/td>\n(~x ) will yield -61 which is 1100 0011 in 2’s complement form due to a signed binary number.<\/td>\n<\/tr>\n
      << (left shift)<\/td>\nBinary Shift Left Operator. The left operands value is moved left by the number of bits given in the right operand.<\/td>\nx << 2 will yield 240 which is 1111 0000<\/td>\n<\/tr>\n
      >> (right shift)<\/td>\nBinary Shift Right Operator. The left operands value is moved right by the number of bits given int the right operand.<\/td>\nA >> 2 will yield 15 which is 1111<\/td>\n<\/tr>\n
      >>> (zero right fill shift)<\/td>\nRight Shift zero fill operator. The left operands value is moved right by the number of bits given int the right operand and shifted values are filled up with zeros.<\/td>\nA >>>2 will yield 15 which is 0000 1111<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

      Table 1.2: List of Bitwise Operators<\/p>\n

       <\/p>\n

      4. Logical Operators<\/strong><\/h4>\n

      Logical operators are used for logical operations.<\/p>\n

      Let X = true and Y = false, then the Table 1.3 give a list of logical operations on X and Y.<\/p>\n\n\n\n\n\n\n
      Operator<\/th>\nBrief description<\/th>\nAn example<\/th>\n<\/tr>\n
      && (logical and)<\/td>\nThis is the Logical AND operator. If both the operands are non-zero, then the condition results in true.<\/td>\n(X && Y) is false<\/td>\n<\/tr>\n
      || (logical or)<\/td>\nThis is the Logical OR Operator. If any of the two operands are non-zero, then the condition results in true.<\/td>\n(X || Y) is true<\/td>\n<\/tr>\n
      ! (logical not)<\/td>\nThis is the Logical NOT Operator. You use it to reverse the logical state of its operand. If a condition is true then Logical NOT operator will make false and vice versa<\/td>\n!(X && Y) is true<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

      Table 1.3: List of Logical Operators<\/p>\n

       <\/p>\n

      5. Assignment Operators<\/strong><\/h4>\n

      You use assignment operators to assign values to variables. Table 1.4 provides a list of assignment operators.<\/p>\n

      They are like two-in-on operations. With exception of simple assignment.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
      Operator<\/th>\nBrief description<\/th>\nAn example<\/th>\n<\/tr>\n
      =<\/td>\nThis is simple assignment operator. Assigns values from right side operands to left side operand.<\/td>\nZ = X + Y will assign value of X + Y into Z<\/td>\n<\/tr>\n
      +=<\/td>\nAdd operator together with assignment operator. It adds right operand to the left operand and assigns the result to left operand.<\/td>\nZ += X is equivalent to Z = Z + X<\/td>\n<\/tr>\n
      -=<\/td>\nSubtract operator together with assignment operator. It subtracts right operand from the left operand and assigns the result to left operand.<\/td>\nZ -= X is equivalent to Z = Z \u2013 X<\/td>\n<\/tr>\n
      *=<\/td>\nMultiply operator together with assignment operator. It multiplies right operand with the left operand and assigns the result to left operand.<\/td>\nZ *= X is equivalent to Z = X * X<\/td>\n<\/tr>\n
      \/=<\/td>\nDivide operator with assignment operator. It divides left operand with the right operand and assigns the result to left operand.<\/td>\nZ \/= X is equivalent to X = Z \/ X<\/td>\n<\/tr>\n
      %=<\/td>\nModulus operator together with assignment operator. It takes modulus using two operands and assigns the result to left operand.<\/td>\nZ %= X is equivalent to Z = Z % X<\/td>\n<\/tr>\n
      <<=<\/td>\nLeft shift AND assignment operator.<\/td>\nZ <<= 2 is same as Z = Z << 2<\/td>\n<\/tr>\n
      >>=<\/td>\nRight shift AND assignment operator.<\/td>\nZ >>= 2 is same as Z = Z >> 2<\/td>\n<\/tr>\n
      &=<\/td>\nBitwise AND assignment operator.<\/td>\nZ &= 2 is same as Z = Z & 2<\/td>\n<\/tr>\n
      ^=<\/td>\nbitwise exclusive OR and assignment operator.<\/td>\nZ ^= 2 is same as Z = Z ^ 2<\/td>\n<\/tr>\n
      |=<\/td>\nbitwise inclusive OR and assignment operator.<\/td>\nZ |= 2 is same as Z = Z | 2<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

      Listing 1.4: List of Assignment Operators<\/p>\n

       <\/p>\n

      6. Miscellaneous Operators<\/strong><\/h4>\n

      Finally, we now consider two miscellaneous operators.<\/p>\n

        \n
      • Conditional Operator (?:)<\/li>\n
      • InstanceOf Operator (instanceof)<\/li>\n<\/ul>\n

         <\/p>\n

        Conditional Operator<\/strong><\/p>\n

        This is also called ternary operator. This is because it uses three operators. You can probably consider it a shortened if statement.<\/p>\n

        You used it to conditionally assign a value to a variable. It evaluates a condition. If the condition is true, then assign a value, if false, assign alternate value.<\/p>\n

        The syntax is:<\/p>\n

        <\/p>\n

        \n
        \tvariable =<\/span> (<\/span>condition)<\/span> ?<\/span> value_if_true :<\/span> value_if_false\r\n<\/pre>\n<\/div>\n
        Take an example in Listing 1.0 below.<\/p>\n
        <\/p>\n
        \n
        public<\/span> class<\/span> Tester<\/span> {<\/span>\r\n\r\n   public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String args[])<\/span> {<\/span>\r\n      int<\/span> x;<\/span>\r\n      int<\/span> y;<\/span>\r\n      x =<\/span> 5<\/span>;<\/span>\r\n      y =<\/span> (<\/span>x ==<\/span> 10<\/span>)<\/span> ?<\/span> 100<\/span>:<\/span> 200<\/span>;<\/span>\r\n      System.<\/span>out<\/span>.<\/span>println<\/span>(<\/span> \"x is : \"<\/span> +<\/span>  y );<\/span> \/\/ y is assigned 200<\/span>\r\n\r\n      y =<\/span> (<\/span>x ==<\/span> 5<\/span>)<\/span> ?<\/span> 100<\/span>:<\/span> 200<\/span>;<\/span>\r\n      System.<\/span>out<\/span>.<\/span>println<\/span>(<\/span> \"x is : \"<\/span> +<\/span> y );<\/span> \/\/y is assigned 100<\/span>\r\n   }<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
        Listing 1.0: Example of Conditional Operator<\/p>\n
         <\/p>\n
        I would recommend you try this yourself. Copy and paste the code in your IDE. Then run it to see the output.<\/p>\n
         <\/p>\n
        instanceof Operator<\/strong><\/p>\n
        You use this operator only for object reference variables. It tests whether an object is an object of a given class. The syntax is<\/p>\n
        <\/p>\n
        \n
        object_variable instanceof<\/span> class_name\r\n<\/pre>\n<\/div>\n
        If the object variable is an instance of the class, it returns true. Otherwise, it returns false.<\/p>\n
         <\/p>\n
        Example is given in Listing 1.1 below<\/p>\n
        <\/p>\n
        \n
        public<\/span> class<\/span> Tester<\/span> {<\/span>\r\n\r\n   public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String args[])<\/span> {<\/span>\r\n\t      String website =<\/span> \"Java Tutorials\"<\/span>;<\/span>\r\n\r\n\t      boolean<\/span> answer =<\/span> website instanceof<\/span> String;<\/span>\r\n\t      System.<\/span>out<\/span>.<\/span>println<\/span>(<\/span> answer );<\/span>    \r\n   }<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
        Listing 1.1: Example of instanceof<\/p>\n
         <\/p>\n
        The output of Listing 1.1 would be true. This is because the string website is an instance of the String wrapper class.<\/p>\n","protected":false},"excerpt":{"rendered":"
        Basic Java Operators includes the following: Arithmetic Operators Relational Operators Bitwise Operators Logical Operators Assignment Operators Miscellaneous Operators   1. Arithmetic Operators You use arithmetic … <\/p>\n","protected":false},"author":395,"featured_media":65,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"categories":[2],"tags":[],"class_list":["post-64","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java-tutorial"],"_links":{"self":[{"href":"https:\/\/kindsonthegenius.com\/java\/wp-json\/wp\/v2\/posts\/64","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/kindsonthegenius.com\/java\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/kindsonthegenius.com\/java\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/kindsonthegenius.com\/java\/wp-json\/wp\/v2\/users\/395"}],"replies":[{"embeddable":true,"href":"https:\/\/kindsonthegenius.com\/java\/wp-json\/wp\/v2\/comments?post=64"}],"version-history":[{"count":3,"href":"https:\/\/kindsonthegenius.com\/java\/wp-json\/wp\/v2\/posts\/64\/revisions"}],"predecessor-version":[{"id":68,"href":"https:\/\/kindsonthegenius.com\/java\/wp-json\/wp\/v2\/posts\/64\/revisions\/68"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/kindsonthegenius.com\/java\/wp-json\/wp\/v2\/media\/65"}],"wp:attachment":[{"href":"https:\/\/kindsonthegenius.com\/java\/wp-json\/wp\/v2\/media?parent=64"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/kindsonthegenius.com\/java\/wp-json\/wp\/v2\/categories?post=64"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/kindsonthegenius.com\/java\/wp-json\/wp\/v2\/tags?post=64"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}