JAVA修飾符、運算子、迴圈語句

一年都在冬眠發表於2024-08-09
Java

JAVA修飾符

修飾符用來定義類、方法或者變數，通常放在語句的最前端

一、訪問修飾符

1、default預設訪問修飾符：在同一包內可見，不使用任何修飾符，使用物件為類、介面、變數、方法，訪問級別是包級別（package-level）,即只能被同一包中的其他類訪問
2、private私有訪問修飾符：最嚴格的訪問級別，所以被宣告為private的方法、變數和構造方法只能被所屬類訪問，並且類和介面不能宣告為private，宣告為私有訪問型別的變數只能透過類中公共的getter方法被外部類訪問，主要用來隱藏類的實現細節和保護類的資料

public class Logger {
   private String format;
   public String getFormat() {
      return this.format;
   }
   public void setFormat(String format) {
      this.format = format;
   }
}

例項中，Logger類中的format變數為私有變數，所以其他類不能直接得到和設定該變數的值。為了使其他類能夠操作該變數，定義了兩個public方法：getFormat()（返回format的值）和 setFormat(String)（設定format的值）
3、public共有訪問修飾符：被宣告為public的類、方法、構造方法和介面能夠被任何其他類訪問。如果幾個相互訪問的public 類分佈在不同的包中，則需要匯入相應public類所在的包。由於類的繼承性，類所有的公有方法和變數都能被其子類繼承。

  • Java程式的main()方法必須設定成公有的，否則，Java直譯器將不能執行該類。

4、protected受保護的訪問修飾符:
（1）子類與基類在同一包中：被宣告為protected的變數、方法和構造器能被同一個包中的任何其他類訪問
（2）子類與基類不在同一包中：那麼在子類中，子類例項可以訪問其從基類繼承而來的protected方法，而不能訪問基類例項的protected方法

  • protected可以修飾資料成員，構造方法，方法成員，不能修飾類（內部類除外），介面及介面的成員變數和成員方法不能宣告為protected
class AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 實現細節
   }
}
 
class StreamingAudioPlayer extends AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 實現細節
   }
}

父類使用了protected訪問修飾符，子類重寫了父類的 openSpeaker()方法,如果把openSpeaker()方法宣告為 private，那麼除了AudioPlayer外，其他類將不能訪問該方法,只想讓該方法對其所在類的子類可見，則將該方法宣告為protected。
5、訪問控制和繼承：
（1）父類中宣告為public的方法在子類中也必須為public
（2）父類中宣告為protected的方法在子類中要麼宣告為 protected，要麼宣告為public，不能宣告為private
（3）父類中宣告為private的方法，不能夠被子類繼承

二、非訪問修飾符

1、static修飾符：用來修飾類方法和類變數
（1）靜態變數：用來宣告獨立於物件的靜態變數，無論一個類例項化多少物件，它的靜態變數只有一份複製。靜態變數也被稱為類變數。區域性變數不能被宣告為static變數。
（2）靜態方法：用來宣告獨立於物件的靜態方法。靜態方法不能使用類的非靜態變數。靜態方法從引數列表得到資料，然後計算這些資料。

  • 對類變數和方法的訪問可以直接使用classname.variablename和classname.methodname的方式訪問。

3、例項

public class InstanceCounter {
   private static int numInstances = 0;
   protected static int getCount() {
      return numInstances;
   }
 
   private static void addInstance() {
      numInstances++;
   }
 
   InstanceCounter() {
      InstanceCounter.addInstance();
   }
 
   public static void main(String[] arguments) {
      System.out.println("Starting with " +
      InstanceCounter.getCount() + " instances");
      for (int i = 0; i < 500; ++i){
         new InstanceCounter();
          }
      System.out.println("Created " +
      InstanceCounter.getCount() + " instances");
   }
}

Starting with 0 instances
Created 500 instances

2、final修飾符：
（1）final變數：變數一旦賦值後，不能被重新賦值。被 final修飾的例項變數必須顯式指定初始值。final修飾符通常和 static修飾符一起使用來建立類常量。
（2）final方法：父類中的final方法可以被子類繼承，但是不能被子類重寫。宣告final方法的主要目的是防止該方法的內容被修改。

public class Test{
    public final void changeName(){
       // 方法體
    }
}

（3）final類：不能被繼承
3、abstract修飾符
（1）抽象類：不能用來例項化物件，宣告抽象類的唯一目的是為了將來對該類進行擴充。一個類不能同時被abstract和final修飾。如果一個類包含抽象方法，那麼該類一定要宣告為抽象類。抽象類可以包含抽象方法非抽象方法。
（2）抽象方法：一種沒有任何實現的方法，該方法的具體實現由子類提供，不能被宣告成final和static。任何繼承抽象類的子類必須實現父類的所有抽象方法，除非該子類也是抽象類。如果一個類包含若干個抽象方法，那麼該類必須宣告為抽象類。抽象類可以不包含抽象方法。抽象方法的宣告以分號結尾。
4、synchronized修飾符：synchronized關鍵字宣告的方法同一時間只能被一個執行緒訪問。synchronized修飾符可以應用於四個訪問修飾符。
5、transient修飾符：該修飾符包含在定義變數的語句中，用來預處理類和變數的資料型別。

public transient int limit = 55;   // 不會持久化
public int b; // 持久化

6、volatile修飾符

public class MyRunnable implements Runnable
{
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // 第一行
        {
            // 程式碼
        }
    }
    public void stop()
    {
        active = false; // 第二行
    }
}

通常情況下，在一個執行緒呼叫run()方法（在Runnable開啟的執行緒），在另一個執行緒呼叫stop()方法。 如果第一行中緩衝區的active值被使用，那麼在第二行的active值為false時迴圈不會停止。但是以上程式碼中使用了volatile修飾active，所以該迴圈會停止。

JAVA運算子

一、算術運算子

表格中的例項假設整數變數A的值為10，變數B的值為20

運算子 描述 例子
+ 加法 - 相加運算子兩側的值 A + B 等於 30
- 減法 - 左運算元減去右運算元 A – B 等於 -10
* 乘法 - 相乘運算子兩側的值 A * B 等於 200
/ 除法 - 左運算元除以右運算元 B / A 等於 2
% 取餘 - 左運算元除以右運算元的餘數 B%A等於0
++ 自增: 運算元的值增加1 B++ 或 ++B 等於 21
-- 自減: 運算元的值減少1 B-- 或 --B 等於 19

1、自增自減運算子

public class selfAddMinus{
    public static void main(String[] args){
        int a = 3;//定義一個變數；
        int b = ++a;//自增運算
        int c = 3;
        int d = --c;//自減運算
        System.out.println("進行自增運算後的值等於"+b);
        System.out.println("進行自減運算後的值等於"+d);
    }
}

進行自增運算後的值等於4
進行自減運算後的值等於2
  • int b = ++a; 拆分運算過程為: a=a+1=4; b=a=4, 最後結果為b=4,a=4
  • int d = --c; 拆分運算過程為: c=c-1=2; d=c=2, 最後結果為d=2,c=2

2、字首自增自減法(++a,--a): 先進行自增或者自減運算，再進行表示式運算
3、字尾自增自減法(a++,a--): 先進行表示式運算，再進行自增或者自減運算

public class selfAddMinus{
    public static void main(String[] args){
        int a = 5;//定義一個變數；
        int b = 5;
        int x = 2*++a;
        int y = 2*b++;
        System.out.println("自增運算子字首運算後a="+a+",x="+x);
        System.out.println("自增運算子字尾運算後b="+b+",y="+y);
    }
}

自增運算子字首運算後a=6，x=12
自增運算子字尾運算後b=6，y=10

二、關係運算子

運算子 描述 例子
== 檢查如果兩個運算元的值是否相等，如果相等則條件為真 （A == B）為假
！= 檢查如果兩個運算元的值是否相等，如果值不相等則條件為真 (A != B) 為真
> 檢查左運算元的值是否大於右運算元的值，如果是那麼條件為真 （A> B）為假
< 檢查左運算元的值是否小於右運算元的值，如果是那麼條件為真 （A <B）為真
>= 檢查左運算元的值是否大於或等於右運算元的值，如果是那麼條件為真 （A> = B）為假
<= 檢查左運算元的值是否小於或等於右運算元的值，如果是那麼條件為真 （A <= B）為真

三、位運算子

應用於整數型別(int)，長整型(long)，短整型(short)，字元型(char)，和位元組型(byte)等型別。位運算子作用在所有的位上，並且按位運算。
A = 00111100，B = 00001101

運算子 描述 例子
& 如果相對應位都是1，則結果為1，否則為0 (A＆B）得到12，即00001100
或 如果相對應位都是0，則結果為0，否則為1 （A或B）得到61，即00111101
^ 如果相對應位值相同，則結果為0，否則為1 （A^B）得到49，即00110001
~ 按位取反運算子翻轉運算元的每一位，即0變成1，1變成0 （〜A）得到-61，即11000011
<< 按位左移運算子。左運算元按位左移右運算元指定的位數 A <<2得到240，即11110000
>> 按位右移運算子。左運算元按位右移右運算元指定的位數 A >> 2得到15即1111
>>> 按位右移補零運算子。左運算元的值按右運算元指定的位數右移，移動得到的空位以零填充 A>>>2得到15即00001111

四、邏輯運算子

假設布林變數A為真，變數B為假

運算子 描述 例子
&& 稱為邏輯與運算子。當且僅當兩個運算元都為真，條件才為真 （A && B）為假
稱為邏輯或運算子。如果任何兩個運算元任何一個為真，條件為真 （A B）為真
！ 稱為邏輯非運算子。用來反轉運算元的邏輯狀態。如果條件為true，則邏輯非運算子將得到false ！（A && B）為真
  • 短路邏輯運算子：當使用與邏輯運算子時，在兩個運算元都為true時，結果才為true，但是當得到第一個操作為false時，其結果就必定是false，這時候就不會再判斷第二個操作了

五、賦值運算子

運算子 描述 例子
= 簡單的賦值運算子，將右運算元的值賦給左側運算元 C = A + B將把A + B得到的值賦給C
+= 加和賦值運算子，它把左運算元和右運算元相加賦值給左運算元 C + = A等價於C = C + A
-= 減和賦值運算子，它把左運算元和右運算元相減賦值給左運算元 C - = A等價於C = C - A
*= 乘和賦值運算子，它把左運算元和右運算元相乘賦值給左運算元 C * = A等價於C = C * A
/= 除和賦值運算子，它把左運算元和右運算元相除賦值給左運算元 C / = A，C 與 A 同型別時等價於 C = C / A
（％）= 取模和賦值運算子，它把左運算元和右運算元取模後賦值給左運算元 C％= A等價於C = C％A
<< = 左移位賦值運算子 C << = 2等價於C = C << 2
>> = 右移位賦值運算子 C >> = 2等價於C = C >> 2
＆= 按位與賦值運算子 C＆= 2等價於C = C＆2
^ = 按位異或賦值運算子 C ^ = 2等價於C = C ^ 2
按位或賦值運算子

六、條件運算子（？：）

也被稱為三元運算子。該運算子有3個運算元，並且需要判斷布林表示式的值。該運算子的主要作用是決定哪個值應該賦值給變數。
variable x = (expression) ? value if true : value if false

public class Test {
   public static void main(String[] args){
      int a , b;
      a = 10;
      // 如果 a 等於 1 成立，則設定 b 為 20，否則為 30
      b = (a == 1) ? 20 : 30;
      System.out.println( "Value of b is : " +  b );
 
      // 如果 a 等於 10 成立，則設定 b 為 20，否則為 30
      b = (a == 10) ? 20 : 30;
      System.out.println( "Value of b is : " + b );
   }
}

Value of b is : 30
Value of b is : 20

七、instanceof運算子

用於操作物件例項，檢查該物件是否是一個特定型別（類型別或介面型別）
( Object reference variable ) instanceof (class/interface type)
如果運算子左側變數所指的物件，是運算子右側類或介面(class/interface)的一個物件，那麼結果為真

String name = "James";
boolean result = name instanceof String; // 由於 name 是 String 型別，所以返回真

如果被比較的物件相容於右側型別，該運算子仍然返回 true

class Vehicle {}
 
public class Car extends Vehicle {
   public static void main(String[] args){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result);
   }
}

true

八、Java運算子優先順序

字尾（括號類、點運算子） > 一元（自增自減） > 乘性（* /％） > 加性 > 移位 > 關係（>>= <<=） > 相等 > 按位與 > 按位異或 > 按位或 > 邏輯與 > 邏輯或 > 條件 > 賦值 > 逗號

JAVA迴圈語句

一、while迴圈

while( 布林表示式 ) {
  //迴圈內容
}

只要布林表示式為 true，迴圈就會一直執行下去

二、do...while迴圈

對於while語句而言，如果不滿足條件，則不能進入迴圈。但有時候我們需要即使不滿足條件，也至少執行一次。do…while迴圈和 while迴圈相似，不同的是，do…while迴圈至少會執行一次

do {
       //程式碼語句
}while(布林表示式);

public class Test {
   public static void main(String[] args){
      int x = 10;
 
      do{
         System.out.print("value of x : " + x );
         x++;
         System.out.print("\n");
      }while( x < 20 );
   }
}

public class Test {
   public static void main(String[] args){
      int x = 10;
 
      do{
         System.out.print("value of x : " + x );
         x++;
         System.out.print("\n");
      }while( x < 20 );
   }
}

value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19

三、for迴圈

for迴圈執行的次數是在執行前就確定的

for(初始化; 布林表示式; 更新) {
    //程式碼語句
}
  • 最先執行初始化步驟。可以宣告一種型別，但可初始化一個或多個迴圈控制變數，也可以是空語句
  • 然後，檢測布林表示式的值。如果為true，迴圈體被執行。如果為false，迴圈終止，開始執行迴圈體後面的語句
  • 執行一次迴圈後，更新迴圈控制變數
  • 再次檢測布林表示式。迴圈執行上面的過程

四、Java增強for迴圈

主要用於陣列

for(宣告語句 : 表示式)
{
   //程式碼句子
}
  • 宣告語句：宣告新的區域性變數，該變數的型別必須和陣列元素的型別匹配。其作用域限定在迴圈語句塊，其值與此時陣列元素的值相等
  • 表示式：表示式是要訪問的陣列名，或者是返回值為陣列的方法
public class Test {
   public static void main(String[] args){
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ){
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names ={"James", "Larry", "Tom", "Lacy"};
      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

10,20,30,40,50,
James,Larry,Tom,Lacy,

五、break關鍵字

主要用在迴圈語句或者 switch 語句中，用來跳出整個語句塊。break跳出最裡層的迴圈，並且繼續執行該迴圈下面的語句。

六、continue關鍵字

continue適用於任何迴圈控制結構中。作用是讓程式立刻跳轉到下一次迴圈的迭代。

  • 在for迴圈中，continue語句使程式立即跳轉到更新語句。
  • 在while或者do…while迴圈中，程式立即跳轉到布林表示式的判斷語句。
public class Test {
   public static void main(String[] args) {
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ) {
         if( x == 30 ) {
        continue;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}

10
20
40
50

相關文章