第一類:邏輯型boolean
第二類:文本型char
第三類:整數型(byte、short、int、long)
char類型占2個字節
short從-32768到32767
int從-2147483648,到2147483647共10位
long從-9223372036854775808到9223372036854775807共19位
第四類:浮點型(float、double)
在數學中0到1有無數個浮點數；而計算機是離散的，所以表示的時候有誤差，計算機用精度（小數點后幾位來表示正確），比較浮點數時a==0.1是不合適的，應該a-0.1==0;如果a是0.1,則即使有誤差 a-0.1==0因為a和0.1都被表示為一個有誤差的計算機二進制
基本類型，或者叫做內置類型，是JAVA中不同于類的特殊類型。它們是我們編程中使用最頻繁的類型。java是一種強類型語言，第一次申明變量必須說明數據類型，第一次變量賦值稱為變量的初始化。
1. Java的簡單類型及其封裝器類
Java基本類型共有八種，基本類型可以分為三類，字符類型char，布爾類型boolean以及數值類型byte、short、int、long、float、double。數值類型又可以分為整數類型byte、short、int、long和浮點數類型float、double。JAVA中的數值類型不存在無符號的，它們的取值范圍是固定的，不會隨著機器硬件環境或者操作系統的改變而改變。實際上，JAVA中還存在另外一種基本類型void，它也有對應的包裝類 java.lang.Void，不過我們無法直接對它們進行操作。8 中類型表示范圍如下：
byte：8位，最大存儲數據量是255，存放的數據范圍是-128~127之間。
short：16位，最大數據存儲量是65536，數據范圍是-32768~32767之間。
int：32位，最大數據存儲容量是2的32次方減1，數據范圍是負的2的31次方到正的2的31次方減1。
long：64位，最大數據存儲容量是2的64次方減1，數據范圍為負的2的63次方到正的2的63次方減1。
float：32位，數據范圍在3.4e-45~1.4e38，直接賦值時必須在數字后加上f或F。
double：64位，數據范圍在4.9e-324~1.8e308，賦值時可以加d或D也可以不加。
boolean：只有true和false兩個取值。
char：16位，存儲Unicode碼，用單引號賦值。
Java決定了每種簡單類型的大小。這些大小并不隨著機器結構的變化而變化。這種大小的不可更改正是Java程序具有很強移植能力的原因之一。下表列出了Java中定義的簡單類型、占用二進制位數及對應的封裝器類。
簡單類型
boolean
byte
char
short
Int
long
float
double
void
二進制位數
1
8
16
16
32
64
32
64
--
封裝器類
Boolean
Byte
Character
Short
Integer
Long
Float
Double
Void
對于數值類型的基本類型的取值范圍，我們無需強制去記憶，因為它們的值都已經以常量的形式定義在對應的包裝類中了。如：
基本類型byte 二進制位數：Byte.SIZE最小值：Byte.MIN_VALUE最大值：Byte.MAX_VALUE
基本類型short二進制位數：Short.SIZE最小值：Short.MIN_VALUE最大值：Short.MAX_VALUE
基本類型char二進制位數：Character.SIZE最小值：Character.MIN_VALUE最大值：Character.MAX_VALUE
基本類型double 二進制位數：Double.SIZE最小值：Double.MIN_VALUE最大值：Double.MAX_VALUE
注意：float、double兩種類型的最小值與Float.MIN_VALUE、 Double.MIN_VALUE的值并不相同，實際上Float.MIN_VALUE和Double.MIN_VALUE分別指的是 float和double類型所能表示的最小正數。也就是說存在這樣一種情況，0到±Float.MIN_VALUE之間的值float類型無法表示，0 到±Double.MIN_VALUE之間的值double類型無法表示。這并沒有什么好奇怪的，因為這些范圍內的數值超出了它們的精度范圍。
Float和Double的最小值和最大值都是以科學記數法的形式輸出的，結尾的"E+數字"表示E之前的數字要乘以10的多少倍。比如3.14E3就是3.14×1000=3140，3.14E-3就是3.14/1000=0.00314。
Java基本類型存儲在棧中，因此它們的存取速度要快于存儲在堆中的對應包裝類的實例對象。從Java5.0（1.5）開始，JAVA虛擬機（Java Virtual Machine）可以完成基本類型和它們對應包裝類之間的自動轉換。因此我們在賦值、參數傳遞以及數學運算的時候像使用基本類型一樣使用它們的包裝類，但這并不意味著你可以通過基本類型調用它們的包裝類才具有的方法。另外，所有基本類型（包括void）的包裝類都使用了final修飾，因此我們無法繼承它們擴展新的類，也無法重寫它們的任何方法。
基本類型的優勢：數據存儲相對簡單，運算效率比較高
包裝類的優勢：有的容易，比如集合的元素必須是對象類型，滿足了java一切皆是對象的思想
2.Java中的常量
十六進制整型常量：以十六進制表示時，需以0x或0X開頭，如0xff,0X9A。
八進制整型常量：八進制必須以0開頭，如0123，034。
長整型：長整型必須以L作結尾，如9L,342L。
浮點數常量：由于小數常量的默認類型是double型，所以float類型的后面一定要加f(F)。同樣帶小數的變量默認為double類型。
如：float f;
f=1.3f;//必須聲明f。
字符常量：字符型常量需用兩個單引號括起來（注意字符串常量是用兩個雙引號括起來）。Java中的字符占兩個字節。一些常用的轉義字符：
①\r表示接受鍵盤輸入，相當于按下了回車鍵；
②\n表示換行；
③\t表示制表符，相當于Table鍵；
④\b表示退格鍵，相當于Back Space鍵；
⑤\'表示單引號；
⑥\''表示雙引號；
⑦\\表示一個斜杠\。
3. 數據類型之間的轉換
1).簡單類型數據間的轉換,有兩種方式:自動轉換和強制轉換,通常發生在表達式中或方法的參數傳遞時。
自動轉換
具體地講,當一個較"小"數據與一個較"大"的數據一起運算時,系統將自動將"小"數據轉換成"大"數據,再進行運算。而在方法調用時,實際參數較"小",而被調用的方法的形式參數數據又較"大"時(若有匹配的,當然會直接調用匹配的方法),系統也將自動將"小"數據轉換成"大"數據,再進行方法的調用,自然,對于多個同名的重載方法,會轉換成最"接近"的"大"數據并進行調用。這些類型由"小"到"大"分別為 (byte，short，char)--int--long--float—double。這里我們所說的"大"與"小",并不是指占用字節的多少,而是指表示值的范圍的大小。
①下面的語句可以在Java中直接通過：
byte b;int i=b; long l=b; float f=b; double d=b;
②如果低級類型為char型，向高級類型（整型）轉換時，會轉換為對應ASCII碼值，例如
char c='c'; int i=c;
System.out.println("output:"+i);輸出：output:99;
③對于byte,short,char三種類型而言，他們是平級的，因此不能相互自動轉換，可以使用下述的強制類型轉換。
short i=99 ; char c=(char)i; System.out.println("output:"+c);輸出：output:c;
強制轉換
將"大"數據轉換為"小"數據時，你可以使用強制類型轉換。即你必須采用下面這種語句格式： int n=(int)3.14159/2;可以想象，這種轉換肯定可能會導致溢出或精度的下降。
2)表達式的數據類型自動提升, 關于類型的自動提升，注意下面的規則。
①所有的byte,short,char型的值將被提升為int型；
②如果有一個操作數是long型，計算結果是long型；
③如果有一個操作數是float型，計算結果是float型；
④如果有一個操作數是double型，計算結果是double型；
例， byte b; b=3; b=(byte)(b*3);//必須聲明byte。
3)包裝類過渡類型轉換
一般情況下，我們首先聲明一個變量，然后生成一個對應的包裝類，就可以利用包裝類的各種方法進行類型轉換了。例如：
①當希望把float型轉換為double型時：
float f1=100.00f;
Float F1=new Float(f1);
double d1=F1.doubleValue();//F1.doubleValue()為Float類的返回double值型的方法
②當希望把double型轉換為int型時：
double d1=100.00;
Double D1=new Double(d1);
int i1=D1.intValue();
簡單類型的變量轉換為相應的包裝類，可以利用包裝類的構造函數。即：Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value)
而在各個包裝類中，總有形為××Value()的方法，來得到其對應的簡單類型數據。利用這種方法，也可以實現不同數值型變量間的轉換，例如，對于一個雙精度實型類，intValue()可以得到其對應的整型變量，而doubleValue()可以得到其對應的雙精度實型變量。
4)字符串與其它類型間的轉換
其它類型向字符串的轉換
①調用類的串轉換方法:X.toString();
②自動轉換:X+"";
③使用String的方法:String.volueOf(X);
字符串作為值,向其它類型的轉換
①先轉換成相應的封裝器實例,再調用對應的方法轉換成其它類型
例如，字符中"32.1"轉換double型的值的格式為:new Float("32.1").doubleValue()。也可以用:Double.valueOf("32.1").doubleValue()
②靜態parseXXX方法
String s = "1";
byte b = Byte.parseByte( s );
short t = Short.parseShort( s );
int i = Integer.parseInt( s );
long l = Long.parseLong( s );
Float f = Float.parseFloat( s );
Double d = Double.parseDouble( s );
③Character的getNumericValue(char ch)方法
5）Date類與其它數據類型的相互轉換
整型和Date類之間并不存在直接的對應關系，只是你可以使用int型為分別表示年、月、日、時、分、秒，這樣就在兩者之間建立了一個對應關系，在作這種轉換時，你可以使用Date類構造函數的三種形式：
①Date(int year, int month, int date)：以int型表示年、月、日
②Date(int year, int month, int date, int hrs, int min)：以int型表示年、月、日、時、分
③Date(int year, int month, int date, int hrs, int min, int sec)：以int型表示年、月、日、時、分、秒
在長整型和Date類之間有一個很有趣的對應關系，就是將一個時間表示為距離格林尼治標準時間1970年1月1日0時0分0秒的毫秒數。對于這種對應關系，Date類也有其相應的構造函數：Date(long date)。
獲取Date類中的年、月、日、時、分、秒以及星期你可以使用Date類的getYear()、getMonth()、getDate()、getHours()、getMinutes()、getSeconds()、getDay()方法，你也可以將其理解為將Date類轉換成int。
而Date類的getTime()方法可以得到我們前面所說的一個時間對應的長整型數，與包裝類一樣，Date類也有一個toString()方法可以將其轉換為String類。
有時我們希望得到Date的特定格式，例如20020324，我們可以使用以下方法，首先在文件開始引入，
import java.text.SimpleDateFormat;
import java.util.*;
java.util.Date date = new java.util.Date();
//如果希望得到YYYYMMDD的格式
SimpleDateFormat sy1=new SimpleDateFormat("yyyyMMDD");
String dateFormat=sy1.format(date);
//如果希望分開得到年，月，日
SimpleDateFormat sy=new SimpleDateFormat("yyyy");
SimpleDateFormat sm=new SimpleDateFormat("MM");
SimpleDateFormat sd=new SimpleDateFormat("dd");
String syear=sy.format(date);
String smon=sm.format(date);
String sday=sd.format(date);
總結：只有boolean不參與數據類型的轉換
（1）.自動類型的轉換：a.常數在表數范圍內是能夠自動類型轉換的
b.數據范圍小的能夠自動數據類型大的轉換（注意特例）
int到float，long到float，long到double 是不會自動轉換的，不然將會丟失精度
c.引用類型能夠自動轉換為父類的
d.基本類型和它們包裝類型是能夠互相轉換的
（2）.強制類型轉換：用圓括號括起來目標類型，置于變量前
4.Java引用類型
Java有 5種引用類型（對象類型）：類 接口 數組 枚舉 標注
引用類型：底層結構和基本類型差別較大
JVM的內存空間：（1）. Heap 堆空間：分配對象 new Student（）
（2）. Stack 棧空間：臨時變量 Student stu
（3）.Code 代碼區 ：類的定義，靜態資源 Student.class
eg：Student stu = new Student（）； //new 在內存的堆空間創建對象
stu.study(); //把對象的地址賦給stu引用變量
上例實現步驟：a.JVM加載Student.class 到Code區
b.new Student()在堆空間分配空間并創建一個Student實例
c.將此實例的地址賦值給引用stu， 棧空間
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
一、介紹
變量就是申請內存來存儲值。也就是說，當創建變量的時候，需要在內存中申請空間。
內存管理系統根據變量的類型為變量分配存儲空間，分配的空間只能用來儲存該類型數據。
Java語言提供了八種基本類型。六種數字類型（四個整數型，兩個浮點型），一種字符類型，還有一種布爾型。
byte：
byte數據類型是8位、有符號的，以二進制補碼表示的整數；
最小值是-128（-2^7）；
最大值是127（2^7-1）；
默認值是0；
byte類型用在大型數組中節約空間，主要代替整數，因為byte變量占用的空間只有int類型的四分之一；
例子：byte a = 100，byte b = -50。
short：
short數據類型是16位、有符號的以二進制補碼表示的整數
最小值是-32768（-2^15）；
最大值是32767（2^15 - 1）；
Short數據類型也可以像byte那樣節省空間。一個short變量是int型變量所占空間的二分之一；
默認值是0；
例子：short s = 1000，short r = -20000。
int：
int數據類型是32位、有符號的以二進制補碼表示的整數；
最小值是-2,147,483,648（-2^31）；
最大值是2,147,483,647（2^31 - 1）；
一般地整型變量默認為int類型；
默認值是0；
例子：int a = 100000, int b = -200000。
long：
long數據類型是64位、有符號的以二進制補碼表示的整數；
最小值是-9,223,372,036,854,775,808（-2^63）；
最大值是9,223,372,036,854,775,807（2^63 -1）；
這種類型主要使用在需要比較大整數的系統上；
默認值是0L；
例子： long a = 100000L，Long b = -200000L。
float：
float數據類型是單精度、32位、符合IEEE 754標準的浮點數；
float在儲存大型浮點數組的時候可節省內存空間；
默認值是0.0f；
浮點數不能用來表示精確的值，如貨幣；
例子：float f1 = 234.5f。
double：
double數據類型是雙精度、64位、符合IEEE 754標準的浮點數；
浮點數的默認類型為double類型；
double類型同樣不能表示精確的值，如貨幣；
默認值是0.0d；
例子：double d1 = 123.4。
boolean：
boolean數據類型表示一位的信息；
只有兩個取值：true和false；
這種類型只作為一種標志來記錄true/false情況；
默認值是false；
例子：boolean one = true。
char：
char類型是一個單一的16位Unicode字符；
最小值是’\u0000’（即為0）；
最大值是’\uffff’（即為65,535）；
char數據類型可以儲存任何字符；
例子：char letter = ‘A’。
下圖是java的基本數據類型
二、筆記
packagecom.hgd.study;/*** java的數據類型
*@authorHuTiger
**/publicclassDataType {publicstaticvoidmain(String[] args) {//定義一個數據類型的語法/** 1.數據類型 變量名 =字面
* 2.數據類型 變量名；
* 變量名=字面1
* 變量名=字面2
* 變量名=字面3*//** long的范圍 -2^63 -->2^63-1
* int范圍-2^31 -->2^31-1
* short范圍-2^15 -->2^15-1
* byte范圍? -2^7 -->2^7-1
* float范圍2^127 -->2^149-1*/longlmin=-9223372036854775808l;//定義一個long的類型要以l結尾不區分大小寫longlmax=9223372036854775807l;floatf=9.98f;//定義單精度浮點型需要在后面加上f不區分大小寫doubled=95.00d;//定義雙精度浮點型需要在后面加上f不區分大小寫booleanfals=false;//布爾類型System.out.println(fals);//falsefals=true;//變量的字面值是可以改變的System.out.println(fals);//true//char類型charc=' ';
c='1';
c='人';//----------------------練習intx=1;
System.out.println(x);chary ='1';
System.out.println(y);//java是一個嚴格區分數據類型語言System.out.println(x+2);//結果=3System.out.println(y+2);//結果=51}
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
一、介紹
數據類型的轉換，分為自動轉換和強制轉換。自動轉換是程序在執行過程中“悄然”進行的轉換，不需要用戶提前聲明，一般是從位數低的類型向位數高的類型轉換；強制類型轉換則必須在代碼中聲明，轉換順序不受限制。
自動數據類型轉換
自動轉換按從低到高的順序轉換。不同類型數據間的優先關系如下：
低--------------------------------------------->高
byte,short,char-> int -> long -> float -> double
運算中，不同類型的數據先轉化為同一類型，然后進行運算，轉換規則如下：
二、筆記
packagecom.hgd.study;/*** 基本數據類型之間的轉換
*@authorHuTiger
**/publicclassDataTypeConversion {publicstaticvoidmain(String[] args) {
}/*** 小類型向大類型的轉換：
* 完成的是自動轉換，不許要程序員做相應的操作
*@paramargs*/publicstaticvoidsTob()
{byteb=100;
System.out.println(b);inti=b;
System.out.println(i);
}/*** 大類型向小類型的轉換*/publicstaticvoidbTos()
{/** 大類型向小類型轉換叫做強制類型轉換。同時要注意類型的邊界值*/inti=100;byteb =(byte)i;
System.out.println(b);
}/*** int和char類型的轉換
* int轉成char是強制類型轉換
* char轉int是自動轉換*/publicstaticvoidintTochar()
{inti=97;charc=(char)i;
System.out.println(c);charc1='a';inti1=c1;//java語言中默認將a的Unicode碼賦值給i1}
}
指針和引用的聯系與區別
★ 相同點：
1. 都是地址的概念；
指針指向一塊內存，它的內容是所指內存的地址；引用是某塊內存的別名。
★ 區別：
1. 指針是一個實體，而引用僅是個別名；
2. 引用使用時無需解引用(*)，指針需要解引用；
3. 引用只能在定義時被初始化一次，之后不可變；指針可變；
4. 引用沒有 const，指針有 const；
5. 引用不能為空，指針可以為空；
6. “sizeof 引用”得到的是所指向的變量(對象)的大小，而“sizeof 指針”得到的是指針本身(所指向的變量或對象的地址)的大小；
7. 指針和引用的自增(++)運算意義不一樣；
8.從內存分配上看：程序為指針變量分配內存區域，而引用不需要分配內存區域。
注解：http://www.cnblogs.com/xdp-gacl/p/3622275.html
