1，數據類型
基本數據類型: byte, short, int, long, float, double, char, boolean
引用數據類型: String 數組 集合 對象
自定義數據類型: ?
2，存儲空間
寄存器： java 不可訪問
棧空間： 存放基本數據類型（效率高，先進後出，空間小，效率次於寄存器）
堆空間： 存放引用數據類型（效率低，大容量，隨機分配）
3，變量的運算
Math.sqrt() -> 計算平方根
Math.round(10*number)/10.0 -> 保留小數點1位
4，變量的作用域（一對大括號的範圍）
5，基本數據類型的包裝類
包裝類列表：Byte Short Integer Long Float Double Character Boolean
包裝類方法：如 Integer.parseInt(String sInteger) -> String 轉換成正數
6，補碼（sign與unsign的概念）
＃科學家自定義
g!->符號位可以與其它位一起處理
g!->減法可以變成加法處理
m!->正數 t-> 負數 ＝ 正數的二進制 取反加一
cc!->模＝某種數據類型的正數
7，正數類型
＃四種類型：byte short int long （默認int）
＃byte b2 = b1+3 默認使用int運算，所以會報錯
8，浮點類型
單精度float 雙精度double
＃默認double （字面量默認）
＃小數時以尾數長度來表示精確度，如pi=3.1415->精確度4位
＃浮點運算就是實數運算
＃double類型保存會有誤差->儘量使用int運算。如double d = 2.6->實際上系統保存爲2.600000000001
9，字符類型
＃char ->底層使用16位正數，unicode編碼來處理字符類型
＃unicode英文字母與數字編碼部分與ASCII碼相同
?->如何打印unicode碼->for{System.out.println(“(char)number”+”:”+number);}
10，轉義字符
\n->回車符
\t->製表位字符
\->表示\，\將轉回原本的字符
\’->表示’
\”->表示“
\u4e2d -> 表示unicode編碼對應的字符（漢字：中），
＃4e2d 轉換成10進制 -> 4*Math.pow(16,3)+14*Math.pow(16,2)+2*16+13 = 20013
(char)20013 ->直接打印出“中”
11，類型轉換
＃小類型->大類型 ：隱式類型轉換（系統自動完成）
＃大類型->小類型 ：強制類型轉換（需要程序員手動執行）
＃Integer.toBinaryString()
＃類型大小排列：byte->short->int->long->float->double
＃基本數據類型轉換有精度丟失與變價數風險的問題
注意：補位取反，轉換成二進制留意最高位，留意類型的精度範圍。例：
int i = 257;
byte b = (byte)i; ->由於i的二進制最高位爲1，byte默認爲負數，會執行補位取反，所以b值爲1
＃main函數args值可以通過arg[0]，獲取程序開啓時輸入的參數，亦是java -jar xxx.jar +參數列表 所攜帶的參數
12，Scanner類的使用
import java.util.Scanner;
Scanner scanner = new Scanner(System.in);
String str;
while (!((str = scanner.next()).equals(“exit”))){
System.out.println(str);
}
//scanner.next();scanner.next().charAt(index);scanner.nextInt();scanner.nextDouble();
13，變量的自增，自減，自乘，自除
int i = 0;
++i -> 先加，再做其他運算
i++ -> 先做其他運算，然後再加
i+=n == i=i+n; ->自增n
- -i ->先減，在做其它運算
i- - ->先做其它運算，再減
i*=n == i=i*n;
i/=n == i=i/n;
14，兩個變量的值互換
int a = 100; int b = 10;
方法1: 定義第三變量
方法2: 利用加減法
->a=a+b -> b=a-b -> a=a-b
15，程序錯誤
＃編譯期錯誤
＃運行期異常
＃邏輯錯誤 -> 程序沒有出錯，只是結果不對
16，語句
switch -> 一定要break
關係運算： == != > < >= <=
邏輯運算：
& -> 與運算（長路運算） 如果兩邊的值是int,則&是兩個int的二進制與運算（二進制各個位對比，11爲1，10爲0），如果兩邊是關係運算，則進行邏輯運算，例如：4<3 & 5*3>12 -> 1) 計算4<3 = false -> 2)計算5*3>12 = true ->3) false & true = false —>最終得到false
&& -> 與運算（短路運算） 當兩個運算結果都true 才true；
＃&&與&的區別—>&&當左邊運算結果爲false時，則不進行右邊的運算
｜ -> 或運算（長路運算） -> 和與運算的規則相同
|| -> 或運算（短路運算）-> 和與運算的規則相同
！ -> 非運算 ->結果取反
＃邏輯運算的優先級: 所有關係運算 > ! > &&/& > ||/|
＃if語句
＃while循環
while循環打印Unicode碼實例：
int i = 0;
while(i<=200){
System.out.println(i+”=”+(char)i);
i++;
}
打印大寫字母實例：
//char 類型的字符在Java底層是通過int來處理的
char c = ‘A’;
while(c<=’Z’){
System.out.println(c+”:”+(int)c);
c++;
}
＃do…while 與while 的區別： do…while 是先做再判斷，while是先判斷再做
＃for循環
＃匿名內部類只能使用外部方法的常量？
＃計算機語言迭代：
第一代：機器語言
第二代：彙編語言
第三代：非結構化語言（Basic） 結構化語言（C）面嚮對象語言（C++，JAVA，80年代開始流行）
＃ （1991年）Sun開始研發Java
＃JAVA SE ＝ Java Standard Edition
＃JAVA EE ＝ Java Enterprise Edition
＃API ＝ Application Program Interface
Java環境變量的配置
1）JAVA_HOME＝C:\….\jdk1.7.0\ -> 代表JDK的根目錄
2）PATH=%JAVA_HOME%\bin -> 代表可以在任意路徑下使用Java命令
3）CLASSPATH=%JAVA_HOME%\tools -> javac編譯命令需要用到dt.jar & tools.jar 兩個文件，所以需要在ClassPath中設置這兩個文件下的路徑
Math類的方法：
Math.floor() -> 取整數
Math.round(float f) -> 四捨五入爲int
Math.abs(-10) -> 取絕對值
Math.pow(3,4) -> 3的4次方
Math.sqrt(120) -> 取平方根
Math.round(3.75*10)/10.0 = 3.8 -> 保留一位小數的方法
類方法／靜態方法
＃由static關鍵字修飾，是靜態成員變量，定義在方法外部
＃JVM虛擬機自動初始化，值爲
＃屬於類的全局變量
＃方法的優點：代碼封裝在方法中，模塊化編程
類和對象的概念
遞歸方法的使用（遍歷手機sdcard，文件夾）
public static int addNum(int num){
if (num ==1){
return 1;
}else {
return num+addNum(num-1);
}
}
＃引用傳遞的方式
1，創建一個新的方法，傳入類，然後修改類內部的變量，這種傳入參數稱爲飲用
＃this關鍵字
this代表的是當前對象，當前類，可以使用this();->代表當前對象的構造方法
＃static
static聲明全局屬性
static方法可以通過類名直接調用
只能訪問static聲明的屬性和方法（其它不能訪問）
Java的三個基本特徵
1，繼承／擴展：
＃獲得父類的所有功能和屬性，按分類來繼承／擴展，
＃單繼承，多重繼承
＃子類不能訪問父類的私有成員
＃子類對象的實例化過程：先調用父類的構造方法，再調用字類的構造方法
＃重寫父類的方法，被重寫的方法權限不能更低
＃super關鍵字 ->強制調用父類的方法，表示的是父類的方法或者屬性
2，封裝
＃private私有化屬性， public方法訪問
3，多態
＃多態性
向上轉型（程序自動完成）
父類 父類對象 ＝ 子類實例；
向下轉型（強制類型轉換）
子類 子類對象 ＝ （子類）父類實例；
＃instanceof -> 判斷一個對象是否某類的實例
抽象類和接口
1，final關鍵字：完結器
＃使用final修飾的類不能被繼承
＃使用final修飾的方法不能被重寫
＃使用final聲明的變量會成爲常量，不能被修改
2，抽象類：包含一個抽象方法的類就是抽象類
＃示例
abstract class Abs{
private int age;
public void tell(){
}
public abstract void say();
public abstract void print();
}
class AbsDemo extends Abs{
@Override
public void say() {
}
@Override
public void print() {
}
}
3，接口：特殊的類，裏面全部是由全局常量和公共的抽象方法所組成
＃實例：
interface Inter{
public static final int AGE = 100;
public abstract void tell();
}
class C implements Inter{
@Override
public void tell() {
System.out.println("alkjdf");
}
}
＃接口可以extend多個接口
＃接口與抽象類的相同點與不同點？
＃接口的使用範例
interface USB{
void start();
void stop();
}
class CDemo {
public static void work (USB u){
u.start();
System.out.println(“工作中”);
u.stop();
}
}
class USBDisk implements USB{
@Override
public void start() {
System.out.println(“USB Disk start”);
}
@Override
public void stop() {
System.out.println(“USB Disk stop”);
}
}
class Printer implements USB{
@Override
public void start() {
System.out.println(“Printer start”);
}
@Override
public void stop() {
System.out.println(“Printer stop”);
}
}
public class main {
public static void main(String[] args) {
CDemo.work(new USBDisk());
CDemo.work(new Printer());
}
}
String字符串
＃實例化方式：String str = “hello”; 或者 String str = new String(“hello”); ->使用第一種方式更省內存空間
＃＝＝比較的是地址，equals()比較的是內容
＃String的內存空間是不可更改的，改變的是堆內存地址的指向
＃常用方法：
length() -> 獲取字符串長度
toCharArray() -> 字符串轉換成數組
String str = “helloadsfsadfsadf”;
char c[] = str.toCharArray();
for (int i = 0; i < c.length; i++) {
System.out.println(c[i]);
｝
charAt() -> 從字符串中取出特定位置的字符
getBytes() -> 字符串轉換成爲byte
indexOf() -> 過濾字符串中存在的字符，如果有，則返回字符所在的位置，如果沒有則返回-1
trim() -> 去掉字符串的前後空格
subString() ->從字符串中取出子字符串
toUpperCase() -> 轉換成大寫
toLowerCase() -> 轉換成小寫
startWith() ->判斷字符串開頭，判斷的條件是一個字符串，長度不限
endsWith() -> 判斷字符串結尾，判斷的條件是一個字符串，長度不限
replace() -> 替換字符串中的一段字符串或者char
StringBuffer(與String最大的不同，StringBuffer的內存空間是可以更改的)
＃常用方法：
append() -> 追加
insert() -> 插入
replace() -> 替換
indexOf() -> 返回字符串所在的位置
＃實際應用中要用StringBuffer，效率高
StringBuilder
＃一個可變的字符序列，單線程建議使用StringBuilder，效率高，但不利於多線程安全
＃使用方式與StringBuffer一樣
異常處理
try{} catch{} finally{}
常見異常：
throws關鍵字