Java的環境配置 day01
1. 環境配置有如下的三種方法：
a) 我的電腦屬性： 從path 環境中配置
b) 利用臨時的變量設置： set path = java的所在路徑\bin%d%
c) 定義批處理文件 ： 設置步驟如下：
a) set path = %cd%\H:\java\jdk1.7\bin
b)
c) start
一． java的環境搭配
1. 安裝jdk >1.jdk是java的開發和運行環境 >2.jre是java的運行環境
2. 配置環境變量?爲什麼呢?方便在任意的目錄下使用java工具
a. 我的電腦—屬性—高級—環境變量
在已有的環境變量path的基礎下，添加一個jdk\bin目錄即可.
這種方法較爲一勞永逸
技巧：爲了日後修改方便，不需要總是修改path，可以首先定義一個環境變量 JAVA_HOME 把前面的路徑保存下來.並且通過%JAVA_HOME%來動態的獲取該變量
b. 也可以通過臨時環境變量，通過dos控制檯，使用set命令即可。
set path = (java的按照目錄)jdk\bin;&path&;
c. 如果是在別人的電腦去完成java開發，還不想配置java環境變量.咱們可以使用批處理來完成：
a) 假設： a.bat
b) set path = %cd%jdk\bin;%path% %cd%代表獲取當前目錄.
c) 爲了避免了不讓它一閃而過：start.
二：轉義字符
1.\n：換行
2.\t：tab鍵
3.\b:退格鍵
三： 數據運算符
& : 只有兩邊都爲true結果爲true，否則爲false。
|：只有兩邊爲flase才爲false,否則都爲true
^ : 只有兩邊相同 結果爲false，否則爲true。
Java基礎知識 day02
二．變量：
在內存中所開闢的空間將常量值進行存儲、方便運算。
好處：該空間可以重複使用..
定義格式：
數據類型 變量名 = 初始值
使用變量的注意事項：
1. 變量有自己的作用域
2. 變量不能賦空值.
基本數據類型：
byte int long char short double boolean float
引用數據類型：
接口 類 數組
什麼時候需要定義變量：
當數據不確定時,或者運算後的結果需要進行下一步的操作
這時候就要定義一個變量將該不確定的數據進行存儲。
三.運算符：
1. 算術運算符：
1. +：連接符
2. %取餘： 任何數%2 結構非零急一
3. ++自增 (++a先運算後賦值 a++先賦值後運算)
2. 賦值運算符：
1. int a,b;
2. a=b=c = 4;
3. i+=4; i=i+4;
3．比較運算符：
特點：運算後結構非false 或true
== 相等於
4.邏輯運算符
& | ^ 這些運算符不僅僅可以代表boolean表達式，也可以進行位運算。
&和&&：當左邊爲false時，&：兩邊的表達式都參與運算。&&右邊的表達式不參與運算。
|和||：當左邊爲true時，|：兩邊的表達式都參與運算。||右邊的表達式不參與運算。
^:兩邊一樣結果爲false。
5．位運算符
左移：<< 3<<2=12 3<<4 = 48
右移：>> 和 >>> 區別：
>>:右移後，空位按照移位前的最高位來填充。最高位爲0，用0補。最高位爲1用1來補
>>>:無符號右移,無論最高位是什麼，都用0補。
6.負數的由來：取反+1
-6: 00000000 00000000 00000000 00000110
取反： 11111111 11111111 11111111 11111001
加一： 11111111 11111111 11111111 11111010
四.語句
判斷：if
1. if(條件表達式){}
2. if(條件表達式){}else{};
3. if(條件表達式){}else{}
對於第二種格式：簡化形式，三元運算符
變量 =(條件表達式)? 表達式1 ：表達式2
簡化形式與非簡化形式有如果不同：
解答： 簡化形式因爲是一個運算，所以咱們必須要有一個結果。
if(x >１)
Y = 100;
else
Y = 200;
Y =(x>1)? 100: 200;
注意：無論條件表達式有多複雜，只要有true ||flase 出現，則沒問題.否則條件表達式會出錯：if(x =1);
選擇:switch(表達式)
switch(表達式)
{
case 1:
執行語句;
break;
case 2:
執行語句;
break;
case 3:
執行語句;
break;
default;
執行語句;
}
特點：
1.表達式運算四種類型的值:byet int short char(它有一個自動型轉換過程)
2.case和default之間是可以沒有任何的順序，但是在運算期間，肯定會先讀取第一個case ,當case不匹配，會繼續執行其他的case。當所有的case不匹配的時候.會運行default。
3.switch語句結束的兩個方式：a.讀取switch語句大括號結束b.碰到break語句結束.注意:如果沒有碰到break，也沒有讀取結束的時候，那麼程序是一直往下面運行，直到程序運算完畢
循環：while du{}while; for
1. while(表達式){執行語句}(先判斷後執行)
2. do{執行語句}while(條件表達式);(先執行一次,再判斷)
3. for(初始化表達式;循環判斷條件;循環後的操作表達式){}
什麼時候用這些語句呢?
當對固定的幾個值進行判斷的時候，建議使用switch
當對範圍的判斷，或者對運算後的真假進行判斷的時候,我們需要用到if
當需要執行語句多次的時候.我們使用到循環
while與for循環是可以相互交換
因爲作用域的關係：
在使用兩個語句的時候有些區分，如果定義變量只爲循環存在，循環結束後就沒有意義。我們使用到for循環語句。
如果變量在循環後再執行別的運算，那麼我們使用while比較好~
break：選擇結構和循環結構
continue：循環結果：結束本次循環.繼續下一次循環
函數：
特點：
--類中的一個獨立小程序
--只有被調用的時候纔會運算
--可以重複的去運行
好處：
對代碼進行封裝,可以提高代碼的複用性
格式：
返回值類型 函數名(參數類型 形式參數1)
{
執行語句;
return 返回值;
}
如果定義一個函數？
1. 明確該功能函數運算後的結果。（明確返回值類型）
2. 明確該功能實現的過程，是否需要有未知值參與運算（明確函數的參數類型）
要定義一個加法運算功能
int getSum(int x ,int y)
{
return x + y;
}
方法的重載：@overload(標記重載)
特點：當多個函數的功能一致，只是參與運算不同的時候，爲了提高代碼的可閱讀性,我們可以使用方法的重載.用參數來進行區分.
int getSum(int x,int y,int z)
{
return x + y + z;
}
函數的特點：
有一種情況，函數執行一個功能，但沒有具體的返回值。返回值類型不可以具體的來確定的時候,那麼我們用void關鍵字來表示.那麼函數的return 語句是可以忽略不寫的. 也可以:return ;
day03 數組
五.數組： 其實就是同類型的一組數字
同一種類型數據的集合，類型一定要一致。
內存圖：
java劃分了兩片內存，方便了運算
棧內存：存放局部變量，函數上和函數定義的變量都是局部變量
變量一點使用完畢,自動清空。
棧內存： new關鍵字所建立的,都稱爲實例.在堆內存裏面存放的.
數組常見的如下問題：
角標越界異常:使用到數組中不存在的角標。
(ArrayIndexOutOfBoundsException) 數組特有異常
空指針異常：引用型變量等於null，也就是沒有指向。
（NullPointsException）
########
本身就是一個容器，用來存儲數據.
特點：固定的長度.
好處：給元素進行編號，從零開始。同時也可以length屬性獲取數組的長度.
什麼時候使用數組？
當數據較多的時候，通常是爲了方便操作這些數據都需要進行臨時存儲.
習慣：
通常操作數組都需要遍歷，獲取數組中的元素需要一個指針。
通常對指針的值的改變也就是更改了數組裏邊的值啦~~
選擇排序：
int[]arr = {1,2,45,657,33,214,64,16,32,13};
for(int i = 0;i<arr.length;i++)
{
for(int j = i+1;j<arr.length;j++)
{
if(arr[j]>arr[i])
{
swap(arr,j,i);
}
}
}
冒泡排序： bubbleSort
public static int[] bubbleSort(int[]arr)
{
for(int i = 0;i<arr.length;i++)
{
for(int j = 0;j<arr.length-i-1;j++)
{
if(arr[j]>arr[j+1])
{
swap(arr,j,j+1);
}
}
}
return arr;
day 04 面向對象
面向對象：
1. 符合現實中人民思考習慣的一種思想.
2. 它將程序員的角色（執行者）轉換成（指揮者）
3. 將複雜的問題簡單化.
對象無處不在,一切皆對象
對象是實實在在存在的個體,那麼我們需要使用計算機語言來進行描述
在java當中，描述事物是通過類來完成,在計算機中是通過new 類來創建對象.並且指揮對象完成事情.
例如： 製造汽車，通過汽車來描述：圖紙。對應的java中的類class
通過圖紙來產生汽車： 對象，對應的就是java在堆內存中所產生的實例
通過java語言編寫程序，其實就是不斷的定義類,創建對象的一個過程。
成員變量（事物的屬性） 成員方法(事物的行爲)。
對象的存在有什麼好處？或者說怎麼才叫做對象?
對象可以用於封裝數據.可以在對象中定義屬性和行爲,並指揮.
在編寫程序中，當要完成某個功能的時候,先看一下java是否提供了自有的對象.如果有,那麼可以直接的去使用這個對象裏面的功能.否則如果該對象不存在.那麼我們需要定義一個對象，並將需要的功能封裝到該對象中,以便對象的重複使用.。
對象是如何使用呢?
通過new 關鍵字來建立，並且通過 對象.成員變量 的形式操作對象所做的事情..
匿名對象：
其實就是一個沒有名字的對象,可以理解爲創建對象的簡化形式.
1. 當只對對象方法進行一次操作的時候可以使用
a) new person();
2. 可以做爲實際參數的傳遞:
a) public void show(new Person());
封裝：
什麼是封裝呢?
其實就是隱藏實現細節，提供了安全性
在通過類來創建對象的時候，可以通過對象調用成員，也可以使用對象的屬性
爲了提高安全性，所以避免了直接對屬性進行訪問：我們可以把它設計爲私有private
對外提供方法來間接訪問age進行賦值！
private int age ;
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
retrun age;
}
在代碼的體現：
1.函數就是一個最小的封裝體
2.類本身就是一種封裝
3.包也是一種封裝
4.ssh框架也是一種封裝.
5.timcat服務器軟件
/*
體現良好的封裝！
*/
class Person
{
private String name ;
private int age;
/*
這是隱藏下來的代碼~~
*/
Person()
{
super();
}
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name ; //this.name
}
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return age;
}
}
class Demo5
{
public static void main(String[] args)
{
Person p = new Person();
p.setName("kudy");
String name = p.getName();
p.setAge(18);
int age = p.getAge();
}
}
執行的過程：
1. 加載Person .class文件到堆內存中
2. 因爲new，在堆內存中開闢空間，創建對象。在對象中出現了name 與age
3. 對象中的屬性默認初始化
4. 對象中的屬性顯式初始化
5. 構造函數初始化
6. 創建引用變量，並將該對象的首地址給變量，該變量這時候就指向了對象。
this語句代碼什麼?
1.this所在的函數所屬對象的引用
2.this被那個對象調用.那this就代表那個對象
A）this還可以用與區分成員變量與局部變量同名的情況
B)什麼時候使用this?
當定義功能時，該變量內部使用了本類的對象,同時，this表示該對象
C）this語句：
在構造函數中，方便於構造函數調用,但注意：this語句只能在構造函數的第一位.因爲要對執行的數據進行初始化.
day05 面向對象
1， 構造函數
a. 函數名與類名相同
b. 沒有返回值
c. 函數中沒有return語句
作用： 可以對對象進行初始化
比喻：Person p = new Person();
a,加載Person.class文件到堆內存中
b,在堆內存中開闢空間，創建實例對象
c,對對象的內容進行默認的初始化
d,對對象的內容進行顯式的初始化
e,對對象自定義的內容進行初始化，通過構造函數來完成的.
f,在棧內存中定義變量存入對象的地址值，指向該對象
注意：
在用class文件時，jvm會自動的在該類添加一個默認的構造函數（沒有構造函數,你就創建不了對象的哦）該函數的形參是空的.
構造函數可以通過this來進行互相的調用，是通過this語句來完成
this的語句一定要放在構造函數的第一行
2,static關鍵字
特點：
---隨着類的加載而加載，隨着類的消失而消失，靜態成員的聲明週期最長
---優先於對象
---被所有的對象所共享
---可以直接通過類名來調用
注意：
---靜態方法只能訪問靜態的成員（因爲我是不需要創建對象就可以使用的）
---靜態方法中不能出現this，super關鍵字.因爲靜態方法沒有所謂的對象
---主函數是靜態的
2， 設計模式：解決某類問題之間有效的方法.
java中有23種設計模式
單例設計模式：
a) 私有化構造函數
b) 定義一個靜態私有化的本類對象
c) 定義一個靜態方法返回內部對象的地址
class Singleton
{
private Singleton()
{
//私有化構造函數,避免創建對象！
}
private static Singleton singleton = new Singleton();
public static Singleton getSingLeton()
{
return singleton;
}
}
class Demo7
{
public static void main(String[] args)
{
Singleton s1 = Singleton.getSingLeton();
Singleton s2 = Singleton.getSingLeton();
System.out.println(s1== s2);
}
}
3,靜態的代碼塊:
特點：隨着類的加載而加載，執行一次，優先於函數
作用：對於類的初始化
4,內部類：
其實就是一個類的內部中定義另外一個類，內部類可以定義在外部類裏面
內部類可以直接訪問外部類的成員，那是因爲內部類只有一個外部類的引用（類名.this）而外部類訪問內部類的成員需要創建對象
什麼時候使用內部類？
描述事物時，該事物內部與還有事物，那麼可以通過內部類來完成
當內部類在成員位置上，可以被成員修飾符所修飾。
當內部類中定義了靜態成員時，內部類是必須要靜態的.但是靜態內部類侷限性
但方法中裏面定義了內部類，方法裏面的屬性內部類是不能所訪問的.因爲局部變量是存儲在棧內存中,系統會不知道什麼時候會被釋放.那麼我們如果定義成final 就是沒問題.定義成final就是常量.是不能改變的量.是存儲在堆內存中.
day06面向對象（面向對象的總結）
異常：
異常的處理機制：
1.可以在方法後面使用throws關鍵字，聲明向外拋出一個異常
2.可以使用try catch語句塊捕獲異常
3.finally語句塊的作用： finally需要結合try使用.不論如何finally當中的代碼都是會被執行
4.如果是運行時異常,那麼jvm是自動的拋出一個異常對象.讓虛擬機去處理.也可以自己手動的去處理.
自定義異常：
1.自定義編譯時異常，定義一個類繼承與Exception
2.可以在程序中使用throw關鍵字向外拋出一個編譯時異常對象,這時方法必須向外拋出一個異常
throw關鍵字相當於return
異常的使用細節：
因爲都是爲了多態而服務的,所以當父類型的引用指向子類型的對象的時候/jvm就分辨不清楚啦~~）
1. 子類重寫父類的方法.不能拋出被父類更多的方法.沒拋,子類不能拋.父類拋了.子類可以不拋.要拋也只能拋父類一樣的異常，或者父類異常的子類.
2. 一個try語句可以跟多個catch語句一起來捕獲異常
3.try finally 可以嵌套使用.
異常的使用總結：
1.異常是在程序運算期間發生的錯誤，所有的異常類都是Throwable的子類
2.error,java的虛擬機錯誤，比較嚴重。處理不了.不用處理。編譯是不會出錯
3.Exception：異常{
一個特殊的子類,RuntimeException這個類的所有的子類都是運行的時候異常,不必要處理,編譯時不會報錯.交給默認的處理程序.其它的子類都是編譯時異常,比較嚴重的錯誤！在方法後面應該跑出去,我們在調用方法一定要處理.否則編譯器會報錯。
}
4.異常處理方式：try {} catch捕獲異常,throws 向外拋出一個異常
5.thorw 與throws 的區別?
throws聲明方法向外拋出一個異常
throw和return一樣,只不過是要創建一個對象
注意：
拋出一個對象,一定需要在方法外面聲明拋出一個異常.
6.自定義異常:
1.可以自己寫一個類繼承與Exception,這個類就是編譯時異常
2.可以自己寫一個類繼承於RuntimeException，這個類就是運算期間異常
面試題目：
1.請說說final 與 finalize 和 finally的區別？三者有什麼共同點?
解答： 除了單詞有點像,他們都是沒什麼緣分的..
1.final是java的修飾關鍵字.修飾類,類不能被繼承.修飾屬性.屬性會編程常量.不能修改的值.修飾方法.這個方法不能被重寫.
2.finalize：是在Object類當中定義的一個方法,所有的類都是默認繼承與Object類.也就是說：繼承了這個方法.當對象被垃圾回收之前.jvm會自動的調用該對象的finalize方法,所以我們一般通過finalize來做一些內存釋放的工作..
3.finally ：java中的關鍵字，必須結合try語句一起來使用.寫在finally代碼中的語句.一定會被執行.除非jvm退出。
class MyException extends Exception
{
public String getMessage()
{
return "上帝~~";
}
}
class Student
{
public void readBook(int num) throws Exception
{
if(num >300 || num <1){
throw new Exception(){ //返回一個對象
//匿名內部類.重寫了父類的方法！
public String getMessage()
{
return "你在吹牛嗎?";
}
};
}
else
{
System.out.println("好孩子！");
}
}
public void eat(int week) throws MyException //向外拋出去一個異常
{
if(week<1||week>7)
throw new MyException(); //結束,有了一個對象！
else
System.out.println("星期是正確的！！");
}
}
class Demo10
{
public static void main(String[] args)
{
try
{
new Student().readBook(400);
}
catch (Exception e)
{
e.printStackTrace();
}
try
{
new Student().eat(88);
}
catch (Exception e) //父類型的引用所指向子類型的對象 Exception e = new MyException();
{
e.printStackTrace();
}
}
}
1. 封裝性：
1)類的封裝：將屬性都私有化(private)，防止外界的直接訪問，對外提供s et 與get方法。
優點：隱藏內部實現過程，方便權限的管理
2)方法的封裝：在實現功能的時候，應該儘可能的多抽取方法，儘量將別人用不到的方法私有化，實現一個封裝性。將提供方法進行功能調用方法設置爲公有的public就可以
優點：讓類看起來更加的整潔，對外隱藏了實現的細節。
2. 抽象：
a) 爲了描述顯示的事物，在程序中通過對象來映射顯示中類的事物（萬物皆對象）
b) 將一組特徵相似的對象共同的特徵和行爲抽象出一個類來定義
c) 類的成員變量（屬性）來描述特徵，用成員方法來描述對象的行爲
3. 繼承：
a) 使用extends 關鍵字讓子類繼承父類，子類就可以自動複用了父類的所有屬性和方法（非私有）
b) 子類實例化過程：
1. 子類的構造方法一定會調用父類的構造方法,可以在第一行使用this（實參）來調用自己其他的構造方法，使用super(實參)來調用父類的構造方法
2. 如果第一行沒有聲明，jvm會自動調用父類的無參的構造方法
3. 子類和父類之間的轉換
1,可以將子類實例當做父類來用，反則不能.
2,把子類當做父類來用時：調用方法是子類的（重寫的關係）,這個是做了動態的綁定,如果是訪問屬性的（靜態的綁定）也就說：調用的數父類的屬性.
3，把子類當做父類來使用時，不能調用子類特有方法，因爲編譯器會檢查語法,發現該父類沒有這個方法，會報錯！
4,如果是把子類當做父類來使用的時候，這時候可以強制類型轉換，則再有把握：咱們都需要用instanceof來判斷一些對象的類型。
4. 多態：
1. 把子類當做父類來用
2. 我們在編程無時無刻不使用多態，在定義一個方法形參的時候，爲了便於方法的通用性，通常會將形參定義爲父類類型，最好是接口類型，當調用方法的時候.那麼就可以子類實例當做父類來使用，正因爲有了多態，我們經常把子類當做父類來使用。所以有了以下的規定。
ii. 返回值類型必須和父類的一致，或者是父類返回值類型的子類實例
iii. 子類不能有比父類更加嚴格的訪問權限,假設父類是 public 而你子類是：private 那麼在傳遞參數的時候，有可能會因爲訪問權限而出錯！所以java是不允許的.
iv. 子類不能被父類拋出更多的異常.
v. 異常： throw 拋出一個異常對象.方法外部也是需要向外聲明拋出一個異常
彩票的搖獎過程：
import java.util.Random;
class Lottery
{
private int poorCount;
private int luckyPoorCount;
private int[] poor;
private int []luckPoor;
//構造函數在構造搖獎的對象
Lottery(int poorCount,int luckyPoorCount)
{
this.poorCount = poorCount;
this.luckyPoorCount = luckyPoorCount;
setPoor();
}
//填充獎池
private void setPoor()
{
/*
怎麼做?
1.根據poorCount創建數組,
2.將1~poorCount填充數組,
*/
int[] arr = new int[poorCount];
for(int i=0; i<poorCount; i++)
arr[i] = i+1; //37個數字
poor = arr;
luckPoor = new int[luckyPoorCount];
}
public void run()
{
//搖出所有的中獎號碼放在中獎池中
setLuckyPoor();
//輸出所有的中獎號碼
listLuckyPoor();
}
//獲得所有的中獎號碼~~
public void setLuckyPoor()
{
//1.定義循環,循環次數是luckyPoorCount
for(int i=0; i<luckyPoorCount; i++)
{
//1.產生一個隨機的中獎號碼
int luckyNumber = getLuckyNumber();
//2.將中獎號碼從裏面刪除
deleteNumber(luckyNumber);
//3.將中獎號碼放在獎池中
luckPoor[i] = luckyNumber;
}
}
private int getLuckyNumber()
{
int randomNum = new Random().nextInt(poor.length);
return poor[randomNum];
}
private void deleteNumber(int luckyNumber)
{
int[] newArr = new int[poor.length-1];
int pos = 0;
for(int i=0; i<poor.length; i++)
{
if(poor[i] == luckyNumber)
continue;
newArr[pos++] = poor[i]; //幸運的數字
}
poor = newArr;
}
private void listLuckyPoor()
{
StringBuffer sb = new StringBuffer();
for(int num : luckPoor)
sb.append(num +" ");
System.out.println("中獎的號碼爲：");
System.out.println(sb);
}
}
public class Demo11
{
public static void main(String[] args)
{
Lottery lottery = new Lottery(36,7);
lottery.run();
}
}
