-----------android培訓、java培訓、java學習型技術博客、期待與您交流！------------
一、關鍵字
定義：被Java賦予了特殊含義的單詞。
特點：體現上都是英文小寫。
|
用於定義數據類型的關鍵字 |
||||
|
class(類) |
interface(接口) |
( 整數類型)byte |
short |
int |
|
long |
(浮點類型)float |
double |
(字符類型)char |
(布爾型)boolean |
|
void(函數上表示無返回值類型) |
|
|
|
|
|
用於定義數據類型值的關鍵字 |
||||
|
true(真) |
false(假) |
null(空) |
|
|
|
用於定義流程控制的關鍵字 |
||||
|
(判斷)if |
else |
switch |
case |
default |
|
(循環)while |
do |
for |
break(結束循環或選擇結構) |
continue(繼續循環) |
|
return(返回) |
|
|
|
|
|
用於定義訪問權限修飾符的關鍵字 |
||||
|
private(私有的) |
public(共有的) |
protected(受保護的) |
|
|
|
用於定義類，函數，變量修飾符的關鍵字 |
||||
|
abstract(抽象) |
final(最終) |
static(靜態的) |
synchronized(同步的) |
enum(枚舉)
|
|
用於定義類與類之間關係的關鍵字 |
||||
|
synchronized(同步的) |
implements(實現) |
|
|
|
|
用於定義建立實例及引用實例，判斷實例的關鍵字 |
||||
|
new(建立實例) |
this(當前引用) |
super(父類引用) |
instanceof(判斷對象類型) |
|
|
用於異常處理的關鍵字 |
||||
|
try(檢查異常) |
catch(捕獲異常) |
finally(最終執行) |
throw(拋出異常) |
throws(拋出異常) |
|
用於包的關鍵字 |
||||
|
package(創建包) |
import(導入包) |
|
|
|
|
其他修飾符關鍵字 |
||||
|
native(本地) |
strictfp(精確浮點) |
transient(變量修飾符) |
volatile(類型修飾符) |
assert(斷言) |
注：main不是關鍵字，卻是被虛擬機所識別的一個名稱。
二、標識符
就是給類,接口,方法,變量等起名字時使用的字符序列。它由26個英文字母大小寫，數字0-9，符號 _ 和$組成。
定義合法標識符的規則：
1、 數字不可以開頭。
2、 不可以使用關鍵字。
注：Java中嚴格區分標識符的大小寫。在起名字的時候，爲了提高閱讀性，要儘量有意義。秉承着見名知意的原則.
Java中的名稱規範：
包名：多單詞組成時所有字母都小寫。
單級:
helloword
多級:
com.baidu.waimai cn.itcast.helloworld
類名接口名：多單詞組成時，所有單詞的首字母大寫。
一個單詞:
Demo
多個單詞:
HelloWorld
變量名和函數名：多單詞組成時，第一個單詞首字母小寫，第二個單詞開始每個單詞首字母大寫。
一個單詞:
main(),show(),eat()
多個單詞:
getName(),getAge()
常量名：所有字母都大寫。多單詞時每個單詞用下劃線連接。
一個單詞:
PI
多個單詞:
COUNTRY_AREA
三、註釋
用於解釋說明程序的文字,是一個程序員必須要具有的良好編程習慣。註釋的作用爲解釋說明程序，提高程序的閱讀性;可以幫助我們排錯。
Java中註釋分類及格式:
單行註釋
格式： //註釋文字
多行註釋
格式： /* 註釋文字 */
文檔註釋
格式：/** 註釋文字 */
四、常量
定義：在程序運行過程,其值不發生改變的量。
Java中常量可分爲字面值常量和自定義常量兩類,其中字面值常量的分類：
1，整數常量。所有整數。
2，小數常量。所有小數。
3，布爾型常量。較爲特有，只有兩個數值。true false。
4，字符常量。將一個數字字母或者符號用單引號( ' ' )標識。
5，字符串常量。將一個或者多個字符用雙引號(“”)標識。
6，null常量。只有一個數值就是：null。
對於整數，Java有三種表現形式：
五、進制
進制就是認爲規定的進位方式。x進制,就是逢x進一。這在我們的生活中是十分常見的,比如我們最常見的時間計時秒進分,分進時,時進天,天進月等就是分別採用了60,60,24,30等作爲進制計算的。而在計算機中進制只有四種,分別爲:二進制、四進制、八進制、十六進制。
二進制的由來在於早期利用開關的開關狀態記錄事件,由於開關只有開和關兩種狀態,可變化量太少,所以人們就採用八個這樣的狀態爲一組作爲一個基本的數據單位字節,byte。但是由於二進制的存儲太長,所以就產生了分組記錄的方式,以三個爲一組,就出現了八進制;以4個爲一組就出現了十六進制。
表達方式分別爲:
1. 二進制:0b開頭 0,1 滿2進1
2. 八進制:0開頭 0~7 滿8進1
3. 十進制:默認生活中一樣
4. 十六進制:0x開頭 0~9 ,abcedf 滿16進1
規律: 同樣的數字符號,進制越大,數值越大
進制的基本轉換：
十進制轉換爲——>二進制：如9的二進制，算法
9/2 = 4 ...1
4/2 = 2 ...0
2/2 = 1 ...0
1/2 = 0 ...1
結果就爲：0b1001。注意：用所給數據對2進行整除直到商爲0,再將餘數按照從後到前的順序讀出就是最後的結果。二進制轉成十進制還可以利用8421碼,用所給數據減去最近的8421碼值,然後再將餘數按照相同的方式計算直至結果我零,將用到的8421碼值記錄下來轉換成二進制形式。如:9-8 = 1....8
1-1 = 0....1,用到了1,8也就是2^0和2^3,最後的結果就是:0b1001。
十進制轉成八進制和十六進制的方法同十進制轉二進制的算法.
二進制轉化爲——>十進制：如1100的十進制等於
23*1+22*1+21*0+20*0=12。
可以理解爲:係數*基數^權值 之和,這可以理解我其他進制轉成十進制的公式。
係數:數位上的那個值
基數:進制就是那個基數
權值:就是那個基數上次冪,從右向左,從0開始數.
八進制 0100
基數8
結果 = 1*8^2 + 0 + 0 = 64
十六進制 0x100
基數16
結果 = 1*16^2 + 0 + 0 = 256
進制轉成其他進制還有一種方法,那就是分組的方法,三個二進制位表示一個八進制位,例如:0b1001 0101
000--0 100--4
001--1 101--5
010--2 110--6
011--3 111--7
010 010 101
--- --- ---
2 2 5
所以最後的結果爲:0225。要注意的是分組從最右側開始,當左側的位數不足時要在最左側補0。二進制轉成十六進制方法同上,要注意的是一個十六進制位要由四個二進制位來表示。
有符號的表示方式:
1. 原碼: 符號位 和 數值位 0 1
2. 反碼: 符號位不變,數值位取反
3. 補碼: 反碼的基礎上補1
4. 正數 原反補都一樣
5. 負數 需要原反補轉換
6. 因爲計算機運算的都採用補碼去運算
帶符號數據的表示方法:
分爲三種:原碼 反碼 補碼
原碼 : 最高位 爲符號位,其他位爲 數值位 , 0 表示正數, 1表示負數
如1100 1110
符號位 數值位
1 1001110
反碼: 正數跟原碼一樣
負數,符號位不變,數值位取反 0變1 1變0
符號位 數值位
1 0110001
補碼: 正數跟原碼一樣
負數,在反碼的基礎上補1
符號位 數值位
1 0110010
已知某數X的補碼爲1110 1110B，試求其原碼。
符號位 數值位
補碼: 1 110 1110
反碼: 1 110 1101
原碼: 1 001 0010-- > -18
六、變量
概念：在程序運行過程,其值在一定範圍內可以發生改變的量。原理爲在內存中開闢一個存儲空間。有自己的名稱（變量名）和類型（數據類型）。
作用：用來不斷的存放同一類型的數據，並可以重複使用。
定義變量的格式：數據類型 變量名 = 初始化值;
數據類型：
Java中有兩種數據類型：1、基本數據類型；2、引用數據類型。
而數據類型的作用是限制初始化值的範圍。
其中基本數據類型可以理解爲四類八種,即:
類型 字節 範圍
整數 byte 1 -128~127
short 2 -32768~32767
int 4 -2^31 - 2^31-1
-2147483648-2147383647
long 8 -2^63 - 2^63-1
浮點數 float 4 -3.4*10^38-3.4*10^38
double 8 -1.7*10^308-1.7*10^308
字符 char 2 0-65535
布爾 boolean 1 true false
要注意的是:(1)在定義變量的時候,虛擬機默認接收整數是int類型,如果你想賦值long類型的數,需要在數值後面加 l 或者 L。
(2)在定義變量的時候,虛擬機默認接收浮點數是double類型,如果你想賦值float類型的數,需要在數值後面加 f 或者 F。
類型的自動提升：
在運算中，當低類型數據與高類型數據進行計算時，系統會自動將表達式中的低類型數據提升到高類型。如：
byte b = 3 ; int c;
c= b + 2; //b會自動提升爲int類型進行運算。
強制類型轉換：
1、 隱式轉換
整數在做運算的時候,會有一個默認數據類型向上提升
(1) byte,short,char-->int-->long-->float-->double
(2) byte,short,char相互之間不轉換，他們參與運算首先轉換爲int類型;boolean類型不參與轉換
2、顯示轉換(強制轉換)
(1) 格式: 數據類型 變量名 = (目標數據類型)(數據);
(2) 隱含了可能損失精度
當程序中，數據類型需要變換時，可以進行強制轉換。如：
注意:
下面這個有沒有問題
double d =12.345;
float f =d ;// 有問題,將double類型的值賦值給float,可能會丟失精度
下面兩句有沒有區別?
float f = (float) 12.345; // 隱含了可能損失精度
float f =12.345f; // 直接賦值
下面語句哪句是編譯失敗的呢？爲什麼呢？
byte b1=3,b2=4,b;
b=b1+b2; //失敗,b1與b2爲byte類型的值,在運算過程中會被轉換成int類型,所以b1+b2的結果爲int類型,將int類型的值賦值給byte類型可能 會導致精度丟失
b=3+4;//成功,本身爲賦值
字符和字符串的運算
(1) 字符類型-->自動提升,具體的值可查閱ASCII碼錶
(2) 字符串 -->拼接字符串(拼串兒)
例如:
System.out.println('a'); //a
System.out.println('a'+1); //98 字符 a 對應97
System.out.println("5+5="+5+5); //"5+5=55"
System.out.println( 5+5+"=5+5"); // "10=5+5"
使用變量的注意事項
1.作用域
指的是有效的使用範圍,一個變量只能聲明一次,即相同作用域中不能定義兩個同名變量
2.初始化值
在使用變量前賦值,沒有初始化值不能直接使用
3.一行一變量
一行定義一個變量
七、運算符
1、算術運算符
|
運算符 |
運算 |
範例 |
結果 |
|
+ |
正 |
+3 |
3 |
|
- |
負 |
b=4;-b |
-4 |
|
+ |
加 |
5+5 |
10 |
|
- |
減 |
6-4 |
2 |
|
* |
乘 |
3*4 |
12 |
|
/ |
除 |
5/5 |
1 |
|
% |
取模 |
5%5 |
0 |
|
++ |
自增（前） |
a=2;b=++a |
a=3;b=3 |
|
++ |
自增（後） |
a=2;b=a++ |
a=3;b=2 |
|
-- |
自減（前） |
a=2;b=--a |
a=1;b=1 |
|
-- |
自減（後） |
a=2;b=a-- |
a=1;b=2 |
|
+ |
字符串相加 |
“he”+”llo” |
“hello” |
注：（1）進行取模運算時，如果有負數，運算結果取決於運算左邊有沒有負數。字符串數據和任何數據使用 +都是相連接，最終都會變成字符串。整數做運算,結果還是整數，要記得區分’＋‘的正、連、加。
（2）自增與自減
單獨使用
在前面和後面是沒有區別的
參與運算
有區別
++在前面,先++,再運算
++在後面,先運算,再++
自增自減運算隱藏了一個強制轉換。
請分別計算出 a, b ,c 的值?
int a = 10;
int b = 10;
int c = 10;
a = b++; a 10 b 11
c = --a; a 9 c 9
b = ++a; a 10 b 10
a = c--; a 9 c 8
B:案例演示 :運算符的優先級
請分別計算出x,y的值?
int x = 4;
int y = (x++)+(++x)+(x*10);
4 6 6*10 = 70
5 6
2、賦值運算符
|
運算符 |
運算 |
範例 |
結果 |
|
= |
把右邊賦值給左邊 |
x = 4 |
4 |
|
+= |
左邊和右邊做加法運算，再賦值給左邊 |
x = 4;x += 2 |
6 |
|
-= |
左邊和右邊做減法運算，再賦值給左邊 |
x = 4;x -= 2 |
2 |
|
*= |
左邊和右邊做乘法運算，再賦值給左邊 |
x = 4;x *= 2 |
8 |
|
/= |
左邊和右邊做除法運算，再賦值給左邊 |
x = 4;x /= 2 |
2 |
|
%= |
左邊和右邊做取模運算，再賦值給左邊 |
x = 4;x %= 2 |
0 |
演示例題：看下面的程序是否有問題，如果有問題，請指出並說明理由。
short s=1;s = s+1;//有問題，可能會丟失精度
short s=1;s += 1; //沒有問題，原因見下
s += 1; <==> s = (short) s + 1;
原因: += 賦值運算符隱含了一個強制轉換 .
3、比較運算符
|
運算符 |
運算 |
範例 |
結果 |
|
== |
相等於 |
4==3 |
false |
|
!= |
不等於 |
4!=3 |
true |
|
< |
小於 |
4<3 |
false |
|
> |
大於 |
4>3 |
true |
|
<= |
小於等於 |
4<=3 |
false |
|
>= |
大於等於 |
4>=3 |
false |
|
instanceof |
檢查是否是類對象 |
“hello” instanceof String |
true |
注：1、比較運算符的結果都是boolean型，也就是要麼是true，要麼是false。
2、比較運算符“==”不能誤寫成“=”，會造成不兼容的類型的錯誤。
4、邏輯運算符
邏輯運算符用於連接boolean類型的表達式。
|
運算符 |
運算 |
範例 |
結果 |
|
& |
AND(與) |
false&true |
false |
|
| |
OR(或) |
false|true |
true |
|
^ |
XOR(異或) |
false^true |
true |
|
! |
NOT(非) |
!true |
false |
|
&& |
AND(短路) |
false&&true |
false |
|
|| |
OR(短路) |
false||true |
true |
&：只要兩邊的boolean表達式結果，有一個爲false，那麼結果就是false。只有兩邊都爲true，結果爲true。
|：兩邊只要有一個爲true，結果爲true；只有兩邊都爲false，結果爲false。
^：兩邊相同結果是false，兩邊不同結果是true。
&和&&的區別：
單&時，左邊無論真假，右邊都進行運算；
雙&時，如果左邊爲真，右邊參與運算，如果左邊爲假，那麼右邊不參與運算。
“|”和“||”的區別同理，雙或時，左邊爲真，右邊不參與運算。
演示事例：
第一題
int x = 1,y = 1;
if(x++==2 & ++y==2){
x =7;
}
System.out.println("x="+x+",y="+y);
結果爲：x = 2,y = 2
---------------------------------------------------
第二題
int x = 1,y = 1;
if(x++==2 && ++y==2){
x =7;
}
System.out.println("x="+x+",y="+y);
結果爲：x = 2,y = 1
---------------------------------------------------
第三題
int x = 1,y = 1;
if(x++==1 | ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);
結果爲：x = 7,y = 2
---------------------------------------------------
第四題
int x = 1,y = 1;
if(x++==1 || ++y==1)
{
x =7;
}
System.out.println("x="+x+",y="+y);
結果爲：x = 7,y = 1
5、位運算符:操作的是二進制位
|
運算符 |
運算 |
範例 |
結果 |
細節 |
|
<< |
左移 |
6<<2 |
24 |
空位補0，被移除的高位丟棄，空缺位補0。 |
|
>> |
右移 |
6>>1 |
3 |
被移位的二進制最高位是0，右移後，空缺位補0； 最高位是1，空缺位補1。 |
|
>>> |
無符號右移 |
6>>>1 |
3 |
被移位二進制最高位無論是0或者是1，空缺位都用0補。 |
|
& |
與運算 |
6&3 |
2 |
任何二進制位和0進行&運算，結果是0； 和1進行&運算結果是原值。 |
|
| |
或運算 |
6|3 |
7 |
任何二進制位和0進行 | 運算，結果是原值； 和1進行 | 運算結果是1。 |
|
^ |
異或運算 |
6^3 |
5 |
任何相同二進制位進行 ^ 運算，結果是0； 不相同二進制位 ^ 運算結果是1。 |
|
~ |
按位取反 |
~6 |
-7 |
對二進制進行取反。 |
異或： ^；任何相同二進制位進行 ^運算，結果是0；1^1=0 , 0^0=0。
不相同二進制位 ^運算結果是1。1^0=1 , 0^1=1。一個數位^另外一個數兩次,其值不發生改變
異或( ^ )與或( | )的不同之處是：當左右都爲true時，結果爲false。
邏輯運算符用於連接布爾型表達式，在Java中
不可以寫成3<x<6，應該寫成x>3 & x<6 。
0000 0011
& 0000 0100
----------------
0000 0000
0000 0011
| 0000 0100
---------------
0000 0111
0000 0011
^ 0000 0100
---------------
0000 0111
& :有0則0(類似 false)
| :有1則1(類似 true)
^ :相同爲0,不同爲1
演示事例：
實現兩個整數變量的交換:
int a =10;
int b =20;
int c;
c = a;
a = b;
b = c;
--------------------------------------
a = a ^ b; // a 30
b = a ^ b; // b 30^20 (a ^ b) ^b
a = a ^ b; // a 30^10 a ^ (a ^ b)
位移 :二進制位
<< 左移 : 移動一位,就是擴大2倍,右邊空的位置補0
>> 右移 : 移動一位,就是縮小2倍,左邊的位置,最高位爲0,補0;最高位爲1,補1
>>> 無符號右移 :移動一位,左邊無論是什麼,都補0
0000 1000
00 100000
10000000 00000000 00000000 00001000
>>> 0010000000 00000000 00000000 000010
6、 三元運算符
格式：
(條件表達式)?表達式1：表達式2；
a)如果條件爲true，運算後的結果是表達式1；
b)如果條件爲false，運算後的結果是表達式2；
示例：
獲取兩個數中大數。
int x=3,y=4,z;
z = (x>y)?x:y;//z變量存儲的就是兩個數的大數。
獲取三個整數中的最大值
max = (x>((y>z)?y:z))?x:((y>z)?y:z);
運算符的優先級：
運算符優先級表
|
優先級 |
運算符 |
結合性 |
|
1 |
() [] . |
從左到右 |
|
2 |
! +(正) -(負) ~ ++ -- |
從右向左 |
|
3 |
* / % |
從左向右 |
|
4 |
+(加) -(減) |
從左向右 |
|
5 |
<< >> >>> |
從左向右 |
|
6 |
< <= > >= instanceof |
從左向右 |
|
7 |
== != |
從左向右 |
|
8 |
&(按位與) |
從左向右 |
|
9 |
^ |
從左向右 |
|
10 |
| |
從左向右 |
|
11 |
&& |
從左向右 |
|
12 |
|| |
從左向右 |
|
13 |
?: |
從右向左 |
|
14 |
= += -= *= /= %= &= |= ^= ~= <<= >>= >>>= |
從右向左 |
八、鍵盤錄入
鍵盤錄入數據概述
我們目前在寫程序的時候，數據值都是固定的，但是實際開發中，數據值肯定是變化的，所以，我準備把數據改進爲鍵盤錄入，提高程序的靈活性。
三步步驟
1. 導包 import java.util.Scanner;
2. 創建對象 Scanner sc = new Scanner(System.in);
3. 接收數據 sc.nextInt(); sc.nextLine();
4. 在控制檯輸入,方便我們運行程序
案例演示
鍵盤錄入練習：鍵盤錄入兩個數據，並對這兩個數據求和，輸出其結果
import java.util.Scanner;
class ScannerTest1{
public static void main(String[] args){
//創建對象
Scanner sc = new Scanner(System.in);
System.out.println("請輸入數字,我會計算兩個數的和");
//接收數據
System.out.println("請輸入第一個數字...");
int a = sc.nextInt();
System.out.println("請輸入第二個數字...");
int b = sc.nextInt();
//求和
int result = a+b;
//輸出
System.out.println("您輸出數字我算出來了,結果爲:" + result);
}
}
九、轉義字符
概念：通過 \ 來轉變後面字母或符號的含義。
常用轉義字符：
\b：退格
\n：換行
\t：製表符，相當於tab鍵
\r：回車
\\：表示反斜槓
\'：表示單引號
\"：表示雙引號
-----------android培訓、java培訓、java學習型技術博客、期待與您交流！------------