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