零基礎學Java——小白的Java之路（2）

Java標識符

 

標識符用來表示變量、方法或類等的名字。

定義的規則如下：

• • 只能包含字母、數字、下划線和美元符號$。
  • 不能以數字開頭
  • 嚴格區分大小寫，如 a 和 A 是不同的標識符
  • 沒有長度限制

 

注意：標識符的命名應該有自明性（見名知意），看到名字就可以知道這個標識符表示的內容。

 

下面是一些合法的標識符（名稱）：

 myName，My_name，Points，$points,_sys_ta，OK，_23b，_3_

以下是一些非法的標識符：

2thupk，high-dig，Not/ok，#name

 

使用標識符進行命名的時候，我們會遵循下面的定義風格：

• • 變量名：第一個單詞的字母小寫，后面每個單詞的首字母大寫。如person，personName。
  • 方法名：第一個單詞首字母小寫，后面每個單詞的首字母大寫。如eat()，showName()。
  • 類名：以大寫字母開頭。如Home，Hello。
  • 常量：全部大寫。如PI，NUMBER。

 

注意：定義風格與語法沒有關系，但是一個優秀的程序員都會按照這個要求規范自己的代碼。

 

關鍵字和保留字

 

正確識別Java語言的關鍵字（keyword）和保留字（reserved word）是十分重要的。

Java的關鍵字對Java的編譯器有特殊的意義，他們用來表示一種數據類型，或者表示程序的結構等。

保留字是java預留的關鍵字，他們雖然現在沒有作為關鍵字，但在以后的升級版本中有可能作為關鍵字。

所以我們在等一標識符的時候，不能與它們沖突，否則代碼不能正常執行。

目前的保留字：const，goto

關鍵字如下：

abstract	break	byte	boolean	catch
case	char	class	continue	default
do	double	else	extends	false
final	while	for	finally	if
import	implements	int	interface	instanceor
long	float	native	new	null
package	private	protected	public	return
switch	synchronized	short	static	super
try	true	this	throw	throws
threadsafe	transient	void	volatile	strictfp

 

 

 

 

 

 

 

 

分隔符

 

空格、圓括號、花括號、分號等。

每條語句無論一行還是多行都以分號結束。

代碼塊（Block）是包含在{}里面的多條語句，塊可以嵌套。

 空白由一個或多個空格組成，也可以由一個或多個tab空格組成。

分隔符	名稱	功能說明
{}	大括號（花括號）	用來定義程序塊、類、方法以及局部范圍，也用來包括自動初始化的數組的值。
[]	中括號	用來進行數組的聲明，也用來表示撤銷對數組值的引用。
()	小括號（圓括號）	在定義和強調方法時用來容納參數表。在控制語句或強制類型轉換組成的表達式中用來表示執行或計算的優先權。
;	分號	用來表示一條語句的結束。
,	逗號	在變量聲明中，用於分隔變量表中的哥哥變量。分隔函數中的參數。
.	點	用來將軟件包的名字與它的子包或類分隔。也用來將引用變量與變量或方法分隔。

 

 

 

 

 

 

 

 

 

注釋

Java支持單行及多行注釋，注釋中的內容會被編譯器忽略。

單行注釋：以換行符結束。語法：

//......

　　

多行注釋：可同時注釋很多內容。語法：

/*......

......*/

　　

文檔注釋：可使用javadoc工具從源代碼和文檔注釋中將信息取出，轉換為HTML文件。語法：

/**
..........
..........
*/

 

　　

Java數據類型划分

　　

 

基本數據類型

類型名稱	長度（bit）	最大值	最小值	默認值	示例
byte	8	127　　　（2^7-1）	-128　　　 (-2^7)	0	byte a=10;
short	16	32767　　(2^15-1)	-32768　　(-2^15)	0	short b =10;
int	32	2^31-1	-2^31	0	int c =10;
long	64	2^63-1	-2^63	0L	long d =10L;
float	32			0.0f	float e =1.23f;
double	64			0.0d	double f=1.23;
char	16	\uffff	\u0000	\u0000	char g='a';
boolean	1	只有兩個取值：true，false		false	boolean h=true;

 

 

 

 

 

 

 

 

 

變量和常量

變量：用於標識數據的存儲單元，可用於數據存儲和運算。各種類型的變量創建后都有默認值。

變量的定義一般格式如下：

　　　　<數據類型><變量標識符>=<值>;

double x = 3.1415;

　　

變量賦值后可以修改，格式如下：

　　　　<變量標識符>=<值>;

x = 1.2345;

注意：在Java中，所有的變量在使用之前必須聲明。

 

常量有字面量和符號量兩種。

字面量表示基本數據類型的源代碼，如整型字面量：6

符號常量指用標識符表示的常量。

定義的一般格式如下：

<final><數據類型><符號常量標識符>=<常量值>;

例如：

final double PI = 3.1415926;

final int COUNT=1000;

　　

注意：常量一旦賦值不能修改。

 

實型數據

實型常量

用十進制數形式表示，由數字和小數點組成，例如：3.25。

用科學計數法形式表示，例如：123E-3。

數后加f或F為float，加d或D為double，沒有后綴修飾的則缺省為double類型。

 

實型變量

實型變量按長度分為：float和double。

雙精度浮點型double比單精度浮點型float的精度更高，表示的數據的范圍更大。

 

三個特殊浮點值

正無窮大：Double.POSITIVE_INFINITY

負無窮大：Double.NEGATIVE_INFINITY

非數字：Double.NaN

注意：Double.NaN=Double.NaN的值為true。

 

字符型數據

字符常量是單引號括起來的一個字符，如：'J'、'*'。

Java中有以反斜杠（\）開頭的字符，反斜杠將其后的字符轉變為另外的含義，稱為轉義字符。

轉義字符	名稱	Unicode值
\b	退格	\u0008
\t	制表	\u0009
\n	換行	\u000a
\r	回車	\u000d
\"	雙引號	\u0022
\'	單引號	\u0027
\\	反斜杠	\u005c

 

 

 

 

 

 

 

 

Java中的字符型數據是16位的Unicode字符，漢子和英文字母占的內存空間相同。

"Java你好"共12個字節。

字符變量的定義如下：

char ch=‘c’;

 

字符串常量數據

字符串常量是使用雙引號括起來的字符序列。

例如：

"Let's learn Java!";

String str = "Hello world";

　　

 

字符串變量作為對象來處理，通過String和StringBuffer類的構造方法來定義。

String s = new String();

 

布爾型數據

布爾型常量值只有：true和false。

布爾型變量為boolean類型，取值為true和false。例如：

boolean b =true;

 示例代碼

//java數據類型
public class DataType{
    public static void main(String args[]){
        //變量是用來存儲和操作數據的
        //數據類型 變量名稱=值
        //byte    大小8位
        byte a = 1;         //定義一個字節型（byte）變量並賦值為1
        a=2;                //變量值可以改變
        //a=200             //數值過大
        System.out.println("a="+a);  //輸出變量
        
        //short   大小16位
        short b =200;
        System.out.println("b="+b);
        
        //int      大小32位
        int c =21543;
        //c = 141343141341;     //數值過大
        System.out.println("c="+c);
        
        //long     大小63位  最大表示2^63-1
        long d = 12344444444L;
        //注意：整型字面量默認是int   表示長整型字面量要在最后加l或者L
        //d = 1431242342341242;
        System.out.println("d="+d);
        
        //float     32位
        //注意：小數的字面量默認是double，表示float字面量后加f或者F
        float e = 1.23f;
        System.out.println("e="+e);
        
        //double   64位
        double f = 3.14;
        System.out.println("f="+f);
        
        //char    16位（unicode）
        char aa='男';      //將字符放在單引號中只能1個字符
        aa = 10;
        aa = '\u0041';
        //轉義字符，用\改變字符的含義，例如\n表示換行，\'表示單引號等
        System.out.println("aa="+aa);
        
        //boolean      1位
        //布爾值只有true和false兩個取值
        boolean bb=false;
        System.out.println("bb="+bb);
        
        //常量 final
        //常量賦值后不可修改
        final double PI=3.1415926;
        //PI=3.14;
        System.out.println("PI="+PI);
        
    }
}

 

類型轉換

自動類型轉換：低優先級的數據自動會轉換為高優先級的數據

byte->short->char->int->long->float->double

強制類型轉換：優先級高的數據轉換成優先級低的數據。例如：

double d =3.14159d;

int a=(int)d;

　　

如果下列兩個條件都滿足，那么將一種類型的數據賦給另一種類型變量時，講執行自動類型轉換。

1. 1. 兩種類型兼容
   2. 目標數據類型的取值范圍比源數據類型的取值范圍大

當滿足以上兩個條件時，自動的“加寬轉換”就可以進行。

例如：將一個byte值賦給int類型的變量

byte a =10;
int x =a;

對於加寬轉換，數字類型，包括整數和浮點類型都是彼此兼容的，但是數字類型和字符類型或布爾類型是不兼容的。字符類型和布爾類型也是互相不兼容的。

當需要將int型的值賦給一個byte型的變量時該怎么辦？

此時，只有采用被稱為“變窄轉換”的轉換方式。因為你肯定要將源數據的值變小才能適合目標數據類型。

在這種情況下，就必須進行強制類型轉換。所謂的強制類型轉換是一種顯示的類型變換方式，其通用格式：(target-type) value

其中，目標類型(target-type)制定了要將指定值所轉換成的類型。

例如，下面的程序段將int型強行轉換成byte型。

int a;
byte  b;
b = (byte)a;

當把一個浮點值賦給整數類型時，將發生一種不同的類型轉換：截斷

即當把浮點值賦給整數類型時，它的小數部分將被舍去。

例如，如果將值1.23賦給一個整數，其結果只是1,0.23被舍棄。

當然，如果浮點值太大而不能適合目標整數類型，那么它的值將會因為目標類型值域取模而減少。

下面的這個程序說明了強制類型轉換過程。

public class Conversion {

	public static void main(String args[]){
	
		byte b;
		
		int i = 258;
		
		double d = 338.136;
		
		System.out.println(“\n將int類型數據轉換為byte");
		
		b = (byte) i;
		
		System.out.println("i and b: " + i + “, " + b);
		
		System.out.println(“\n將double類型數據轉換為int");
		i = (int) d;
		
		System.out.println("d and i :" + d + " ," + i);
		
		System.out.println(“\n將double類型數據轉換為byte");
		
		b = (byte) d;
		
		System.out.println("d and b: " + d + “, " + b);
	}
}

運行結果如下：

將int類型數據轉換為byte

i and b: 258, 2

將double類型數據轉換為int

d andi: 338.136 ,338

將double類型數據轉換為byte

d and b :338.136, 82

下面讓我們分析一下每個類型轉換。

當值258被強制轉換為byte變量時，取值它的低八位；

當把變量d轉換為int型，它的小數部分被舍棄了；

當把變量d轉換為byte型，它的小數部分被舍棄了，也是取它的低八位。

 示例代碼

//類型轉換
public class TypeConvert{
    public static void main(String args[]){
        //1.自動類型轉換
        //低優先級數據類型自動轉換成高精度的數據類型
        //byte->short->char->int->long->float->double
        
        byte b=1;
        short s=b;
        System.out.println("s="+s);
        
        double d=b;
        System.out.println("d="+d);
        
        //2.強制轉換
        //強制轉換可能會導致數據的丟失
        //格式  （目標數據類型）值
        float f=1.23F;
        int i =(int)f;               //小數轉整數會直接將小數點后的數字直接舍去，不進行四舍五入
        System.out.println("i="+i);
        
        int x=250;
        System.out.println("x="+x);
        byte y =(byte)x;              //取int的低8位存入byte，第8位是符號位
        System.out.println("y="+y);
    }
}

 

賦值運算符

包括：=，+=，-=，*=，/=，%=

int a=2;

a =a*b;

a*=b;

a%b=b;

a =a%b;

算術運算符

包括：+，-，*，/，%，++，--等

后綴++（--）：變量首先進行操作再自身進行加減。

int a=2;

int b =a++;

//a=3,b=2

前綴++（--）：變量首先加減后再進行操作。

int a=2;

int b=++a;

//a=3,b=3

關系運算符

包括：==，！=，<，<=，>，>=

完成操作數的比較運算，結果為布爾類型值。

int a=10;

int b=3;

boolean f=a>b;

//比較a和b的值，結果為true，即f的值為true

邏輯運算符

包括：&，|，!，^，&&，||

注意區別:＆既是位運算符也是邏輯運算符，＆＆只是邏輯運算符，＆與＆＆同時作為邏輯運算符時＆＆是短路的(截斷功能)，而＆並不短路。 

int a=6;

int b=8;

int c=10;

int d=12;
      
boolean x=++a>b++&&c++>d--;


//上面代碼的結果：
//a=7   b=9  c=10  d=12   x=flase

條件運算符

也稱作三目運算符

一般形式為：

<表達式1>?<表達式2>:<表達式3>;

表達式1的數據類型為布爾值類型，如果為true，取表達式2的值為最終結果，否則取表達式3的值。

int x=2 ;i

nt y=3;

int salary=(x ==y)?2000:200;

//上面代碼中因為x==y不成立，所以salary的最終值為200。

位運算符

• • 按位取反〜，〜01010101=10101010。 (1變0 0變1)
  • 按位與&，11111001&10001111=10001001。 (同為1時為1 )
  • 按位或|，11111001|10001111=11111111。 （只要有一個為1就為1）
  • 按位異或^，11111001^10001111=01110110。 （相同為0 不同為1）
  • 左移<<，10101011<<2=10101100。
  • 帶符號右移>>，10101011>>2=11101010。
  • 無符號右移>>>

 示例代碼

//運算符
public class Operator{
    public static void main(String args[]){
        //1.算數運算符：+ — * / % ++ --
        /*int a =1;
        int b =2;
        int c =a/b;           //兩個整數相除結果仍為整數
        System.out.println("c="+c);
        
        //++自增
        int i =1;
        //i++;          //后綴自增   
        //++i;          //前綴自增
        int i2=i++;      //先其他操作后自加
        System.out.println("i2="+i2+",i="+i);
        int i3=++i;      //先自加后其他操作
        System.out.println("i3="+i3+",i="+i);
        */
        
        //2.賦值運算符：= += -= *= /= %=
        /*int a =2;
        int b=3;
        a+=b;   //相當於a=a+b
        System.out.println("a="+a);
        */
        
        //3.關系運算符：== != > < >= <=
        //關系運算符結果是布爾類型
        /*int a =2;
        int b =3;
        boolean bl = a<b;
        System.out.println("bl="+bl);
        */
        
        //4.邏輯運算符
        //專門針對布爾類型數據進行運算
        //與 & && 兩個同時為true，結果才為true
        //或| ||  只要有一個為true，結果就為true
        //取反 !  
        //異或 ^   兩個相同結果為false，不同為true
        
        /*boolean b1 = true;
        boolean b2 = false;
        boolean b3 = b1^b2;
        System.out.println("b3="+b3);
        */
        
        //具有短路功能的與 && 或 || 在運算過程中已知結果便不再進行后面的運算
        
        /*int a=2,b=4,c=10,d=11;
        boolean c1 = ++a >= b-- && c-- ==--d;
        System.out.println("a="+a+",b="+b+",c="+c+",d="+d+",c1="+c1);
        */
        
        //5.條件運算符（三目運算符）
        /*
            條件?表達式1:表達式2
            注意表達式1和表達式2 類型相同
            如果條件為true 取表達式1的結果，否則取表達式2的結果
        */
        /*int a=2;
        int b=3;
        int c = a>b?a:b;
        System.out.println("c="+c);
        */
        
        //6.位運算符
        //按位與 &
        //按位或 |
        //按位取反 ~
        //異或 ^
        int a =2;   //0...0 0010
        int b =3;   //0...0 0011
        int c =a&b;    //0010
        System.out.println("c="+c);
        
        //位移
        //<<左移
        int d =2; //0...0 0010
        d =d<<2;
        System.out.println("d="+d);
        //右移>>
        int e =-2; //1...1 1110
        e =e>>2;   //111...1 1111  -1
        System.out.println("e="+e);
        //無符號右移>>>
        int f = -2;
        f = f>>>2;
        System.out.println("f="+f);
    }
}

 

表達式

由操作數和運算符按照一定的語法格式組成表達式。

(a+b)*(c--d)

 

變量的作用域

• • 所謂的作用域就是在變量在什么時候是可見在什么是不可見的！
  • 作用域決定變量“可見性”與“存在時間”
  • 作用域的范圍：只作用於從聲明開始到所在的{}結束。

 示例代碼

//變量的作用域指的是變量從定義開始到所在的花括號}結束
public class Scope{
    public static void main(String args[]){
        int x =10;
        {
            System.out.println("x="+x);
            double y =1.23;
        }
        //System.out.println(y);  //超出了y的作用域
    }
}

 

簡單的輸入輸出

輸出：

使用System.out對象進行輸出。

println()：輸出文本並換行

print()：輸出文本不換行

如：System.out.println(“hello world!”);

輸入：

1、使用Scanner對象輸入。

new Scanner(System.in)

import java.util.Scanner與next()或nextInt()方法

2、使用命令行參數main()方法的args[]。

 示例代碼

//簡單的輸入輸出
import java.util.Scanner;  //引入Scanner類
public class InOut{
    public static void main(String args[]){
        //輸入1：通過main方法的args參數
        /*String str =args[0];
        int a = Integer.parseInt(str);   //將字符串轉換成整數
        System.out.println("a*10="+a*10);
        */
        
        //輸入2：通過Scanner對象（掃描器）
        //使用new 創建Scanner對象
        Scanner scan = new Scanner(System.in);   //System.in表示從控制台讀取數據
        //調用功能next()，nextInt(),nextDouble(),nextLine()
        System.out.print("請輸入一個整數：");
        int i = scan.nextInt();
        System.out.println("你輸入的是:"+i);
        
        //輸入文本
        System.out.print("請輸入一句話：");
        Scanner myscan = new Scanner(System.in);
        String a =myscan.nextLine();
        System.out.println("你輸入的是："+a);
    }
}

 

練習

 

從屏幕上輸入兩個實數，計算他們的和，差，積，然后輸出

//從屏幕上輸入兩個實數，計算他們的和，差，積，然后輸出

import java.util.Scanner;
public class HWD1T1{
    public static void main(String args[]){
        /*
        Scanner a =new Scanner(System.in);
        System.out.print("請輸入第一個數字：");
        double x = a.nextDouble();
        
        Scanner b =new Scanner(System.in);
        System.out.print("請輸入第二個數字：");
        double y = b.nextDouble();
        */
        
        /*
        String str1 = args[0];
        String str2 = args[1];
        double x = Double.parseDouble(str1);
        double y = Double.parseDouble(str2);
        */
        
        double x =Double.valueOf(args[0]).doubleValue();
        double y =Double.valueOf(args[1]).doubleValue();
        
        double sum=x+y;
        double diff=x-y;
        double avg=x*y;
        
        System.out.println("它們的和是"+sum);
        System.out.println("它們的差是"+diff);
        System.out.println("它們的積是"+avg);
    }
}

 

用戶從屏幕上輸入圓的半徑，然后計算並輸出該圓的直徑、周長和面積。
注意：∏的值可以使用預定義常量Math.PI。該常量要比3.14159精確。

//用戶從屏幕上輸入圓的半徑，然后計算並輸出該圓的直徑、周長和面積。
//注意：∏的值可以使用預定義常量Math.PI。該常量要比3.14159精確。
import java.util.Scanner;
public class HWD1T2{
    public static void main(String args[]){
        Scanner scan = new Scanner(System.in);
        System.out.print("請輸入圓的半徑：");
        double r = scan.nextDouble();
        
        double d = r*2;
        double C = Math.PI*r*2;
        double S = Math.PI*r*r;
        
        System.out.println("該圓的直徑為"+d);
        System.out.println("該圓的周長為"+C);
        System.out.println("該圓的面積為"+S);
    }
}

 

編寫一個應用程序，讀取用戶輸入的一個整數，判斷該整數的奇偶性，並將結果顯示在控制台上。

//編寫一個應用程序，讀取用戶輸入的一個整數，判斷該整數的奇偶性，並將結果顯示在控制台上。
//提示：使用求模和三目運算符。
import java.util.Scanner;
public class HWD1T3{
    public static void main(String args[]){
        Scanner scan =new Scanner(System.in);
        System.out.print("請輸入一個整數：");
        int a = scan.nextInt();
        String b = a%2==0?"偶數":"奇數";
        System.out.println("該數字是："+b);
    }
}
　　

 

編寫一個程序，輸入一個5位數，將輸入數分離成單個數字，然后打印出這些數字，個數字間間隔3個*符號。

//編寫一個程序，輸入一個5位數，將輸入數分離成單個數字，然后打印出這些數字，個數字間間隔3個*符號。
//提示：使用整除除法和求模運算符。
//例如：如果用戶輸入：42933,那么輸出是：4***2***9***3***3

import java.util.Scanner;
public class HWD1T4{
    public static void main(String args[]){
        Scanner scan = new Scanner(System.in);
        System.out.print("請輸入一個5位數：");
        int a = scan.nextInt();
        
        int s5=a/10000;
        int s4=(a/1000)%10;
        int s3=(a/100)%10;
        int s2=(a/10)%10;
        int s1=a%10;
        
        System.out.println(s5+"***"+s4+"***"+s3+"***"+s2+"***"+s1);
    }
}
　　

 

編寫一個Java應用程序,用戶從鍵盤輸入一個浮點數據,將該浮點數保留兩位小數位后輸出。

//編寫一個Java應用程序,用戶從鍵盤輸入一個浮點數據,將該浮點數保留兩位小數位后輸出。
import java.util.Scanner;
public class HWD1T5{
    public static void main(String args[]){
        Scanner scan =new Scanner(System.in);
        System.out.print("請輸入一個小數：");
        double a = scan.nextDouble();
        
        //int b =(int)(a*100);
        //a=(double)b/100;
        //System.out.println(a);
        
        System.out.println(String.format("%.2f",a));
    }
}
　　

 

輸入一個數，如果能被3、4、5中的任意一個數整除，則輸出：　i+“能被3或者4或者5整除” （i是輸入的數字）。

//輸入一個數，如果能被3、4、5中的任意一個數整除，則輸出：　i+“能被3或者4或者5整除” （i是輸入的數字）。
//用||實現。
import java.util.Scanner;
public class HWD1E1{
    public static void main(String args[]){
        Scanner scan = new Scanner(System.in);
        System.out.print("請輸入一個整數：");
        int a = scan.nextInt();
        String b=a%3==0||a%4==0||a%5==0?"能被3或4或5整除":"不能被3或4或5整除";
        System.out.println(a+b);
    }
}
　　

 

輸入一個數，如果是能被2整除，且能被3整除，則輸出：i+”能被2和3整除” （i是輸入的數字）。

//輸入一個數，如果是能被2整除，且能被3整除，則輸出：i+”能被2和3整除” （i是輸入的數字）。
//用&&實現。
import java.util.Scanner;
public class HWD1E2{
    public static void main(String args[]){
        Scanner scan =new Scanner(System.in);
        System.out.print("請輸入一個整數：");
        int a = scan.nextInt();
        String b =a%2==0&&a%3==0?"能被2和3整除":"不能被2和3整除";
        System.out.println(a+b);
    }
}