JAVA學習之路--基礎篇二

目錄

• Java第一個程式：HelloWorld！
• • 将Helloworld.java程式通過Javac工具進行編譯所遇到的問題以及解決辦法
  • • 将HelloWorld程式編譯運作【兩種方法】
• public class和class的差別
• 語言基礎
• • 辨別符
  • 關鍵字
  • 字面值
  • 變量
  • 資料類型
  • • 資料類型詳解
    • • 字元型char
      • 轉義字元
      • 整數型
      • 浮點型
      • 布爾型
  • 運算符
  • • 算數運算符
    • 關系運算符
    • 邏輯運算符
    • 指派類運算符
    • 字元串連接配接運算符
    • 三目運算符

前言

生活或許是一往無前的勇氣

或許是前進路途的阻礙

但黑暗

在灼燒

在撕裂

灑下的灰燼

終将會飄向那

光明的未來

Java第一個程式：HelloWorld！

建立以HelloWorld.java檔案，預設打開編譯器【這裡小白使用的編譯器是Editplus，有很多編譯器，選擇一個适合自己的】

程式如下：

public class HelloWorld
{
 public static void main(String[] args){
  System.out.println("Hello World!);
 }
}
           

将Helloworld.java程式通過Javac工具進行編譯所遇到的問題以及解決辦法

接下來将Helloworld.java程式通過Javac工具進行編譯：

-我們打開DOS視窗，輸入javac，然後回車，出現以下指令：

’javac’ 不是内部或外部指令，也不是可運作的程式或批處理檔案

這是什麼問題呢？

出現以上問題是因為windows作業系統無法找到javac檔案

該如何解決？

兩種方法：【個人推薦第二種】

😃 1，找到你安裝JDK的硬碟，在該硬碟下找到Program Fies檔案，點開，在該檔案下面找到Java檔案， 點開，找到你安裝的JDK檔案，打開該檔案下面的bin檔案，你就會在該檔案下面找到javac.exe指令；然後複制整體路徑

重新打開DOS指令視窗，輸入 ：cd 剛才的路徑

例如：cd C:\Program Files\Java\jdk-14.0.2\bin

此時再輸入javac，指令成功運作!

注意：當你退出DOS視窗再次打開時，直接輸入javac還是出現以上問題，還得再重新輸入： cd javac.exe所在的路徑；個人覺得太麻煩；并且容易出錯。

😃 2，我們在學習計算機網絡的時候，都知道ipconfig這個指令【可以檢視ip位址】，當我們打開 cmd視窗輸ipconfig，直接我們可以看到我們的ip位址相關資訊。

那麼，如何使javac和ipconfig指令一樣，在視窗輸入javac，直接成功呢？

這就需要更改環境變量path

在講述第二種方法前，我們首先了解windows作業系統是如何找尋硬碟上的某個指令的呢？

首先從目前目錄下搜尋

在目前目錄搜尋不到的話，會從環境變量path指定的路徑當中搜尋

如果都搜尋不到則會報錯：XXX不是内部或外部指令，也不是可運作的程式或批處理檔案

是以，如果要達到在cmd視窗直接輸入javac，顯示成功那麼我們就得配環境變量。

具體操作：

打開檢視進階系統設定–>打開計算機屬性下的進階選項–>打開環境變量–>選擇下面系統變量path變量一欄–>點選建立，将javac.exe指令所在的路徑複制過去–>點選應用，就可以了（Windows10）

wondows7配置形式：path=xxx；C:\Program Files\Java\jdk-14.0.2\bin【這裡是我的電腦上javac.exe指令所在位置的路徑，你的電腦路徑你得自己找到】

這時我們再打開DOS指令視窗；直接輸入javac指令，顯示成功。

并且值得一提的是，當關閉DOS視窗再次打開輸入javac指令也不會出以上問題。【個人建議第二種，一勞永逸】

将HelloWorld程式編譯運作【兩種方法】

剛才建立立了一個程式：HelloWorld.java

現在進行編譯階段

有兩種方法：

😃 1,

打開你 HelloWorld.java源程式所在位置

打開DOS指令視窗

輸入指令 javac 源程式所在路徑【絕對路徑】（直接滑鼠左鍵拖拉到DOS指令視窗那裡）

點選回車

發現在案例目錄下生成了一個HelloWorld.class檔案，則編譯成功

😃 2，

打開你 HelloWorld.java源程式所在位置

在視窗路徑位置打開cmd指令視窗

輸入指令 javac HelloWorld.java【相對路徑】

點選回車

發現在案例目錄下生成了一個HelloWorld.class檔案，則編譯成功

運作階段：

要注意，必須在你所建立的程式目錄下運作結果！

輸入指令：java 類名

對于第一種方法而言，必須要先切換到.class檔案目錄下才可以運作！

錯誤圖示：

第二種方法因為

你在class檔案目錄下打開ODS指令視窗，是以直接輸入：java HelloWorld可以運作成功！

【個人建議使用第二種方法好一點；避免多出錯誤】

注意：windows7可能不能在路徑視窗那裡直接輸入cmd；這個時候用第一種方法。

public class和class的差別

一個Java源檔案當中可以定義多個class檔案

一個Java源檔案當中不一定有piblic的class

一個class會定義生成一個.class檔案

一個Java源程式當中定義一個公開的類【public class】，類名稱必須同源檔案的名稱一緻否則會報錯

每一個class都可以編寫mian方法，都可以設定程式的入口

注意：要求class中必須有主方法，不然會出錯

錯誤: 在類 b 中找不到 main 方法, 請将 main 方法定義為:

public static void main(String[] args) 否則 JavaFX 應用程式類必須擴充javafx.application.Application

語言基礎

辨別符

-通俗的來說，在Java源程式當中自己有權限命名的單詞/詞語叫做辨別符

-辨別符是用來給類、對象、方法、變量、接口、和自定義資料類型命名的

-命名規則：

1，辨別符隻能由字母、數字、下劃線"_"、美元符号"$"或者人民币"￥"組成，不能含有其他符号。

2，辨別符開頭不能是數字

3，關鍵字和保留字不能作為辨別符

4，辨別符沒有長度限制，大小寫敏感

-命名規範：

1.類和接口名。每個字的首字母大寫，含有大小寫。例如，MyClass，HelloWorld，Time等。

2.方法名。首字元小寫，其餘的首字母大寫，含大小寫。盡量少用下劃線。

例如，myName，setTime等。這種命名方法叫做駝峰式命名。

3.常量名。基本資料類型的常量名使用全部大寫字母，字與字之間用下劃線分隔。對象常量可大小混寫。

例如，SIZE_NAME。

4.變量名。可大小寫混寫，首字元小寫，字間分隔符用字的首字母大寫。不用下劃線，少用美元符号。給變量命名名是盡量做到見名知義。

關鍵字

Java具體關鍵字如下表：

關鍵字詳細解釋點選此處

字面值

/*
   * 10、100【整數型字面值】
   * 'a'【字元型字面值】
   * "ac"【字元串型字面值】
   * true;false【布爾型字面值】
   * 3.14【浮點型字面值】
   * null【空】
   * 通俗的來說就是資料。
*/

public class Constantdemo{
    public static void main(String[] args){
    System.out.println("abc");   //字元串型字面值
    System.out.println('a');    //字元型字面值
    //System.out.println('ab');    //這裡特别注意；''必須存放單個字元；多個是字元串
    System.out.println(true);    //布爾型字面值
    System.out.println(false);    //布爾型字面值
    System.out.println(3.14);    //浮點型字面值
    System.out.println('');    //帶表空格字元
    }
}
           

變量

😃 什麼是變量？

變量從本質上來講是記憶體的一塊空間。包括資料類型、字面值、名稱。 是記憶體中存儲資料最基本的單元

-變量存儲的資料必須和資料類型一緻

-聲明/定義變量：資料類型 變量名;

例如：int i; int age; int num

-變量指派：變量名 = 字面值;【字面值的資料類型必須和變量名的資料類型一緻】

-通路一個變量通常有兩種通路方式：

1，讀取變量中儲存的具體資料

2，修改變量中儲存的具體資料

-變量在一行上可以聲明多個； 例如：int a,b,c;

-變量必須先聲明，指派，才能通路；

/*
   舉一個簡單的例子
   計算1-100的和
   簡單了解定義變量，給變量指派，輸出變量
*/
public class a{
    public static void main(String[] args){
    int i,sum=0;  //定義變量i，sum；給sum指派；
  for (i=0;i<=100 ;i++ )  //for循環，實作i從1到100；
  { sum+=i;              //i從1到100實作自加，然後指派給sum；
  }                     //這裡用的for循環，不了解後面會将講述
  System.out.println(sum);    //輸出列印 sum
 
}
}
           

輸出結果：

-變量可以重新指派

-在同一個“作用域”當中；變量名不能重名，但變量值可以重新指派；

-作用域：指的是變量作用的有效範圍，出了作用域，該變量無法通路；

public class Ver{
   public static void main(String[] args){//被main方法包括的整體為一個共同作用域
    int i;    //定義變量i
    i=100;    //将變量指派為100
    System.out.println(i);   //輸出列印變量
    i=200;  //重新将變量值指派，在同一個main方法作用域當中
    System.out.println(i); //輸出列印重新指派過後的變量
   //int i=-1;不能再重新定義i，因為在同一個變量名當中，變量名不能重複
   //System.out.println(i);
   }
   }
           

變量的類型：

根據變量的聲明位置可将變量分為：

1，局部變量：

-在方法體當中聲明的變量叫局部變量；

2，成員變量：

-在方法體外【類體之内】聲明的變量叫成員變量；

public class Ver{
 int k=100; //類體中不能直接編寫Java程式，除聲明變量之外
 public static void main(String[] args){
 int i=1;  //局部變量，作用域為main方法
 System.out.println(i); //輸出結果遵循就近原則；
}

int i=200; //成員變量，在類a當中，方法體之外，且作用域不同，變量名可以一樣并可以重新定義

public static void other(){
int i=300; //局部變量，作用域為other方法
System.out.println(i);
}
}
           

-注意：成員變量沒有手動指派系統會自動指派為0

public class Ver
{ 
   static int f;   //成員變量，沒指派，系統預設為0；
 public static void main(String[] args){
  int i=100;  //對變量i指派
  System.out.println(i);  //輸出列印變量i
  System.out.println(f);  //輸出列印變量f
 }
}
           

結果如下：

資料類型

1，資料類型作用

程式當中每一個資料都有其相關類型，不同的資料類型占用的記憶體空間大小不同

資料類型的作用是指導JVM在運作資料的時候給該資料配置設定多大的空間

2，Java資料類型包括：

基本資料類型

引用資料類型

基本資料類型包括：四大類八小種

整數型：byte;short;int;long

浮點型: float;double

布爾型: boolean

字元型: char

注意：字元串"ab"不屬于基本資料類型，屬于引用資料類型；

字元屬于基本資料類型

字元串用" "【雙引号】

字元用 ’ '【單引号】

這裡我們需要知道的是：一位元組=8比特位【二進制位】相應的基本資料類型的二進制位為位元組數乘以8；

而基本資料類型的取值範圍是轉化為相應的二進制位，再計算對應的具體數值來表達的，對于Java中的資料的表示範圍，我們不需要記憶，因為它們的值以常量的形式定義在對應的包裝類中了

在Java中

二進制位數表示文法：資料類型.SIZE;

最大取值範圍：資料類型.MAX_VALUE

最小取值範圍：資料類型.MIN_VALUE

包裝類：java.lang.資料類型包裝表示；

包裝類具體如下：

基本資料類型	包裝類型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

基本資料類型具體如下：

public class HollowWorld {
 public static void main(String[] args) {
//  byte
  System.out.println("基本類型:byte二進制位數："+Byte.SIZE);
  System.out.println("包裝類:java.lang.Byte");
  System.out.println("最小值:"+Byte.MIN_VALUE);
  System.out.println("最大值:"+Byte.MAX_VALUE);
  
//  short
  System.out.println("基本類型:short二進制位數："+Short.SIZE);
  System.out.println("包裝類:java.lang.Short");
  System.out.println("最小值:"+Short.MIN_VALUE);
  System.out.println("最大值:"+Short.MAX_VALUE);
  
//  int
  System.out.println("基本類型:int二進制位數："+Integer.SIZE);
  System.out.println("包裝類:java.lang.Integer");
  System.out.println("最小值:"+Integer.MIN_VALUE);
  System.out.println("最大值:"+Integer.MAX_VALUE);
  
  
//  long
  System.out.println("基本類型:long二進制位數："+Long.SIZE);
  System.out.println("包裝類:java.lang.Long");
  System.out.println("最小值:"+Long.MIN_VALUE);
  System.out.println("最大值:"+Long.MAX_VALUE);
  
  
//  float
  System.out.println("基本類型:float二進制位數："+Float.SIZE);
  System.out.println("包裝類:java.lang.Float");
  System.out.println("最小值:"+Float.MIN_VALUE);
  System.out.println("最大值:"+Float.MAX_VALUE);
  
//  double
  System.out.println("基本類型:double二進制位數："+Double.SIZE);
  System.out.println("包裝類:java.lang.Double");
  System.out.println("最小值:"+Double.MIN_VALUE);
  System.out.println("最大值:"+Double.MAX_VALUE);
  
  
  
//  char
  System.out.println("基本類型:char二進制位數："+Character.SIZE);
  System.out.println("包裝類:java.lang.Character");
  //以數值形式而不是字元形式将Character輸出到控制台
  
  }
}
           

具體圖示如下：

資料類型詳解

字元型char

資料類型	位元組
char	2

public class DataType01
{ 
 public static void main(String[] args){
 char a='c'; //定義一個字元變量a，同時指派字元'c'
  System.out.println(a);//輸出列印字元變量a
  char b='你';//一個中文占用兩個位元組，char為2個位元組，可以存儲一個中文字元
  System.out.println(b);//輸出列印字元變量b
  /*
  char c="ad"; //char類型用單引号，雙引号為字元串類型，"ad"為字元串類型，c為字元類型，編譯報錯
  System.out.println(c);
  //錯誤提示為：錯誤: 不相容的類型: String無法轉換為char
  char c="ad";
  */
   }
}
           

輸出結果：

轉義字元

char中的轉義字元：\

轉義字元出現在特殊字元之前會将其轉換成普通字元

‘\n’: 換行符

‘\t’：制表符

‘\\’: 表示在控制台上輸出 \

‘\’’: 表示在控制台上輸出單引号’

‘"’: 表示在控制台上輸出雙引号"

‘\"’ :表示普通的雙引号：例如：“你好”

public class DataType02
{
 public static void main(String [] args){
 //n為一個普通字元
  char a='n';
  System.out.println(a); //輸出列印字元變量a
  char b='\n';   //  '\n'這裡我們來說為一個字元，并不是兩個字元，這裡叫做換行符，'\'這裡表示轉義的功能

  /*
  System.out.println()和System.out.print()的差別:
  println表示輸出之後換行；print表示輸出不換行；
  也就表明這裡的'ln'跟'\n'表示同是換行的意思
  */

  System.out.print('M');//輸出字元M,不換行
  System.out.println('N');//輸出字元N，接下來換行
  
  System.out.print('A');//輸出列印字元A，不換行
  System.out.print(b);//輸出列印字元b，這裡表示換行符
  System.out.println('B');//輸出列印字元B，接下來換行
  
  System.out.print('C');//輸出列印字元變量C，不換行
  System.out.println('D');//輸出列印字元D，接下來換行

  System.out.println('E');//輸出列印字元E,換行
  System.out.println('F');//輸出列印字元F，換行

  //普通字元t
  char q='t';
  System.out.println(q);//輸出列印字元變量q，換行

  //制表符Tab（鍵盤上Tab鍵）；制表符和空格不同，看起來效果一樣，但他們的ASCII值不同
  char w='\t';//定義字元變量w，指派為：'\t';這裡'\t'表示為制表符
  System.out.print('H');//輸出字元H,不換行
  System.out.print(w);//輸出字元變量w
  System.out.println('J');//輸出字元J

/* 
  輸出'\'在控制台上
  char x='\';這裡的\表示轉義的意思，它會把後面的單引号轉義成一個字元，此時這裡的單引号就沒有了本來的意思
  System.out.prointln(x);
  
  運作出錯： 錯誤: 未結束的字元文字
                char x='\';
  */
  //在控制台上輸出'\'字元
  char x='\\';//'\\'這裡表示，第一個'\'具有轉義功能，将後面的'\'轉義為普通字元'\'
  System.out.println(x);

  //在控制台上輸出單引号字元,同理，加轉義字元
  char v='\'';//  \具有轉義功能将第二個單引号轉換成普通字元，第一個單引号與第三個單引号配對
  System.out.println(v);

  char z='"';//定義字元變量z，指派
  System.out.println(z);
  
  System.out.println("\"你好\"");
       
  }
}
           

輸出結果：

整數型

Java中的整數型包括：

資料類型	位元組
byte	1
short	2
int	4
long	8

java語言當中的整數型字面值被預設當作int類型來處理

如果要使該整數型字面值被當作long類型來處理，需要在該整數型字面值後面加上l/L

java語言當中的整數型字面值有3種表示方式：

八進制【是一種預設的預設方式】

十進制【需要以0開始】

十六進制【需要以0x開始】

Java語言中預設小容量可以直接轉化為大容量的資料類型，這種自動轉化方式我們稱之為：自動轉化機制

而小容量轉化為大容量的資料類型，則在前面需要加強制轉換符

也可以通俗的來說，當一個數沒有超過前面的取值類型的取值範圍，可以直接指派給該取值類型變量。

詳細情況如下列程式：

public class DataType03
{
 public static void main(String[] args){
  int a=10; //定義整數型變量a，指派十進制數字10
  int b=010;//定義整數型變量b，指派八進制，逢8進一，該數字為8
  int c=0x10;//定義整數型變量c，指派16進制，逢16進一，該數字為16
  System.out.println(a);//輸出列印整數型變量a【10】
  System.out.println(b);//輸出列印整數型變量b【8】
  System.out.println(c);//輸出列印整數型變量c【16】
  
  long x=12; //12為整數型字面值，在沒有任何處理的情況下Java會預設為int類型；
  //java語言當中的【整數型字面值】被預設當作【int類型】來處理
  //因為int類型占用4位元組，long類型占用8位元組，是以自動轉換類型
  System.out.println(x);//小容量直接轉換成大容量的這種轉換方式被成為：自動轉換機制【大容量不能直接轉換成小容量，需要強制類型轉換，byte除外】
 /*
     小容量轉換成大容量需要加【強制類型轉換符】，編譯通過，運作可能損失精度
     這裡編譯錯誤:
        long m=100L;
        int n=m;
 */
//編譯成功如下：
  long m=100L;
  int n=(int)m;//加(int)；強制将long類型轉換成int類型，以此類推
  System.out.println(n);
  
 /*
 轉換原理：例如：long類型【8位元組64二進制位】數字100二進制：
 00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
  轉換成int類型【4位元組32二進制位】：
 00000000 00000000 00000000 01100100
 所有類型的轉換都是把前面的二進制位去掉
 */
 
/*
 超過範圍：
    long y=2147483648;//會報錯，因為等号右邊開始在沒有任何處理的情況下Java會預設為int類型
    System.out.println(y);//而該範圍超出int類型取值範圍，故編譯錯誤；
    錯誤提示：
    錯誤: 整數太大
       long y=2147483648;
*/

 //當數值出int類型取值範圍的時候，要想不出現錯誤，則開始就聲明為容量比int類型大的long類型
 long z=2147483648L;//右邊數字超出int類型取值範圍，直接編譯會出錯，要想編譯成功，那麼需要轉換類型，容量大于int類型
 System.out.println(z);//輸出列印long類型變量z


//注意：但對于byte類型，字面值沒有超出其取值範圍的，不用加強制轉換符，可以直接編譯成功

byte h=3;//byte類型【-128~127】
System.out.println(h);

 }
}

/*綜上我們也就是說，
當一個數沒有超過前面的取值類型的取值範圍，
可以直接指派給該取值類型變量
byte,short,int,long,char等
*/
           

輸出結果：

浮點型

資料類型	位元組
float	4
double	8

/*
浮點型：
float【4位元組】
double【8位元組，精度較高】
在Java語言中，所有浮點型字面值【例如5.6】都被預設當作double類型來處理
轉化為float類型需要在後面添加F/f
*/
public class DataType04
{
 public static void main(String[] args){
  double i=3.0;
  System.out.println(i);
  /*
  float m=4.8;//4.8為double類型，m為float類型
  小容量轉化為大容量需要添加強制轉換符
  或者在後面加f/F
  否則編譯錯誤：
  錯誤: 不相容的類型: 從double轉換到float可能會有損失
                float m=4.8;
   */
  float n=(float)4.8;//強制類型轉換
  System.out.println(n);
  
  float f=5.2f;//直接轉化為float類型
  System.out.println(f);
  
   }
}



           

布爾型

資料類型	位元組
boolean	1

/*
布爾型：
boolean
1為true（真），0為false（假）
經常使用在邏輯控制語句當中
*/
public class DataType05
{
 public static void main(String[] args){
 boolean b1=true;
  if(b1){
   System.out.println("登入成功!");//b1為真，輸出該語句
  }else{
   System.out.println("對不起，使用者名或密碼錯誤!");
   }
    
 }
}
           

輸出結果：登入成功！

public class DataType05
{
 public static void main(String[] args){
 boolean b1=false;
  if(b1){
   System.out.println("登入成功!");
  }else{
   System.out.println("對不起，使用者名或密碼錯誤!");//b1為假，輸出該語句
  }
  
  }
}

           

輸出結果：對不起，使用者名或密碼錯誤!

運算符

算數運算符

/*
算數運算符：
+： 加法
-： 減法
*： 乘法
/： 出發/商
%： 取餘/求模
--：自減1
++：自加1

一個表達式有多個運算符；運算符有優先級之分，
不确定的可以加小括号，優先級得到提高
*/
public class OperatorText01
{
 public static void main (String[] args){

//求兩數相加
  int a=3;
  int b=4;
  int m=a+b;
  System.out.println("兩數相加結果為:" +m);

//求兩數相減
  float x=3.2F;
  int y=3;
  float z=x-(float)y;
  System.out.println("兩數相減結果為：" +z);

//求長方形的面積：長=2.5；寬=5.4；
  float lengh=2.5f;
  float wide=5.4f;
  float area=lengh*wide;
  System.out.println("長方形面積為：" +area);

//求兩數相除
  int d=10;
  int f=3;
  float g=(float)d/3;
  System.out.println("兩數相除結果為：" +g);

//++ --出現在變量後
  int h=3;
  int j=h--;//先做指派運算，再自加1；
  //也就是說h的值先指派給了j，再h自加1，那麼j的值就是h沒自加1的值
  int e=6;
  int r=e++;
  System.out.println("h--結果為：" +j);
  System.out.println("e++結果為：" +r);

//++ --出現在變量前
  int q=4;
  int w=--q;
  int t=8;
  int u=++t;//先自加1，再指派；
  //也就是說t的值先自加1，然後指派給了u；
  System.out.println("--q結果為：" +w);
  System.out.println("++t結果為：" +t);

//取餘/取模
  int i=20;
  int o=7;
  int p=i%o;
  System.out.println("取餘/求模的結果為：" +p);

//混合運算
  //求台型的面積：上底：4.8，下底：8.6，高：4
  int high=4;
  float low=8.6f;
  float upper=4.8f;
  float area2=(float)(low+upper)*high/2;
  System.out.println("台型的面積為：" +area2);

 }
}
           

運算結果為：

關系運算符

/*
關系運算符：
>      大于
>=     大于等于
<      小于
<=     小于等于
==     等于
!=     不等于

運算結果一定為布爾類型：true/false
*/
public class OperatorText02
{
 public static void main(String[] args){
  int a=6;
  int b=10;
  System.out.println(a>b);//false
  System.out.println(a>=b);//false
  System.out.println(a<b);//true
  System.out.println(a<=b);//true
  System.out.println(a==b);//false
  System.out.println(a!=b);//true 
 }
}
           

運算結果為：

邏輯運算符

/*
邏輯運算符：要求兩邊的算子都是布爾類型【true/false】,其結果也是布爾類型
&    與【兩邊算子都為真才真】
|    或【兩邊算子隻要有一邊為真就真】
！   非【取反，例如：！true為非真，就是假的意思】
^    異或【兩邊的算子真假隻要不一樣，結果就為真，其餘為假】

&&   短路與：跟與的判斷條件一樣，不同的是判斷條件的執行情況不同
||   短路或：跟或的判斷條件一樣，不同的是判斷條件的執行情況不同
*/

public class OperatorText03
{
 public static void main(String[] args){
 
  System.out.println(8>9 & 2>1);//兩邊真才為真，結果為false
  System.out.println(2>9 | 2>1);//一邊真就為真，結果為true
  System.out.println(!true);//取反，結果為false
  System.out.println(8>9 ^ 1>2);//兩邊算子真假一樣，都為假，其結果為false
  System.out.println(8>9 ^ 3>2);//兩邊算子真假不相同，左邊為假，右邊為真，其結果為真

//邏輯與和短路與的差別：
  int a=11;
  int b=3;
  System.out.println(a<b&b>a++);//邏輯與，判斷兩邊的條件是否都成立之後，
  //再整體判斷是否為真或者假，沒有短路現象
  System.out.println(a);//上面條件判斷為假，再執行a++，輸出a
  
  System.out.println(a<b&&b++>a);//a<b為假，則整個條件判斷為假，
  //後面的算子【b++>a】不在執行，相當于短路，稱之為：短路與
  System.out.println(b);//上面第一條件【左邊條件】判斷為假，不執行第二條件【b++>a】,輸出原來的b的值
  
//邏輯或和短路或的差別：
  int x=8;
  int y=10;
  System.out.println(x<y|x>y++);//判斷兩邊條件，有一真【x<y】，全為真，再執行y++
  System.out.println(y);//輸出y++  11
  System.out.println(x<y||y>x++);//判斷第一條件【左邊：x<y】為真，有一真則為真，發生短路或
  System.out.println(x);//根據上面第一個結果為真【發生短路或】，右邊條件【x++】不執行，輸出x值 8
  
   }
}

/**
  *短路與：
  *第一表達式執行結果為假，可以判斷全為假，發生短路與
  *短路或：
  *第一表達式執行結果為真，可以判斷全為真，發生短路或
*/
           

運算結果為：

指派類運算符

/*
 指派類運算符
 基本指派類運算符：=
 
 擴充指派類運算符：
 += 【加等】
 -= 【減等】
 *= 【乘等】
 /= 【除等】
 %= 【取餘等】
 
 共同特點：都是将等号右邊的表達式運算結果指派給左邊
*/
public class OperatorText04
{
 public static void main(String[] args){
 
 //基本運算符 =
 
  int a=3;//将3指派給a
  int b=5;//将5指派給b
  int x=6;//将6指派給x
  int y=9;//将9指派給y
  int c=a+b;//将等号右邊表達式【a+b】運算結果指派給c，此時c的值為8；
  System.out.println(c);
   b+=a;//相當于b=b【5】+a【3】；将【5+3】結果重新指派給b，此時b的值為8；
   System.out.println(b);
   a-=1;//相當于a=a【3】-1；将【3-1】結果重新指派給a，此時a的值為2；
  System.out.println(a);
   c*=2;//相當于c=c【8】*2；将【8*2】結果重新指派給c，此時c的值為16；
  System.out.println(c);
   x%=5;//相當于x=x【6】%5；将【6%5】結果重新指派給x，此時x的值為1；
  System.out.println(x);
   y/=7;//相當于y=y【9】/7；将【9/7】結果重新指派給y，上面定義y為int類型，此時y的值為1；
   System.out.println(y); 
   }
}
           

運算結果為：

字元串連接配接運算符

/*
字元串連接配接運算符：+
1,數字+數字：加法求和
2,數字+字元串/字元串+字元串：字元串連接配接運算
*/

/*
要求：在控制台輸出動态的顯示資訊：
例如： 
 1. int a=1;
    int b=2;
   控制台輸出：
      1+2=3
   當a，b，變量改變的時候，控制台輸出改變後的動态資訊
   
 2.   當登入界面資訊時候，輸出不同名字情況下不同的顯示資訊
 
 */
 public class OperatorText05
{
 public static void main(String[] args){
//1
  int a=1;
  int b=2;
  System.out.println(a+"+"+b+"=" +(a+b));
  /*
  a+的意思為：變量a連接配接後面的表達式
  "+"的意思為：輸出字元串+号；可以看出，第一個+号表示連接配接字元串的意思
  +b的意思為：連接配接變量b
  +"="的意思為：連接配接字元串=号
  +(a+b)的意思為：連接配接變量(a+b)運算結果的值
  
  輸出結果：1+2=3
  */
  a=3;
  b=45;
  System.out.println(a+"+"+b+"=" +(a+b));
  //輸出結果：3+45=48

 //2
  String username="小明";
  System.out.println("歡迎使用者 "+username+" 登入成功！");
  /*
  String的意思為字元串類型，
  定義字元串變量username
  "歡迎使用者":表示輸出字元串：歡迎使用者
  +username：連接配接字元串變量username
  +"登入成功！"：表示連接配接字元串：登入成功！
  
  輸出結果：歡迎使用者 小明 登入成功！
  */
  username="小雨";
  System.out.println("歡迎使用者 "+username+" 登入成功！");
  //輸出結果：歡迎使用者 小雨 登入成功！
   }
}
 
           

輸出結果為：

三目運算符

/*
三目運算符：
文法規則：

布爾表達式 ？表達式1：表達式2

布爾表達式執行結果為真，輸出表達式1的執行結果，為假，輸出表達式2的執行結果

*/

public class OperatorText06
{
 public static void main(String[] args){
  int a=4;
  int b=5;
  System.out.println(a>b?a:b);//判斷a>b的值，為假的，執行b，并輸出
  System.out.println(a<b?a:b);//判斷a<b的值，為真的，執行a，并輸出
 }
}
           

運算結果為：

所有的回頭都是為了更好的再次踏步

轉身

再對自己說一句

你好廢物

往期：

Java學習之路–基礎篇一