正數：
源碼：即對應的二進制
源碼，反碼，補碼一樣
負數：
反碼 = 最高位之後全取反，最高位不變
補碼 = 反碼 + 1
float: 後面要加f
long： 後面要加 L 或 l
switch 根據jdk版本
1.6及以上版本支持string變量
switch常量值不能一樣
switch能解決的問題，都可以用多重if都可以解決
但是反過來不可以
等值判斷首選switch
switch只能執行等值判斷問題
無特殊情況case 最後要break；
默認值default放在最後比較好
異常：if(input.hasNextInt()){}
循環結構：
while(條件表達式) 先判斷 後執行
do while 無條件執行一次，然後再判斷條件
變量在哪個大括號裏面聲明
作用域就在哪個大括號裏面
string變量.equals（“y”）
System.exit(0); //正常退出程序
int random = (int)(Math.random()*1000);
//隨機生成1000以內的整數
import java.util.Scanner;
Scanner input = new Scanner(System.in);
int x = input.nextInt();
//創建輸入
數組一般和for循環一起使用
循環次數確定用for循環
for(; ; ;)可省表達式，分號不可省
過程：表達式1，表達式2正確則執行循環體，表達式3
break //跳出當前整個循環結構
與條件語句一起使用
continue; //跳過本次循環
與break區分開來
array //數組開闢連續的空間存數據
數組也有數據類型
數組元素的數據類型相同
int[] a; //聲明數組，聲明後長度固定
a = new int[5]; //給數組分配空間
a[0] = 8; //賦值
b = a; // 兩個數組公用一個內存（淺拷貝）
// a 改變後 b 也是改變了，兩個數組同時改變
a[0] = a[0]*10; //使用數組元素
數組作爲參數傳遞，作爲引用
可以作爲引用參數改變值
也可以：
int[] a = new int[5]; //一次性分配空間
一個int類型4個字節
int[] a = {a,b,c,d}; //一次性賦值
//想要倒序就反過來輸出
求最大值：（打擂臺思想）
if(max<a[i]){
max = a[i];
}
二維數組：
int[][] arr = new int[3][5];
int[][] arr = { {1, 2},{3, 4, 5},{5, 6} }
//支持創建列不相等的二維數組
//不是以最長列爲基準讓每行都等列
arr[i][j] （i 行 j 列）
arr.length: 行數（高度）
arr[i].length: 第 i 行的列數（寬度）
Exception 異常類 //在JDK API 1.6.0中文版中查看常見異常
在畢業之前記住100多個異常
比較字符串大小：s1.compareTo(s2);
//爲正數則s1>s2
String.valueOf(num).length();
//返回一個數字有多少位數
雙重for循環解決方程組（雞兔同籠）
解決二維數組輸入類型（多個班級學員）
解決雙重累加、累乘
for（int aa : 數組名) {
//int aa就是數組的別名
System.out.println(aa);
}
//第四種循環：foreach循環
//變態for循環，只能用來遍歷輸出
//不能做其他操作
//逆序獲取x的各位數
while(x!=0){
i = x%10;//得到x的個位數
x = x / 10;//得到x除了個位數之外的數
}
//判斷它是幾位數
int count = 0;
while(n != 0)
{
n = n/10;
count++;
}
//生成四位隨機數?
int max = 9999;
int min = 1000;
cardNumber = (int)(Math.random()*(max-min)) +min;
//2+22+222+2222..........
巧妙算法：
int a = 2;
int sum = 0;
int num = 0;
for(int i = 1; i <= n; i++)
{
num = num * 10 + a;
sum = sum + num;
}
//1,1,2,3,5,8.......
(也可以用數組做)
用第三變量存中間值：
int a = 1,b = 1,c = 0;
for(int i = 0, i < n; i++)
{
c = a;
a = b;
b = b + c;
}
一個基本數據類型的變量作爲參數傳遞的時候，
在方法裏面對形參做修改不會影響實參的
數組做形參，則會改變，涉及到引用地址
int temp = a[0];
a[0] = b[0];
b[0] = temp;
//a, b 作爲參數互換兩個數組的內容
//對象也是類似數組，引用數據類型
方法重載：
1.方法名相同
2.參數的個數或類型要不同
3.返回類型不理
正確遞歸：
1.設計正確的遞歸算法
2.設計一個遞歸出口
public static int getSum( int n ){
if (n == 0){
return 1;
}
return n + getSum(n - 1);
}
（API 含左不含右）
數組常用方法：
//拷貝數組從a1考到a2
System.arraycopy( a1, 0, a2, 0, 3 );
//二分查找, 必須有序的數據，返回下標
Arrays.binarySearch(a, n);
//快速打印數組內容
System.out.print(Arrays.toString(arr));
//導入數組包
import java.util.Arrays;
//數組排序，默認升序
Arrays.sort(數組名);
//拷貝數組a, 返回4個元素存到b
int[] b = Arrays.copyOf( a, 4 );
//比較兩個數組是否相等
Arrays.equals(a, b);
//給d初始化
Arrays.fill( d, 100);
//存大寫字母
for( int i = 0, i < 26, i++ ){
str[i] = (char)('A' + i) + "";
}
//輸入字符串
String str = s.nextLine();
//全部變成大寫字母
toUpperCase()
//獲取字符串下標爲index的值
str.charAt(index)
//變成字符數組
toCharArray()
//格式化和解析日期的具體類
SimpleDateFormat
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
//Date 類與獲取年月的函數
//創建日期對象
Date date = new Date();
//獲取年
int year = date.getYear() + 1900;
//獲取月
int month = date.getMonth() + 1;
//獲取星期，如果沒有明確到天，默認返回每月的1號的星期
int day = date.getDay();
java常用算法：
排序都是雙重循環
查找都是一重循環
考慮時間複雜度 和 空間複雜度
//順序查找
int strainghtSearch(int[] num, int n){
for(int i = 0; i < num.length, i++){
if(num[i] == n)
return i;
else
return -1;
}
//折半查找(也叫二分查找，要求集合有序)
//開始的時候min = 0; max = arr.length
while (min <= max) {
int mid = (min + max) / 2;
if (num[mid] == n) {
return mid;
}else if (num[mid] > n) {
max = mid - 1;
}else{
min = mid + 1;
}
}
return -1;
//冒泡排序
for (int i = 1; i < num.length; i++) {//共進行n-1趟
for (int j = 0; j < num.length -i; j++) {
if (num[j] > num[j + 1]) {
int temp = num[j];//比前一個小, 則與之交換
num[j] = num[j + 1];
num[j + 1] = temp;
}
}
}
//直接插入排序
for (int i = 1; i < num.length; i++) {//共進行n-1趟插入
int m = i;
while(m>=1 && num[m] < num[m-1]){//短路表達式
int temp = num[m-1];//比前一個小, 則與之交換
num[m-1] = num[m];
num[m] = temp;
m--;
}
}
面向對象特性：抽象，封裝，繼承，多態
對象特徵：屬性（成員變量），行爲（方法）
類也是一種數據類型，組合的數據類型
對象是引用數據類型， 數組也是
類是對象的抽象
對象是類的實例化
抽象：
定義類的過程
封裝：
1. 將屬性和行爲封裝到一個類，對象
2. 不同的訪問權限（public/private）
3. 功能的實現細節要封裝
繼承：
不勞而獲，繼承父類（extends）
（父類也叫超類，子類也叫派生類）
1. 直接獲得父類已有的東西
2. 改造父類已有的東西
3. 增加自己新的東西
4. java不支持多繼承（多個父親），c++支持
5. java通過接口彌補不能多繼承的缺憾
多態：
同一種行爲，得到不同的形態
構造方法：
new 對象的時候構造方法執行
系統默認有無參的構造方法
自己定義後默認構造方法不存在了
自己可以重載一個無參構造方法
垃圾對象：
當一個對象失去了所有引用變量引用它的時候（沒人在用它了）
對象的比較：
==就是比較兩個變量的值是否相等（不包括地址）
equals 是比較兩個變量的內容是否相同
obj1 == obj2；//兩個地址相等
obj1.equals(obj2) //比較
//java中所有的類都是Object的子類
//Object 類中有equals方法
//重寫比較方法
@Override
public boolean equals( Object obj ){
Person p = (Person)obj;
if(this.name.equals(p.name) && this.age == p.age){
return true;
}else{
return false;
}
}
//打印對象
System.out.println（obj.toString()）;
//重寫打印對象方法
@Override
public String toString(){
return "[" + name + " " + age + "]";
}
this 關鍵字：
代表一個對象 （也代表類）
指當前調用的對象
可以訪問本類中的屬性和方法
this(); //調用本類的構造方法
this()調用本類構造方法這條語句必須寫在構造方法的首行
this()不能調用自己所在的構造方法
this()調用構造方法不能形成閉環
理解main()方法：
public //共有的
static //靜態的
void //不需要返回值
String[] //系統傳遞參數使用的
運行的時候加上系統參數，可以作爲args[]打印出來
內存：棧區、堆區、靜態區、代碼段區
靜態變量：
生命週期長，隨着類而生
類名可以直接調用
對象共享的變量
用於存對象的值相等的屬性
靜態方法：
生命週期長，隨着類而生
類名可以直接調用
靜態方法不可以調用非靜態變量（非靜態的變量只有在創建對象纔會產生，相當於調用了不存在的東西）
也不可以調用非靜態方法
用於不訪問對象特有值得方法
比如說輸出數組，排序數組
總之：
靜態有侷限性，有共同性
靜態方法塊：
在類名下面寫（類加載就執行，只一次）
父類優先與子類
（但子類的靜態代碼塊優先於父類構造代碼塊）
主類優先於其它類
構造代碼塊：
寫在類體裏面
優先於構造方法
單例模式：
1. （只能產生一個程序窗口的軟件）
2. 構造方法私有
3. 定義一個靜態的本類對象成員
4. 設計一個公共的靜態接口方法
用於返回本類對象
private static Obj obj = null;
public static Obj getObj(){
if(obj == null)
obj = new Obj();
return obj;
}
單例類:
避免創建多個對象
省去了new操作符
類似交易引擎，必須用單例類
單例模式保證不重複命令
不重複交易
對象數組：
和常用的數組差不多
但是要注意對象實例化
（API 含左不含右）
基本數據類型的包裝類：
java思想：（一切皆對象）
基本數據類型 包裝類
char ---> Character
int ----> Integer
byte -----> Byte
short ------> Short
long -----> Long
float ---> Float
double ----> Double
boolean ---> Boolean
int i = 0;
Integer x = new Integer(i); //老版本裝箱過程
int j = x.intValue(); //老版本拆箱過程
//是整形字符串可得整數，若不是整形則報錯
int result = Integer.parseInt(“1234”);
//result == 1234
//類似的;Double.parseDouble(str);
（API 含左不含右）
String 類的常見方法：
charAt(index) //返回字符串的index下標的值
toCharArray() //變成字符數組
indexOf("s") //返回str的位置
trim(); //消除字符串兩邊的空格
str.split("&") //按照一定格式分割字符串
str.replace('a','p') //替換
String.valueOf(x); //將x變成字符串
String a = x + ""; //也可以將x變成字符串
java註釋：
文檔註釋、單行註釋、多行註釋
繼承：(extends關鍵字)
1. 子類可以直接獲得父類已有的東西
2. 子類可以改造或增加父類的方法
3. 子類可以
4. super():父類的構造方法
super：當前類的父類對象（臨時對象）
5. 構造方法裏面的父類對象只是在創子類的時候暫時存在
6. 私有的成員不能被繼承，也不能重寫
7. 子類有無參構造方法，父類必須也有
8. super可以訪問父類的屬性和方法
final 修飾的方法不可重寫
final 修飾的類不可繼承
9. 向上轉型，子類轉父類沒問題，能運行所有的方法
10. 向下轉型，父類轉子類，編譯的時候要進行強轉，運行的時候有時對，有時錯
11.如果這個父類引用的是父類實力的話，運行的時候一定出錯，無關是否調用的方法是父類和子類中都有的
12.構造方法不能重寫，不能繼承
修飾符：
protected：不同包非子類不可訪問，其他可以
protected: 不能修飾外部類
public：都可用
final 修飾的方法不可重寫
final 修飾的類不可繼承
多態：（重寫、重載、抽象方法、接口實現）
（對象多態性和方法多態性）
方法重載：
1.方法名相同
2.參數的個數或類型要不同
3.必須在同一個類
4.註釋：Overload
方法重寫：
1.方法名相同
2.參數個數與類型都相同
3.返回值類型子類必須小於父類（類類型才比較）
4.子類的方法權限必須大於或等於父類
5.註釋：Override
6.final 修飾的方法不可重寫
7.final 修飾的類不可繼承
8.構造方法不能重寫，不能繼承
//重寫打印對象方法
@Override
public String toString(){
return "[" + name + " " + age + "]";
}
抽象類:（abstract關鍵字）
（接口定義一種標準，抽象類定義一種模板）
1.用來作爲一個超類繼承
2.abstract修飾的類
3.可以包含抽象方法
4.抽象類不具有實例化的能力
5.如果抽象類的子類沒有實現父類中的所有抽象方法，那麼這個子類依然是一個抽象類
if(animal instanceof Dog){
((Dog)animal).swingTail();
}//判斷是否是這個類
（對象 instanceof 類或接口）
void
//從-128---------127 true
Integer i = -129;
Integer j = -129;
System.out.println(i==j);
但是 new出來的==比較都是false
final關鍵字：
final修飾的類不可繼承
final修飾的變量只能賦值一次（只能讀）
final修飾的方法不可重寫
fun(final int[] arg){
arg[0] = 5;
} //程序沒錯，args沒被賦值
public static final int I = 100;
//全局變量，建議大寫
接口：（interface關鍵字）
（接口定義一種標準，抽象類定義一種模板）
1.接口裏面只能包含全局常量和抽象方法
2.裏面的變量都默認爲全局變量
默認有 public static final 修飾
3.裏面的方法都默認爲抽象方法
默認有public abstract 修飾
4.接口可以多繼承，彌補繼承的缺陷
(C++類可多繼承，Java不可以)
5.implement 實現
只有調用子類重寫父類的方法時，才體現對象多態性
一個接口可以繼承多個接口.
interface C extends A, B { }是可以的.
一個類可以實現多個接口:
class D implements A,B,C{ }
但是一個類只能繼承一個類,不能繼承多個類
class B extends A{ }
在繼承類的同時,也可以繼承接口:
class E extends D implements A,B,C{ }
類的內部類：
1.可以被任何類修飾符修飾
2.通過外部類點內部類訪問
//創建一個內部類對象
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
3.屬性有就近原則
4.Outer.this.name //內部類的成員變量
5.不能用super關鍵字，沒用
6.匿名接口實現類（匿名內部類）直接new 對象直接調用，不用事先new對象
方法內部類：（沒有什麼意義的）
枚舉：（用於類似四季，星期幾）
enum Color{
yellow,
blue,
gray,
red
}
Color color = Color.red;
Color[] colors = Color.values();
for(Color:value, colors)
{ System.out.print(value);}
java系統常見類：
如果一個類沒有構造方法：
1.它裏面所有方法都是靜態方法
2.如果它裏面有靜態方法，那麼它一定有一個靜態的返回此類對象的接口方法runTime()
System 類：
exit(0); //退出系統
System.arraycopy(b,2,a,3,3);//拷貝數組
getProperties() //返回當前系統屬性
console(...) //獲取當前控制檯對象
readPassword(...) //禁止回顯，不顯示輸入的東西
//在cmd裏面纔能有結果
Console con = System.console();
System.out.println("請輸入密碼：");
char[] ch = con.readPassword();
String str = new String(ch);
System.out.println(str);
Runtime 類：
（程序運行時）
Math 類：
abs();
cos(); //cos值
cbrt(a);//返回立方根，必須正數，否則返回NaN
round(2.5);//返回最接近的long值,返回3
rint(2.5);//返回最接近的int，返回2
ceil(2.4);//向上取整，返回3
floor(2.4);//向下取整，返回2
Random random = new Random();
//帶固定參數的話每次生成的隨機數不變
random.nextInt(33)+1;//隨機產生1~~33
random.nextDouble();
random.nextFloat();
BigInteger 類：
（大數據操作類）
BigInteger bi1 = new BigInteger("987979879878");
BigInteger bi2 = bil.add(new BigInteger(100000));
String 類：
Date 類：
內存：棧區、堆區、靜態區、代碼段區
java垃圾回收機制：只負責堆內存，不負責棧區
finalize() //系統自動調用（當對象成爲永死狀態）
System.gc();//通知系統馬上回收垃圾（不通知也會回收）
demo = new Demo();
demo = null;//去活狀態
demo = this;//復活（在重寫finalize()裏面鞋且只有一次復活一次）
傳參JVM：右鍵Run As --->run configuration..
當程序中出現異常，而我們沒有處理的時候它交給JVM處理，JVM的處理方式就是結束程序
異常處理機制：
算數異常（ArithmeticException)
數組越界（ArraysIndexOutOfBoundsException）
空指針異常（NullPointException）
輸入不匹配（InputMismatchException）
指定的類不存在（ClassNotFoundException）
轉換爲數字異常（NumberFormatException）
方法的參數錯誤（IllegalArgumentException）
沒有訪問權限（IllegalAccessException）
數據類型轉換異常（ClassCastException）
文件未找到（FileNotFoundException）
數組存儲異常（ArrayStoreException）
方法不存在（NoSuchMethodException）
文件結束異常（EOFEception）
實例化異常（InstantiationException）
內存不足（OutOfMemoryException）
不支持克隆（CloneNotSupportedException）
被中斷異常（InterruptedException）
未找到類定義（NoClassDefFoundException）
//循環輸入int但出現非int的問題
if(input.hasNextInt()){
x = input.nextInt();
}else{
input.next();
}
或：
try{
x = input.nextInt();
//寫可能會出現異常的代碼
}catch(Exception e){
input.next();
//寫異常處理的代碼
}catch(){
//寫異常處理的代碼
}finally{
//寫不管如何一定會輸出的代碼
//比如數據庫連接的close();方法
}
例：
try{
result = i / j;
for(int k = 0; k > 3; k++){
sum = sum1[k] + sum;
}catch(Exception e){
System.out.print("除數爲0！");
System.out.print("數組越界");
}//可以兩個catch，但是一旦捕獲到異常不會繼續下面的代碼
寫多個catch的時候一定要從小到大
try{
if(i < 0 || j < 0） {
//主動拋出異常
throw new ArithemticException();
}else{
result = i * j;
}
}catch(ArithemticException e){
System.out.print("輸入的數有負數");
e.printStackTrace();//打印異常的跟蹤棧信息
}
自定義異常類：
class MyException extends Exception{
//默認沒有構造方法,構造方法不能重寫，不能繼承
public MyException(String name){
super(name);
}
}
斷言語法：
assert boolean 條件
用來調試，現在沒什麼實用性
註解：（Annotation）
不是簡單的對代碼的說明
很多框架裏面廣泛使用
JDK1.5以後引進，與類，接口，枚舉一個層次的
功能：
編寫文檔，（生成doc檔）
代碼分析，（使用反射）
編譯檢查，（）
系統的三個內定註解：
1.@Override:判斷某個方法是否是一個正確的重寫的方法，
只能在方法前用（如果不是，則方法報錯）
2.@Deprecated:標記某個結構是否是已過時的，
不建議使用，可以使用在類，字段，方法前
3.@SuppressWarnings("all") 壓制系統警告的信息（使用需要帶參數）
可以使用在類，字段，方法前
系統的四個元註解：（用來定義註解）
1.@Target：定義註解的使用範圍
2.@Retention：制定生命週期
3.@Inherited：制定註解是否被繼承
4.@Documented：指定註解是否會被生成到doc文檔
自定義註解:
@Target({ElementType.FIELD，ElementType.TYPE，ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
//變量要記得帶括號，參數可以默認值
//自定義類型，接口類型，包裝基本數據類型不支持作爲參數
//註解類型可以用
public @interface MyAnnotation{
int value() default 3;
int name() default 4;
}
用法：@MyAnnotation(value = 3,name = 5);
//當變量名爲value,value可省
JDBC （Java DataBase Connectivity）
java數據庫連接，用於執行SQL語句的一組API
數據庫有很多種：
Oracle，MySql，SQL Server，DB2，Sybase
1.加載驅動
2.獲取數據庫的連接對象
3.通過獲得數據庫連接對象獲取一個Statement對象
4.通過Statement對象執行我們想要執行的SQL語句
後知後覺：
1.表設了外鍵本表可以直接刪除
2.被引用表不可刪除
3.必須去除引用財會，先刪引用它的表
4.可以修改數據，除了外鍵之外的
5.一般先獲取表所有信息存到集合
6.查詢、顯示可以在集合做
7.數據有更新再訪問數據庫修改
數據庫連接池：
往池子預先初始化幾個連接對象，
要用的時候從池子裏拿出一個對象來用，
用完歸還。
c3p0步驟：
1.導jar包（c3p0-xxx.jar）
2.複製配置文件(c3p0-config.xml)到src下
3.如果直接的用的化就是new一個ComboPooledDataSource
對象然後通過這個DataSource獲得Connection 連接對象
4.也可以先封裝一個工具類
dbcp步驟：
1.導jar包（commons-dbcp-xx.jar和commons-pool-xx.jar）
2.複製配置文件(xx.properties)到src下
3.如果直接的用的化就是new一個ComboPooledDataSource
對象然後通過這個DataSource獲得Connection 連接對象
4.也可以先封裝一個工具類
dbutils步驟:
1.導jar包（c3p0-xxx.jar）
2.new QueryRunner(C3PoUtils.getDataSource());
Object類型可以兼容所有類型int double ...
但是Object類型存在類型轉換的安全隱患
（萬能數據類型）
泛型類的定義：(泛型可以帶多個)
class Poit<T,K> {
private T xPos;
private K yPos;
pubic Point(T xPos, K yPos){
this.xPos = xPos;
this.yPos = yPos;
}
public void setxPos(T xPos){
this.xPos = xPos;
}
public T getxPos(){
return this.xPos;
}
}
//實例化
Point<nteger> p = new Point<Integer>(12,23);
泛型類對象之間是不能直接自動轉換的
//不同類型不能直接賦值
實例化泛型的類型只能是類類型
類實現泛型接口：
clas IC2<T,K> implements I2<T>{
//如果接口名沒有帶<T>,系統默認Object
//繼承也是同理，系統默認Object
//類可以擴展泛型，但必須帶上接口的
//記住：重寫參數類型和數量必須一致
}
泛型方法的定義：
//在類裏面定義（類不一定爲泛型類）
//泛型方法跟泛型類之間不相互影響
public <T> T add(T x, T y){
return x + y;
}
public <T> fun(){
}
publc static <T>
class P<T>{
//T i = 2; 不可
//T[] = new T[5]; 不可
//初始化方法
public void set(T a, T[] b){
i = a;
T[] = b;
}
}
new 泛型數組的時候不要用<>
MyGener<Integer>[] mgs = new MyGener[5];
mgs[0] = new MyGenr<Integer>();
泛型類充當泛型的實例化類（嵌套）
Test<Info<String,Integer>> t = new Test<Info<String,Integer>>();
Info<String,Integer> info = new Info<String,Integer>();
info.setValue("hehe");
info.setV(34);
t.setValue(info);
通配符，能讀不能寫
受限泛型：
設置上限：
class MyGener<T extends Number>{
}
public static void show(Test<? super Number>test)
設置下限:(只能在聲明對象的時候用)
數據結構：
線性：
順序表：
棧：先進後出
隊列：先進先出
鏈式存儲：
單鏈表，多鏈表
class Node{
int iData; //數據域
Node pNext; //指針域
}
main(){
Node node123pHead = new Node();
node1.pNext = node2;
node2.pNext = node3;
pHead = node1;
}
非線性：
樹
圖
集合：
list.size() //元素個數，不是集合大小
remove(index) //刪除，通過下標或者通過元素
輸出集合：
1.直接用System.out.println(list);
2.通過for循環 或者 for_each循環
3.通過迭代器遍歷
Iterator<Integer> it = list.iterator
while(it.hasNext()){
}
elementt() //獲取但不移除列表的頭元素
peek() //獲取但不移除列表的頭元素
poll() //獲取並移除第一個元素
romove()//默認移除第一個元素
peekLast()
pop() //出棧 獲取並移除第一個元素
push() //入棧
offer() //往後添加
getFirst() //
getLast()
clone()
list:
ArrayList和LinkList
有序插入
treeSet:(sortedSet的唯一實現類)
會自動排序，也無插入順序
set:
無插入順序，取決於哈希地址
且內容不重複，且去重
如果需要判斷對象是否相等，需要
重寫equals()方法和hashCode()方法
public boolean equals(Obj o){
Person p = (Person)obj;
if(){ return ture}
else(){ return false}
}
public int hashCode(){
return name.hashCode() + age;
}
可自動生成重寫的方法
如果重寫了compareTo()方法，可以不用重寫
hashCode(),equals(）方法也可以實現去重
JVM：
JAVA 反射機制：
1.獲取反射入口，也就是獲取Person類的Class實例
ClassLoader loader = ClassLoader.getSystemClassLoader();
//第一種方法加載類實例
Class c = loader.loadClass("com.itjob.Person");
//第二種方法加載類實例
Class.forName("com.itjob.Person");
//第三種方法加載類實例
Person p = new Person();
Class c = p.getClass();
//第三種方法加載類實(比較有效，不用知道包名)
Class c = Person.class;
2.通過相應的反射API完成相應的反射操作
//實際中一般不用這種
Person p = (Person)c.newInstance();
getConstructor();//獲取指定的構造方法
getConstructors();//獲取到所有的構造方法
getMethod();
getMethods();
Class c = Person.class;
Class cs = c.getSuperclass();
Class[] inters = c.getInterfaces();
Constructor[] cons = c.getDeclaredConstrutors();
Constructor con = c.getDeclaredConstrutor(String.class,int.class)
Person p = (Person)con.newInstance();
Class[] types = m.getParameterTypes();
getXXX():獲取當前類和父類繼承下來的XXX結構，不包含非public
getDeclaredXXX():包含非public
Method m = c.getDeclaredMethod("fun");
m.invoke(p); //通過反射調用
m.setAccessible(true);
sql語句拼接變量存在危險：
aaa' or '1'='1
//配置文件
src ---> new ----> file
file name : db.properties
driverclassname = com.mysql.jdbc.Driver
url = jdbc:mysql:///student?useUnicode=true&characterEncoding=utf-8
usernme=root
password=123456
static{
1.通過ResourceBundle類來加載資源源文件中的配置數據
ResourceBundle bundle = ResourceBundle.getBundle("db");
driverClassName = bundle.getString(driverClassName);
...
2.通過Properties類來加載資源源文件中的配置數據
Properties p = new Properties();
InputStream inStream = JDBCUtil.class.getClassLoader().getSystemResourceAsStream("db.properties");
p.load(inStream);
driverClassName = p.getProperty("driverClassName");
}
線程、進程：
進程：程序一次動態執行的過程
線程：進程已線程爲單位，爲了數據共享
n（至少一個）個線程組成一個進程
進程中必須有主線程
輪換快，與同時進行一樣
實現多線程的兩種方式：
1.通過Tread類實現
自定義一個類繼承Tread類
重寫run()方法，也就是線程方法
我們需要這個線程做的事都應該放到此方法中來自做
在需要創建一個線程的地方new一個自定義線程對象，
//運行時不能調用run(),否則沒差別
2.通過Runnable接口實現
自定義一個類實現Runnable接口
重新run()方法，一樣的
運行時：
MyThread1 mtr1 = new MyThread1();
new Thread(mtr1).start();
只有在run()方法裏面跑的纔是子線程
wait(); //等待
notify(); //通知
多線程解決阻塞
IO 流：
字節流、字符流、管道流
字節流：InputStream OuputStream
FileInputStream FileOuputStream
字符流：
File f1 = new File ("C;\\aaa\\1.txt");
得到類型對象
f1.createNewFile();
創建對象
絕對路徑：
從系統的根目錄出發的路徑
相對路徑：
不是從系統根目錄出發的路徑
字符流---->字符流的轉換：
InputStreamReader
OutputStreamWriter
字符編碼：
ASCII
GBK, GB2312
BIG5:繁體中文
unicode
utf-8
ISO-8859-1:單字節
支持中文的字符集：GBK, GB2312, utf-8
亂碼原因：
兩端使用的字符編碼不一致
編碼：字符--->byte[] String.getByte()--->byte[]
解碼：byte[]---->字符 new String(byte[], charset)
對象序列化：（串行化）
將對象轉換爲二進制流
java網絡編程：
TCP：
1.三次握手
2.面向連接
3.安全可靠
4.傳輸速度慢
UDP：
InetAddress 類的使用：
ServerSocket 類的使用：
服務器：
創建服務器套接字
綁定IP和端口
等待客戶端的連接請求（如果有客戶端連接上來就會產生一個與客戶端的連接套接字）
收發數據
關閉與客戶端的連接套接字
關閉服務器
客戶端：
創建一個客戶端的套接字
發送一個請求(如果服務開啓則）
基於這個連接進行收發數據
關閉這個連接
按位取反：
快捷算法：相反數-1
~4567 = -4567 - 1 = -4568
~（-2345）= 2345 - 1 = 2344
// Springframework的jar包
https://repo.spring.io/release/org/springframework/spring/
