------- android培訓、java培訓、期待與您交流！ ----------
1：面向對象
(1)面向過程 強調過程，執行者(2)面向對象 強調對象，指揮者
(3)面向對象思想的特點
A：它是一種更符合人們思考習慣的思想
B：它是複雜的內容簡單化
C：它使我們從執行者變成了指揮者
請解釋面向對象的思想？
定義一：面向對象方法是一種運用對象、類、封裝、繼承、多態和消息等概念來構造、測試、重構軟件的方法。
定義二：面向對象方法是以認識論爲基礎，用對象來理解和分析問題空間，並設計和開發出由對象構成的軟件系統
（解空間）的方法。 由於問題空間和解空間都是由對象組成的，這樣可以消除由於問題空間和求解空間結構上的不
一致帶來的問題。簡言之，面向對象就是面向事情本身，面向對象的分析過程就是認識客觀世界的過程。
面向對象方法從對象出發，發展出對象，類，消息，繼承等概念。
面向對象方法的主要優點是：符合人們通常的思維方式；從分析到設計再到編碼採用一致的模型表示具有高度連續性；
軟件重用性好。
(4)面向對象的特點
A：封裝
B：繼承
C：多態
2：類和對象
(1)類 對現實世界中事物的描述(屬性和方法)Person p = new Person();String name,int age
(2)對象 現實世界中實際存在具體的個體
(3)對象的使用以及內存圖 new
3：局部變量和成員變量
(1)作用範圍
局部變量：方法內
成員變量：類中，對整個類有效
(2)存儲空間
局部變量：棧內存
成員變量：堆內存
(3)初始化值
局部變量：在使用前必須手動給值
成員變量：jvm默認初始化值。
class Person {
int num;
public void method(){
int age ;
//age = 10;
System.out.println(num);
}
}
4：匿名對象的使用(瞭解)
(1)當對對象中的功能只執行一次的時候使用。否則，請你使用有名字的對象。
Person p = new Person();
p.show();
p.show();
p.print();
new Person().show();
new Person().show();
new Person().print();
method(new Person());
(2)用於作爲實際參數進行傳遞。
method(Person pp){}//method(p);//地址值
method(new Person());//地址值
method(p);
public static void method(Person p){}
(3)是否可以用匿名對象調用屬性,是否有意義?
4：封裝
(1)封裝的好處：便於重複使用，安全性高。
(2)private權限修飾符
class Demo{
private int age;//把屬性私有對外提供公共的訪問方法,可控性提高了
public void setAge(int age){//age = -20;
if(age>=0 && age<=200){
this.age = age;
}
else {
System.out.println("請回火星");
}
}
public int getAge(){
return age;
}
}
class DemoTest{
public static void main(String[] args) {
Demo d = new Demo();
d.setAge(-20);
System.out.println(d.getAge());
}
}
5：構造函數
class Person{
int age;
Person(int age){}
}
(1)用途：用於給對象進行初始化。
A：格式類名(){code}Person(){}
B：Person(){}public Person(){}
(2)特點 你不定義空參數的構造函數，系統會自動給一個空參構造，你定義了構造函數無論是有參還空參的，
系統就不再給空參數的了。
(3)重載構造函數,是根據參數列表來區分是哪個構造函數
A：Person(){}//Person p = new Person();
B：Person(int age,String name){}
C：Person(int age){}
D：Person(String name,int age){}
注意：構造還可以用於給屬性賦值。
class Person{
int age;
String name;
Person(){}
Person(int age,String name) {//age = 20,name = "zhangsan";
this.age = age;
this.name = name;
}
public void speak(){
System.out.println(age + "....." + name);
}
}
class Demo{
public static void main(String[] args) {
//Person p = new Person(20,"zhangsan");
Person p = new Person();
p.speak();
}
}
6：this關鍵字
(1)代表當前對象的引用。使用的時候，誰調用方法，this就代表誰。
(2)什麼時候使用this呢？
A：當局部變量和成員變量重名的時候,可以用this進行區分。
B：寫功能的時候，可能用到this。比如比較兩個對象的年齡compare()
C：構造函數中使用this
**this() 必須放在第一行。
同下面的道理：
Person(String name){
this.name = name;
}
Person(String name,int age){
this("張三");//是找帶一個字符串類型參數的構造方法
this.name = name;
this.age = age;
//this("zhangsan");
}
Person p = new Person("lisi",20);
7:代碼塊
(1)局部代碼塊 控制變量的生命週期{int x}
(2)構造代碼塊 每創建一次對象就執行一次。
(3)思考下面的問題
Person p = new Person();
它在內存中做了哪些事情？
A：將Person.class文件加載到內存中。
B：在棧內存中聲明Person類型的變量P。
C：在堆內存中創建一個對象Person。分配地址值
D：把Person中的屬性進行默認初始化。
E：把Person中的屬性進行顯示初始化。
F：調用構造代碼塊(如果沒有，不執行這個操作)。
G：調用構造函數進行初始化。
H：把堆內存的地址(引用)賦給了棧內存中P。
public void method() {
{
int x = 10;
System.out.println(x);
}
}
class Person{
{
System.out.println("你好");
}
}
Person p = new Person();
1：static關鍵字
(1)靜態的意思。可以修飾類的成員(成員變量和成員方法);
(2)靜態成員的特點：
A：隨着類的加載而加載，生命週期最長。
B：優先於對象存在。javac Demo 生成Demo.class java Demo{ Demo d = new Demo();
}
C：被所有的對象所共享。
D：比非靜態成員多了一種訪問方式。可以通過類名直接調用。
(3)什麼時候需要使用static修飾呢？
當類中的成員需要被所有對象共享時，用static修飾。不需要被共享時，就不用static修飾。
簡單說：共性用static修飾，特性不用static修飾。
(4)注意事項
A：靜態方法只能訪問靜態成員的。
B：靜態方法中不能使用this,super關鍵字。
C：main是靜態的。
**格式如下：
public static void main(String[] args){
}
***由於它被jvm調用，所以權限要足夠大，所以用public權限修飾符。
***爲了jvm可以不用創建對象直接調用它，所以用static修飾。
***void jvm不需要任何返回。但是方法體結尾默認有return;
***main jvm只認識這個名字。
***String[] 有可能需要傳入參數。
***args 字符串數組的名字，爲了方便使用。
(5)靜態代碼塊
類中加載流程？
靜態代碼塊--構造代碼塊--構造方法。
2：靜態的應用
工具類ArrayTool
因爲使用的都是class文件。所以你應該先編譯ArrayTool，然後在編譯ArrayToolDemo，最後執行ArrayToolDemo。
但是如果引用的工具類特別多的情況下，這樣就很麻煩，所以java提供好的方式：只編譯ArrayToolDemo即可。
(其實它首先在classpath下找ArrayTool.class，如果沒有，接下來在當前類下找ArrayTool.class文件。
如果還沒有，它就會找ArrayTool.java文件，並且進行編譯。如果都沒有，就報錯。)
製作工具說明書:代碼中有文檔註釋,用javadoc解析。
javadoc -d myAPI -author -version ArrayTool.java
-d 後面跟目錄
ArrayTool.java 源代碼文件
javadoc: 錯誤 - 找不到可以文檔化的公共或受保護的類。
改用public修飾一下即可
3：API(Application programming Interface)：應用程序編程接口。
JavaAPI:java的幫助文檔。
4：設計模式
java中有23種設計。
單例設計模式：保證類在內存中只有一個對象。
如何保證類在內存中只有一個對象呢？
(1)控制類的創建，不讓其他類來創建本類的對象。private
(2)在本類中定義一個本類的對象。Single s;
(3)提供公共的訪問方式。 public static Single getInstance(){return s}
單例寫法兩種：
(1)餓漢式 開發用這種方式。
class Single{
private Single(){
}
static Single s = new Single();
public static Single getInstance(){
return s;
}
}
(2)懶漢式 面試寫這種方式。多線程的問題？
class Single {
private Single(){}
private static Single s;
public static Single getInstance(){
if(s==null){
s = new Single();
}
return s;
}
}
class Single{
private int num = 10;
private static Single s = new Single();
private Single(){
}
public static Single getInstance(){
return s;
}
public void setNum(int num){
this.num = num;
}
public int getNum(){
return this.num;
}
}
class SingleDemo {
public static void main(String[] args) {
Single s = Single.getInstance();
Single s1 = Single.getInstance();
//System.out.println(s==s1);
s.setNum(10);
s1.setNum(20);
System.out.println(s.getNum());
System.out.println(s1.getNum());
}
}
1：繼承(extends)
(1)繼承的體系結構：就是對要描述的事物進行不斷的向上抽取，就出現了體系結構。
**要了解這個體系結構中最共性的內容,就看最頂層的類。
**要使用這個體系的功能,就用最底層的類創建對象。
(2)繼承的好處：
A：繼承的出現，提高了代碼的複用性。
B：繼承的出現，讓類與類之間產生了關係，extends來表示，
這個關係的出現，爲後面我們講面向對象的第三個特點多態打下了基礎。
(3)特點
A：java只支持單繼承(其實確切的說是java對多繼承進行了優化，避免了安全問題)。
B：java支持多重(層)繼承。
(4)注意：
A：子類可以直接訪問父類中的非私有的屬性和行爲。
B：不要僅爲了獲取其他類中部分功能而去繼承。
C：類與類之間要有所屬( " is a " )關係，xx1是xx2的一種。
**如何判斷A和B是否有繼承關係？
**A如果繼承B，那麼就可以說A是B的一種。
2：繼承後子父類之間成員的關係
(1)成員變量
class Fu{
int num1 = 5;
}
class Zi extends Fu{
int num1 = 20;
public void show() {
int num1 = 30;
System.out.println("num1:"+num1);
//當局部變量和成員變量重名的時候用this來區分
System.out.println("this num1:"+this.num1);
//當子類和父類出現了同名變量,用super來區分
System.out.println("father num1:"+super.num1);
}
}
總結:在一個類中如果方法中的局部變量和方法外的成員變量重名,那麼如果在方法內輸出這變量,就是方法
自己的變量裏的值,想要區分要用this,加上this.就是輸出成員變量的值
在子父類中如果出現成員變量重名的時候,在子類輸出會輸出自己的變量裏的值,想要區分要用super,
加上super.就是輸出父類裏變量的值
this和super的區分：
**this代表本類對象的引用
super本類對象父類的引用。
**this可以用於區分局部變量和成員變量同名的情況。
super可以用於區分子類和父類成員變量同名的情況。
**一般，子類中不會出現和父類同名的成員變量。面試可能問到。
(2)成員方法
class Fu {
public void show() {
System.out.println("fu show");
}
}
class Zi extends Fu{
/*public void show(){
System.out.println("zi show");
}*/
public void show(){
System.out.println("zi show1");
}
}
子類中存在和父類成員方法同名的這種現象，叫做重寫，複寫，覆蓋。
重寫(override)和重載(overload)的區別：
重載的特點：
**在同一類中。
**方法名相同，參數列表不同。
重寫的特點：
**要有繼承關係。在子父類中
**方法的聲明相同。(方法名和參數列表都相同)
***覆蓋時，子類方法權限一定要大於等於父類方法權限
***靜態只能覆蓋靜態。
(3)構造方法
class Fu{
//Fu(){}
Fu(int age){//age = 30
System.out.println("father age:"+age);
}
}
class Zi extends Fu{
Zi(){
//this(20);
System.out.println("son");
}
Zi(int age){//age =30
super(age);
System.out.println("son age:"+age);//30
}
}
Zi z = new Zi();
Zi z = new Zi(30);
總結：子類中所有的構造方法默認都會訪問父類中空參數的構造方法。
**因爲每一個構造方法的第一行都有一條默認的語句super();
當父類中沒有空參數的構造方法時，子類的構造函數必須通過this
或者super語句指定要訪問的構造方法。或者手動提供無參構造方法。
this(...):調用本類中的構造方法
super(...):調用父類中的構造方法
構造方法用於創建對象，並進行初始化.建議如果你寫了有參的構造函數,也要把空參的構造函數再手動加上
否則你定義了有參的構造函數,空參的系統就不會再給了
你這樣創建對象的時候就會報錯Person p = new Person();//這句話是會去找空參的構造函數
class Person{
Person(){}
Person(int age){
this.age = age;
}
Person(int age,String name){
this(age);
//this.age = age;
this.name = name;
}
}
//Person p =new Person(); //系統默認給出無參構造
//當你手動給出構造方法後，系統就不會再給出默認的空的構造方法。
手動無參數，如果你想給屬性賦值或者做一些初始化，無參你別刪不就行了嗎。
class Demo{
private String name;
Demo(){}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
}
3：final可以用來修飾什麼呢？
(1)final可以用來修飾類：被fainl修飾的類不能被繼承。
(2)final可以用來修飾成員方法：被final修飾的成員方法不能被重寫。
(3)final可以用來修飾變量：被final修飾的變量爲常量，值不能被修改。
常量的命名規範：要求大寫。
final int PI = 3.14;
final難道必須聲明的時候就賦值。
一般來說，是這樣的。但是特殊情況：在構造方法可以給final修飾的變量賦值。
4：抽象類(abstract)
(1)只抽取了很多類的方法的聲明，爲了保證不出問題，方法聲明用abstract修飾。
(2)抽象類的特點
A：一個類如果有了抽象方法，那麼這個類必須是抽象類。抽象類裏邊可以沒有抽象方法。
B：抽象類是不能夠被實例化的。不能夠創建對象的。
C：如果一個類繼承抽象類，那麼，它要麼實現抽象類中的所有抽象方法，
要麼本身也是抽象類。
(3)抽象類的成員特點：
A：成員變量：子類可以直接繼承抽象類中的成員變量。(抽象類中的成員變量可以和以前是一樣的)
B：成員方法：抽象類中分爲兩種方法，一種是抽象方法，這種方法在子類中必須要被實現。
一種是普通的方法。可以被子類直接繼承使用。
C：構造方法：抽象類不能被實例化，那麼它有構造方法嗎?抽象類是class，那麼它就有構造方法。
它的構造方法有用嗎？有，爲了讓子類實例化的時候使用。
(4)舉例：教師舉例，學生舉例，員工舉例
(5)抽象類的相關問題：
A：抽象類中是否有構造函數？參照(3)裏面的C。
B：抽象關鍵字abstract不可以和哪些關鍵字共存？
**private
***私有的，外部直接無法訪問。
**static
***那麼這個時候抽象方法就可以可以通過類名調用，但是這樣是沒有意義的。
**final
***final修飾的方法不能被重寫。所以它和abstract衝突。
C：抽象類中可不可以沒有抽象方法？
**可以。如果這麼做只有一個目的不讓你創建這個類的對象
面向對象
1：解釋面向對象思想
2：封裝 private
3：局部變量和成員變量
4：構造 this
5：繼承 extends, super
6：抽象類 abstract
***類，抽象類，還是接口。
***構造方法
***學習裏面的功能。
奉勸大家:學習程序要結合着生活中的例子去理解,不要就在程序中死扣,這樣反而讓你越來越越暈,比如理解
繼承有父親有兒子,兒子從父親那裏繼承非私有的東西很正常
1：接口(interface)
(1)接口的由來：當一個類中所有的方法都是抽象的時候，你沒必要定義爲抽象類，
定義爲接口就可以了。
(2)解決了java中只能單繼承的問題。(對多繼承進行了優化)
A：類與類：只能是單繼承。 extends
B：接口與接口：可以是單繼承，也可以是多繼承。 extends
C：類與接口：可以是單實現，也可以是多實現。 implements
(3)成員特點：
A：只有成員變量和成員方法。
B：成員變量 默認修飾符 public static final
**int X = 20;
**其實是這樣的 public static final int X = 20;
C：成員方法 默認修飾符 public abstract
**void show();
**其實是這樣的 public abstract void show();
建議：爲了便於閱讀,自己手動加上修飾符。
(4)接口特點：
A：接口是對外暴露的規則
B：接口是功能的擴展
C：接口降低了程序的耦合性。
**內聚(自己實現功能的能力)
**高內聚，低耦合。
舉例：主板和CPU,USB接口,電源插座。
D：擴展說了下接口的理解
**狹義的理解就是java中的接口。
**廣義的理解就是：任何定義的規範都是接口。
(5)接口和抽象類的區別：
A：抽象類只能被單繼承；接口可以被多實現。
B：抽象類中的成員：成員變量:可以是常量，也可以是變量。
成員方法:可以是抽象的，也可以是非抽象的。
構造方法:雖然不可以創建對象，但是可以給子類實例化用。
接口中的成員：成員變量：只能是常量。默認修飾符 public static final
成員方法：只能是抽象的。默認修飾符 public abstract
C：抽象類中定義的是體系結構中的共性的內容。
接口中定義的是對象的擴展功能。
D：抽象類被繼承表示的是："is a"的關係。xx是yy中的一種。
接口被實現表示的是: "like a"的關係。xx像yy中的一種。
(6)學生：Student
A：屬性：學號,姓名,年齡
B：方法：學習(study),吃飯(抽象eat),抽菸(是不是所有的學員都抽菸呢?),
籃球(是不是所有的人都會打籃球呢?)
分析:學員都具備學習的行爲和吃飯的行爲,但是並不是所有的學員都抽菸,也不是所有的學員都打籃球
interface Smoking {
public abstract void smoking();
}
interface Sport{
public abstract void playBasketBall();
}
描述的是即會抽菸又會打籃球的學生：SmokeStudent extends Student implements Smoking,Sport
一個類只能繼承一個類,但是可以實現多個接口,每實現一個接口,功能就擴展了一部分
SmokeStudent ss = new SmokeStudent();
ss.eat();
ss.study();
ss.smoking();
ss.playBasketBall();
2：多態
(1)某一類事物的多種存在形態。
**方法重載(靜態多態)
**方法重寫(動態多態,對象多態)
(2)對象多態的前提
A：類與類(或接口)要有繼承(或實現)關係。
B：一定要有方法的重寫。
C：一定要有父類或者接口的引用指向子類的對象。Person p = new SuperMan();
SuperMan sm = (SuperMan)p;
(3)多態思想：可以指揮同一類型的一批對象做事情。多態的出現讓我們複雜的問題簡單化了。
A：Animal Cat Dog
**method(Animal a){a.eat();}//Animal a = new Cat();
(4)多態中成員的特點：(我們只研究特殊的，就是說名字一樣的東西)
Fu f = new Zi();
A：成員變量：編譯和運行都看Fu。
B：非靜態方法：編譯看Fu，運行看Zi。
C：靜態方法：編譯和運行都看Fu。
舉例： 動物的例子：
向上轉型
Animal a = new Cat();
a.eat();
//a.catchMouse();
向下轉型
Cat c = (Cat)a;
c.eat();
c.catchMouse();
//向上轉型
Animal a = new Dog();
//向下轉型 轉換異常
//Cat c = (Cat)a;
Dog d = (Dog)a;
超人的例子：
person :談生意();
SuperMan:談生意();fly();
Person p = new SuperMan();//超人沒變身之前就是普通人一個,只能調用Person裏的方法
//在運行的時候發現有SuperMan這個子類繼承了他,會去看裏面是否有和你調用Person裏相同的方法
//如果有運行就執行子類重寫的方法(成員函數的特性,覆蓋)
p.談生意();
SuperMan sm= (SuperMan)p;//內褲外穿,變身超人
sm.談生意();
sm.fly();
總結:無論是向上轉型還是向下轉型,變化的都是子類對象,絕對不能把父類對象強轉爲子類類型
1：內部類
內部類分別有:1,成員內部類2,靜態內部類3,局部內部類4,匿名內部類
(1)成員內部類
A：定義,:在一個外部類中有成員變量和成員方法,那麼成員內部類就是把整個一個類當成了外部類的成員對待了
B: 訪問方式:內部類訪問外部類,內部類可以直接訪問外部類,包括私有成員,因爲內部類擁有外部類的引用是類名.this
外部類訪問內部類,外部類訪問外部類的成員,必須要建立內部類的對象
格式:外部類名.內部類名 = 外部類對象.內部類對象;
Outer.Inner oi = new Outer().new Inner();//outer代表外部類,Inner代表內部類
C:存放位置:在外部類裏,在外部類的成員方法外.
D:修飾符:final、abstract、public、private、protected和static等,那麼被static修飾的就是下面所說的
靜態內部類.
(2)靜態內部類
A：定義,就是在成員內部類的基礎上加上static
B：格式:外部類名.內部類名 = 外部類名.內部類對象;
Outer.Inner oi = new Outer.Inner();
C:存放位置:和成員內部類一樣,就是多了個static
(3)局部內部類
A：定義,在外部類成員方法中定義的內部類,他更像局部變量
B: 注意:
第一:方法內部類只能在定義該內部類的方法內實例化，不可以在此方法外對其實例化。
第二:方法內部類對象不能使用該內部類所在方法的非final局部變量。因爲方法的局部變量位於棧上，
只存在於該方法的生命期內。當一個方法結束，其棧結構被刪除，局部變量成爲歷史。
但是該方法結束之後，在方法內創建的內部類對象可能仍然存在於堆中！
例如，如果對它的引用被傳遞到其他某些代碼，並存儲在一個成員變量內。
正因爲不能保證局部變量的存活期和方法內部類對象的一樣長，所以內部類對象不能使用它們。
第三:方法內部類的修飾符。與成員內部類不同，方法內部類更像一個局部變量。可以用於修飾方法內部類
的只有final和abstract。
第四:靜態方法內的方法內部類。靜態方法是沒有this引用的，因此在靜態方法內的內部類遭受同樣的待遇，
即：只能訪問外部類的靜態成員。
(4)匿名內部類：沒有名字的內部類。它是內部類的簡化寫法。
A：前提：內部類可以繼承或實現一個外部類或者接口。
B：格式爲：new 外部類名或者接口名(){覆蓋類或者接口中的代碼，(也可以自定義內容。)}
C：簡單理解：就是建立一個帶內容的外部類或者接口的子類匿名對象。
D: a,繼承式的匿名內部類
b,接口式(也可以叫實現式的,名字無所謂)的匿名內部類
c,參數式的匿名內部類
多加一句:我的理解,其實與其說是匿名內部類,我個人認爲說是匿名對象更確切一點(個人理解,僅供參考);
interface Inter {
public abstract void show1();
public abstract void show2();
}
//有名字的內部類
class Outer {
public void method(){
class Inner implements Inter {
public void show1(){
System.out.println("show1");
}
public void show2(){
System.out.println("show1");
}
}
}
public void show() {
Inter in = new Inner();//父類引用指向子類對象
in.show1();
in.show2();
}
}
//匿名內部類(重點,android裏面用的多,awt的監聽器用的多)
class Outer {
public void method() {
//匿名內部類對象調用方法
new Inter() {
public void show1() {
System.out.println("show1");
}
public void show2() {
System.out.println("show1");
}
}.show1();
new Inter() {
public void show1() {
System.out.println("show1");
}
public void show2(){
System.out.println("show1");
}
}.show2();
//匿名內部類對象的另一種調用方式,父類引用指向子類對象
Inter in = new Inter() {
public void show1() {
System.out.println("show1");
}
public void show2() {
System.out.println("show1");
}
};
in.show1();
in.show2();
}
}
(5)什麼時候使用匿名內部類呢？
A：通常在使用方法是接口類型參數，並該接口中的方法不超過三個時，
可以將匿名內部類作爲參數傳遞。
2：異常
(1)就是程序運行過程中，遇到了問題，這就叫異常。
(2)異常的體系
Throwable 其實應該分三種
Error
通常出現重大問題如：運行的類不存在或者內存溢出等。
不編寫針對代碼對其處理。
Exception
除了 RuntimeException 和其所有子類,其他所有的異常類都是在編譯的時候必須要處理的
要麼try,要麼拋
RuntimeException
RuntimeException 和其所有的子類,都不會在編譯的時候報異常,而是在運行時報異常,這時候我們
就需要回頭看看我們的代碼是否有問題,比如角標越界,空指針等
(3)Throwable
A：getMessage() ：返回此 throwable 的詳細消息字符串。
class Throwable {
String detailMessage;
Throwable(){}
Throwable(String message) {
this.detailMessage = message;
}
public String getMessage() {
return detailMessage;
}
}
B：toString()：獲取異常類名和異常信息，返回字符串。
C：printStackTrace()：獲取異常類名和異常信息，以及異常出現在程序中的位置。返回值void。
(4)處理異常處理方式：
A：try...catch...finally
格式：
try {
需要檢測的代碼；
}
catch(異常類 變量) {
異常處理代碼；
}
...
finally {
一定會執行的代碼；
}
可以有下面三種搭配形式：
**try...catch(...)
**try...finally
**try...catch(...)...finally
B：拋出 throws throw
throws:用於標識函數暴露出的異常。thorws用在函數上，後面跟異常類名(可以由多個，用,隔開)。
throw:用於拋出異常對象。throw用在函數內，後面跟異常對象。new Exception();
C：到底用誰？
**你能處理，建議處理。try...catch...finally
**你處理不了，拋出。
D：自定義異常
自定義類繼承Exception或者其子類(RuntimeException)
class MyException extends Exception{
MyException(){}
MyException(Stirng message){
super(message); //將信息傳遞給父類,調用父類封裝好的構造方法
}
}
class Student {
public void giveAge(int age) throws MyException {
if(age>40 || age<0) {
//throw new MyExcetpion("建議不學了");
MyExcepiont my = new MyExcetpion("建議不學了");
throw my;
}
else {
System.out.println("可以學習Java");
}
}
}
E：RuntimeException和Exception
區別：RuntimeException就是要你改代碼的。你可以不處理。
1：包
(1)包：package
A：對類文件進行分類管理
B：給類提供多層命名空間
C：放在程序代碼的第一行(註釋除外)
(2)訪問：先得有包，然後:包.類名
如何解決手動創建包的問題呢？
javac -d xxx PackageDemo.java
-d 後面跟的是：目錄
當前目錄：.
(3)不同包之間類的訪問
類一定要用全路徑名稱:包名.類名
2：protected
包之間的繼承關係。
3：import
簡化類名。
一個程序文件中只有一個package，可以有多個import。
用來導包中的類，不導入包中的包。
通常寫import mypack.Demo;
而不寫import mypack.*;爲什麼？
4：權限修飾符
同一個類中 同一個包中 不同包中子類中 不同包中，不存在繼承關係
private OK
默認 OK Ok
protected Ok Ok Ok
public OK Ok OK OK
特殊：private和static可以修飾內部類。
static可以代碼塊。靜態代碼塊。
A：四種訪問權限修飾符任意時刻只能使用一種。
B：static,private,final 不能和abstract並用。
6：jar
(1)打包：
jar -cf haha.jar packa
(2)查看jar包
jar -xvf haha.jar
(3)如果內容特別多，好幾個屏幕都放不下，
我們能夠通過dos命令，講這些目錄寫入到一個記事本中。數據重定向。dos的命令
jar -tf haha.jar > c:\a.txt