Java主類結構：運算子

標籤：三元   print   rgs   ++   調用   span   並且   red   OLE   

賦值運算子

int a=100

賦值運算子以符號“=”表示他是一個二元運算子，其功能是將有房運算元包含的值付給作坊操作。

a被定義為int類型並賦值為100，就完成了賦值運算。

public class demo {
    public static void main(String[] args) {
  int a,b,c;//a,b,c都被定義為int類型
  a=15;
     c=b=a+4;
     System.out.println("c的值為"+c);
     System.out.println("b的值為"+b);
 }
}

 

列印結果為：c的值為19
                      b的值為19

算數運算子：顧名思義，算數的方法運算也就是+、-、*(乘)、/(除)、%（取餘）

其格式為：

public class Arith {
   public static void main(String[] args) {
 float number1=45.56f;//float為浮點型聲明float型並賦值
 int number2=152;//聲明int整數型並賦值
 System.out.println("和為"+(number1+number2));
 System.out.println("差為"+(number2-number1));
 System.out.println("相乘為"+(number2*number1));
 System.out.println("相除為"+(number2/number1));
 System.out.println("取餘數"+(number2%number1));
   }

運算結果為：和為197.56
                     差為106.44
                    相乘為6925.12
                    相除為3.3362598
                    取餘數15.319996

自增和自減法

條件：必須是整數型或浮點型變數，然後在整數或者浮點型數的前提下自動成長1

public class Increase_自增 {
  public static void main(String[] args) {
 int b;
 int a = 0;
 b=++a;
 System.out.println(b);
  }
}

運算結果為：1

自減：在運算過程中會有自動減掉1比如：0運算後的結果為-1

public class reduction_自減 {
 public static void main(String[] args) {
  int b;
  int a = 0;
  b=--a;
  System.out.println(b);
 }
 
}

運算結果為：-1

與c語言的區別

public class java中自增自減運算與c中自增自減的區別 {
    public static void main(String[] args) {
  int j=0;
  for (int i=0;i<100;i++){
   j=j++;
  }
  System.out.println(j);
 }
}

運算結果：0

1. java中間緩衝變數的機制，在java中，執行自增運算時，會給每個自增操作分配一個臨時 
2. 變數，如果是首碼加（++i），就會先自加1後賦值給臨時變數；如果是尾碼加（i++），就會 
3. 先賦值給臨時變數後自加1.運算最終使用的，並不是變數本身，而是被賦值了得臨時變數。 
4. 所以上面的j=j++：
   1. temp=j; 
   2. j=j+1; 
   3. j=temp; 

中間緩衝機制：

public class java_中間緩衝變數機制 {
 public static  void main(String[] args){         
        method_1();  //從主方法裡面調用method_1()的靜態方法
        method_2();   //從主方法裡面調用method_2()的靜態方法
    }

 private static void method_2() {
    int j = 0;  //定義j為int整數型並且賦值0

         for(int i=0;i<100;i++){         //遍曆十進位   
             j = j++; //十進位                        
         }        
         System.out.println("method_1---"+j);     //輸出的方法1的十進位後加法
  
 }

 private static void method_1() {
   int j = 0; 
         for(int i=0;i<100;i++){           
             j = ++j;  //位置略有改變                     
         }        
         System.out.println("method_2---"+j);     
  
 } 
}

比較子：顧名思義就是比較大小或者相等或者大於等於或不等於右方

public class Compare {
    public static void main(String[] args) {
  int number1=4;
  int number2=6;
  System.out.println("number1>number2的傳回值為："+(number1>number2));//比較大小number1>number2大為假。
  System.out.println("number1==number2的傳回值為："+(number1==number2));//numerber1和number2為相等。為假
  System.out.println("number1!=number2的傳回值為："+(number1!=number2));//numerber1和number2不為相等。為真
  System.out.println("number1>=number2的傳回值為："+(number1>=number2));//number1比number2大或相等為假的
 }
}

結果為：number1>number2的傳回值為：false
              number1==number2的傳回值為：false
              number1!=number2的傳回值為：true
               number1>=number2的傳回值為：false

邏輯運算子：運算時進行邏輯上的判斷判斷真假。是否短路針對boolean類型來判斷和運算

//邏輯運算子
//運算子                      含義                                 用法                     結合方向
//&&，&   邏輯與(什麼和什麼的邏輯)      opl&op2         從左至右
//||      邏輯與(什麼或者什麼的邏輯)    opl||op2        從左至右
//!       邏輯非(並不是什麼)           ！op            從右至左
//進行邏輯運算(運算結果)
//運算式1         運算式2        運算式1&&運算式2        運算式1||運算式2        ！運算式1
//true(真)       true(真)          true(真)               true(真)            false(假)
public class Calculation {
     public static void main(String[] args) {
  int a=2;//聲明變數int類型為a
  int b=5;//聲明變數int類型為
  //聲明boolean型變數，用於儲存應用邏輯運算子"&&"後的傳回值
  boolean result=((a>b)&&(a !=b));
  //聲明boolean型變數，用於儲存應用邏輯運算子"||"後的傳回值
  boolean result2=((a>b)||(a !=b));
  System.out.println(result);
  System.out.println(result2);
 }
}

運算結果為：false
                      true

位元運算符：根據二進位十進位十六進位和三十二進位的規則可分為：與運算子、非運算子、或運算子、異或運算子

與運算子：

//但邏輯運算子是針對兩個關係運算子來進行邏輯運算，
//而位元運算符主要針對兩個位元的位進行邏輯運算。
public class And_operator_與運算子 {
 public static void main(String[] args) {
  int a=129;//定義int類型名為a並賦值為129
  int b=128;//定義int類型名為b並賦值為128
  System.out.println("a和b與的結果是："+(a&b));//邏輯為a與b
 }
// “a”的值是129，轉換成二進位就是10000001，
// 而“b”的值是128，轉換成二進位就是10000000。
// 根據與運算子的運算規律，只有兩個位都是1，
// 結果才是1，可
// 以知道結果就是10000000，即128。 

非運算子:
//非運算子用符號“~”表示
public class Not_operator_非運算子 {
 public static void main(String[] args)
 {
 int a=2;
 System.out.println("a 非的結果是："+(~a));
 }
}
//a賦值為2，a=2，根據二進位定理2為10有根據非運算的定律補位所得出的結果為-3

 

或運算子:

public class Or_operator_或運算子 {
// 或運算子
// 或運算子用符號“|”表示，其運算規律如下：
// 兩個位只要有一個為1，那麼結果就是1，否則就為0
 public static void main(String[] args)
 {
 int a=129;
 int b=128;
 System.out.println("a 和b 或的結果是："+(a|b));//a或者b運算結果
 }
// 運行結果
// a 和b 或的結果是：129
// 下面分析這個程式段：
// a 的值是129，轉換成二進位就是10000001，
// 而b 的值是128，
// 轉換成二進位就是10000000，根據或運算子的運算規律，
// 只有兩個位有一個是1，結果才是1，可以知道結果就是10000001，
// 即129。
 }

 

異或運算子

//異或運算子是用符號“^”表示的，其運算規律是：
//兩個運算元的位中，相同則結果為0，
public class Xor_operator_異或運算子 {
  public static void main(String[] args)
  {
  int a=15;
  int b=2;
  System.out.println("a 與 b 異或的結果是："+(a^b));
  }
//  a 與 b 異或的結果是：13
//  分析上面的程式段：a 的值是15，轉換成二進位為1111，
//  而b 的值是2，轉換成二進位為0010，
//  根據異或的運算規律，可以得出其結果為1101 即13。
}

三元運算子：

//boolean b=20<45;?ture:false;

類似於if。。。。else語句可作為判斷條件

Java主類結構：運算子