------- android培訓、java培訓、期待與您交流！ ----------
內部類（嵌套類、內置類）
一、內部類的訪問規則：
1，內部類可以直接訪問外部類中的成員，包括私有。
之所以可以直接訪問外部類中的成員，是因爲內部類中持有了一個外部類的引用，格式外部類名.this
2，外部類要訪問內部類，必須建立內部類對象。
class Outer
{
privateint x = 3;
classInner//內部類
{
//intx = 4;
voidfunction()
{
//intx = 6;
System.out.println("innner:"+Outer.this.x);
}
}
voidmethod()
{
Innerin = new Inner();
in.function();
}
}
class InnerClassDemo
{
publicstatic void main(String[] args)
{
Outerout = new Outer();
out.method();
//直接訪問內部類中的成員。
// Outer.Innerin = new Outer().new Inner();
// in.function();
}
}
二、訪問格式：
1,當內部類定義在外部類的成員位置上，而且非私有，可以在外部其他類中。
可以直接建立內部類對象。
格式
外部類名.內部類名 變量名 = 外部類對象.內部類對象;
Outer.Innerin = new Outer().new Inner();
2,當內部類在成員位置上，就可以被成員修飾符所修飾。
比如，private：將內部類在外部類中進行封裝。
static:內部類就具備static的特性。
當內部類被static修飾後，只能直接訪問外部類中的static成員。出現了訪問侷限。
在外部其他類中，如何直接訪問static內部類的非靜態成員呢？
newOuter.Inner().function();
在外部其他類中，如何直接訪問static內部類的靜態成員呢？
uter.Inner.function();
注意：當內部類中定義了靜態成員，該內部類必須是static的。
當外部類中的靜態方法訪問內部類時，內部類也必須是static的。
當描述事物時，事物的內部還有事物，該事物用內部類來描述。
因爲內部事務在使用外部事物的內容。
class Body
{
privateclass XinZang
{
}
publicvoid show()
{
newXinZang().
}
}
*/
class Outer
{
privatestatic int x = 3;
staticclass Inner//靜態內部類
{
staticvoid function()
{
System.out.println("innner:"+x);
}
}
staticclass Inner2
{
voidshow()
{
System.out.println("inner2show");
}
}
publicstatic void method()
{
//Inner.function();
newInner2().show();
}
}
class InnerClassDemo2
{
publicstatic void main(String[] args)
{
Outer.method();
//Outer.Inner.function();
//newOuter.Inner().function();
//直接訪問內部類中的成員。
// Outer.Innerin = new Outer().new Inner();
// in.function();
}
}
三、
內部類定義在局部時，
1，不可以被成員修飾符修飾
2，可以直接訪問外部類中的成員，因爲還持有外部類中的引用。
但是不可以訪問它所在的局部中的變量。只能訪問被final修飾的局部變量。
class Outer
{
intx = 3;
voidmethod(final int a)
{
finalint y = 4;
classInner
{
voidfunction()
{
System.out.println(y);
}
}
newInner().function();
}
}
class InnerClassDemo3
{
publicstatic void main(String[] args)
{
Outerout = new Outer();
out.method(7);
out.method(8);
}
}
四、在內部類中：內部類局部變量訪問有x、內部類成員變量訪問用this.x、外部類成員變量訪問用外部類.this.x。
五、匿名內部類:
1，匿名內部類其實就是內部類的簡寫格式。
2，定義匿名內部類的前提：
內部類必須是繼承一個類或者實現接口。
3，匿名內部類的格式： new 父類或者接口(){定義子類的內容}
4，其實匿名內部類就是一個匿名子類對象。而且這個對象有點胖。 可以理解爲帶內容的對象。
5，匿名內部類中定義的方法最好不要超過3個。
abstract class AbsDemo
{
abstractvoid show();
}
class Outer
{
intx = 3;
/*
classInner extends AbsDemo
{
intnum = 90;
voidshow()
{
System.out.println("show:"+num);
}
voidabc()
{
System.out.println("hehe");
}
}
*/
publicvoid function()
{
//AbsDemoa = new Inner();
// Innerin = new Inner();
// in.show();
// in.abc();
AbsDemod = new AbsDemo()
{
intnum = 9;
voidshow()
{
System.out.println("num==="+num);
}
voidabc()
{
System.out.println("haha");
}
};
d.show();
//d.abc();//編譯失敗;
}
}
class InnerClassDemo4
{
publicstatic void main(String[] args)
{
newOuter().function();
}
}
異常
對於問題的劃分：兩種：一種是嚴重的問題，一種非嚴重的問題。
對於嚴重的，java通過Error類進行描述。
對於Error一般不編寫針對性的代碼對其進行處理。
對與非嚴重的，java通過Exception類進行描述。
對於Exception可以使用針對性的處理方式進行處理。
無論Error或者Exception都具有一些共性內容。
比如：不正常情況的信息，引發原因等。
Throwable
|--Error
|--Exception
2,異常的處理
java 提供了特有的語句進行處理。
try
{
需要被檢測的代碼；
}
catch(異常類變量)
{
處理異常的代碼；(處理方式)
}
finally
{
一定會執行的語句；
}
3，對捕獲到的異常對象進行常見方法操作。
StringgetMessage()：獲取異常信息。
*/
class Demo
{
intdiv(int a,int b)throws Exception//在功能上通過throws的關鍵字聲明瞭該功能有可能會出現問題。
{
returna/b;
}
}
class ExceptionDemo
{
publicstatic void main(String[] args)
{
Demod = new Demo();
try
{
intx = d.div(4,1);
System.out.println("x="+x);
}
catch(Exception e)//Exception e = new ArithmeticException();
{
System.out.println("除零啦");
System.out.println(e.getMessage());// / by zero;
System.out.println(e.toString());//異常名稱：異常信息。
e.printStackTrace();//異常名稱，異常信息，異常出現的位置。
//其實jvm默認的異常處理機制，就是在調用printStackTrace方法。
//打印異常的堆棧的跟蹤信息。
}
System.out.println("over");
}
}
對多異常的處理。
1，聲明異常時，建議聲明更爲具體的異常。這樣處理的可以更具體。
2，對方聲明幾個異常，就對應有幾個catch塊。不要定義多餘的catch塊。
如果多個catch塊中的異常出現繼承關係，父類異常catch塊放在最下面。
建立在進行catch處理時，catch中一定要定義具體處理方式。
不要簡單定義一句 e.printStackTrace(),
也不要簡單的就書寫一條輸出語句。
*/
class Demo
{
intdiv(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//在功能上通過throws的關鍵字聲明瞭該功能有可能會出現問題。
{
int[]arr = new int[a];
System.out.println(arr[4]);
returna/b;
}
}
class ExceptionDemo2
{
publicstatic void main(String[] args) //throws Exception
{
Demod = new Demo();
try
{
intx = d.div(5,0);
System.out.println("x="+x);
}
catch(Exceptione)
{
System.out.println("hahah:"+e.toString());
}
catch (ArithmeticException e)
{
System.out.println(e.toString());
System.out.println("被零除了!!");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println(e.toString());
System.out.println("角標越界啦！！");
}
/**/
System.out.println("over");
}
}
因爲項目中會出現特有的問題，
而這些問題並未被java所描述並封裝對象。
所以對於這些特有的問題可以按照java的對問題封裝的思想。
將特有的問題。進行自定義的異常封裝。
自定義異常。
需求：在本程序中，對於除數是-1，也視爲是錯誤的是無法進行運算的。
那麼就需要對這個問題進行自定義的描述。
當在函數內部出現了throw拋出異常對象，那麼就必須要給對應的處理動作。
要麼在內部try catch處理。
要麼在函數上聲明讓調用者處理。
一般情況在，函數內出現異常，函數上需要聲明。
發現打印的結果中只有異常的名稱，卻沒有異常的信息。
因爲自定義的異常並未定義信息。
如何定義異常信息呢？
因爲父類中已經把異常信息的操作都完成了。
所以子類只要在構造時，將異常信息傳遞給父類通過super語句。
那麼就可以直接通過getMessage方法獲取自定義的異常信息。
自定義異常：
必須是自定義類繼承Exception。
繼承Exception原因：
異常體系有一個特點：因爲異常類和異常對象都被拋出。
他們都具備可拋性。這個可拋性是Throwable這個體系中獨有特點。
只有這個體系中的類和對象纔可以被throws和throw操作。
throws和throw的區別
throws使用在函數上。
throw使用在函數內。
throws後面跟的異常類。可以跟多個。用逗號隔開。
throw後跟的是異常對象。
*/
class FuShuException extends Exception//getMessage();
{
privateint value;
FuShuException()
{
super();
}
FuShuException(Stringmsg,int value)
{
super(msg);
this.value= value;
}
publicint getValue()
{
returnvalue;
}
}
class Demo
{
intdiv(int a,int b)throws FuShuException
{
if(b<0)
thrownew FuShuException("出現了除數是負數的情況------ / by fushu",b);//手動通過throw關鍵字拋出一個自定義異常對象。
returna/b;
}
}
class ExceptionDemo3
{
publicstatic void main(String[] args)
{
Demod = new Demo();
try
{
intx = d.div(4,-9);
System.out.println("x="+x);
}
catch(FuShuException e)
{
System.out.println(e.toString());
//System.out.println("除數出現負數了");
System.out.println("錯誤的負數是："+e.getValue());
}
System.out.println("over");
}
}
/*
class Throwable
{
privateString message;
Throwable(Stringmessage)
{
this.message= message;
}
publicString getMessage()
{
returnmessage;
}
}
class Exception extends Throwable
{
Exception(Stringmessage)
{
super(message);
}
}
class Person
{
Stringname;
Person(Stringname)
{
this.name= name;
}
publicString getName()
{
returnname;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}
new Sttdent("lisi").getName();
/*
Exceptoin中有一個特殊的子類異常RuntimeException運行時異常。
如果在函數內容拋出該異常，函數上可以不用聲明，編譯一樣通過。
如果在函數上聲明瞭該異常。調用者可以不用進行處理。編譯一樣通過；
之所以不用在函數聲明，是因爲不需要讓調用者處理。
當該異常發生，希望程序停止。因爲在運行時，出現了無法繼續運算的情況，希望停止程序後，
對代碼進行修正。
自定義異常時：如果該異常的發生，無法在繼續進行運算，
就讓自定義異常繼承RuntimeException。
對於異常分兩種：
1，編譯時被檢測的異常。
2，編譯時不被檢測的異常(運行時異常。RuntimeException以及其子類)
*/
class FuShuException extendsRuntimeException
{
FuShuException(Stringmsg)
{
super(msg);
}
}
class Demo
{
intdiv(int a,int b)throws Exception//throws ArithmeticException
{
if(b<0)
thrownew Exception("出現了除數爲負數了");
if(b==0)
thrownew ArithmeticException("被零除啦");
returna/b;
}
}
class ExceptionDemo4
{
publicstatic void main(String[] args)
{
Demod = new Demo();
intx = d.div(4,-9);
System.out.println("x="+x);
System.out.println("over");
}
}
/*
class Person
{
publicvoid checkName(String name)
{
//if(name.equals("lisi"))//NullPointerException
if("lisi".equals(name))//if(name!=null&& name.equals("lisi"))
System.out.println("YES");
else
System.out.println("no");
}
}
main()
{
Personp = new Person();
p.checkName(null);
}
*/
異常：
是什麼？是對問題的描述。將問題進行對象的封裝。
------------
異常體系：
Throwable
|--Error
|--Exception
|--RuntimeException
異常體系的特點：異常體系中的所有類以及建立的對象都具備可拋性。
也就是說可以被throw和throws關鍵字所操作。
只有異常體系具備這個特點。
--------------
throw和throws的用法：
throw定義在函數內，用於拋出異常對象。
throws定義在函數上，用於拋出異常類，可以拋出多個用逗號隔開。
當函數內容有throw拋出異常對象，並未進行try處理。必須要在函數上聲明，都在編譯失敗。
注意，RuntimeException除外。也就說，函數內如果拋出的RuntimeExcpetion異常，函數上可以不用聲明。
--------------
如果函數聲明瞭異常，調用者需要進行處理。處理方法可以throws可以try。
異常有兩種：
編譯時被檢測異常
該異常在編譯時，如果沒有處理(沒有拋也沒有try)，編譯失敗。
該異常被標識，代表這可以被處理。
運行時異常(編譯時不檢測)
在編譯時，不需要處理，編譯器不檢查。
該異常的發生，建議不處理，讓程序停止。需要對代碼進行修正。
--------------
異常處理語句：
try
{
需要被檢測的代碼；
}
catch ()
{
處理異常的代碼；
}
finally
{
一定會執行的代碼；
}
有三個結合格式：
1. try
{
}
catch()
{
}
2. try
{
}
finally
{
}
3. try
{
}
catch()
{
}
finally
{
}
注意：
1，finally中定義的通常是關閉資源代碼。因爲資源必須釋放。
2，finally只有一種情況不會執行。當執行到System.exit(0);fianlly不會執行。
--------------
自定義異常：
定義類繼承Exception或者RuntimeException
1,爲了讓該自定義類具備可拋性。
2，讓該類具備操作異常的共性方法。
當要定義自定義異常的信息時，可以使用父類已經定義好的功能。
異常異常信息傳遞給父類的構造函數。
classMyException extends Exception
{
MyException(Stringmessage)
{
super(message);
}
}
自定義異常：按照java的面向對象思想，將程序中出現的特有問題進行封裝。
--------------
異常的好處：
1，將問題進行封裝。
2，將正常流程代碼和問題處理代碼相分離，方便於閱讀。
異常的處理原則：
1，處理方式有兩種：try 或者 throws。
2，調用到拋出異常的功能時，拋出幾個，就處理幾個。
一個try對應多個catch。
3，多個catch，父類的catch放到最下面。
4，catch內，需要定義針對性的處理方式。不要簡單的定義printStackTrace，輸出語句。
也不要不寫。
當捕獲到的異常，本功能處理不了時，可以繼續在catch中拋出。
try
{
thrownew AException();
}
catch(AException e)
{
throwe;
}
如果該異常處理不了，但並不屬於該功能出現的異常。
可以將異常轉換後，在拋出和該功能相關的異常。
或者異常可以處理，當需要將異常產生的和本功能相關的問題提供出去，
當調用者知道。並處理。也可以將捕獲異常處理後，轉換新的異常。
try
{
thrownew AException();
}
catch(AException e)
{
//對AException處理。
thrownew BException();
}
比如，匯款的例子。
異常的注意事項：
在子父類覆蓋時：
1，子類拋出的異常必須是父類的異常的子類或者子集。
2，如果父類或者接口沒有異常拋出時，子類覆蓋出現異常，只能try不能拋。
（類類型的對象在堆內存中默認值爲空（null）。）
class
{
publicstatic void main(String[] args)
{
intx = 0;
try
{
x= 4;
}
catch()
{
}
finally
{
System.out.println("x="+x);
}
}
}
包package
特點：對類文件分類管理。
給類提供多種命名空間。
寫在程序文件首行。
定義包格式：package pack//包名要小些；
javac –d file ClassName.java:把編譯出來的class文件放進去當前文件夾下file文件夾中（當然也可以寫絕對路徑c:/name/file等等放在這些包中），如果ClassName .java文件中寫package a，那麼還會在file文件夾中中創建a包並把編譯出來的文件放進去。
如果寫成javac –d . ClassName.java: 把編譯出來的class文件放進去當前文件夾(.代表當前)下,如果ClassName.java文件中寫package a，那麼還會在當前文件夾中創建a包並把編譯出來的文件放進去。
第一種：運行時要cd 進入到file文件夾下運行，運行時要用java 包名.類名；
第二種：運行時在當前文件夾下要用java 包名.類名；
注意：當出現包時類的全名就是——包名.類名。
包與包之間的訪問
包與包之間的訪問，被訪問的類和成員要有public修飾。
protected//保護權限。
當不在同一個包的父類和子類，子類可以訪問到父類protected修飾的成員，包與包訪問可以使用的權限只有兩種——public和protected；
|
訪問控制 |
private成員 |
缺省的成員 |
protected成員 |
public成員 |
|
同一類中成員 |
Ö |
Ö |
Ö |
Ö |
|
同一包中其他類 |
× |
Ö |
Ö |
Ö |
|
不同包中子類 |
× |
× |
Ö |
Ö |
|
不同包中非子類 |
× |
× |
× |
Ö |
同一個文件夾下不能存在兩個以上的公有類或接口。
如果同一個包中的兩個類都要被別的包裏的類訪問，那麼這兩個類要放在不同文件中。因爲在一個文件中不可以有兩個public修飾的類。
導入（import）
importpackage*；//導入package包中的是所有類。
當導入不同包中類出現重名時要用——包名.類。
定義包名不要重名，可以用url格式來寫：package cn.itcast.demo;
package cn.itcast.test;
導包只爲簡化類名的書寫。
jar包
工具：jar.exe。
例子：將Foo.class Bar.class類文件歸檔到一個名爲class.jar的歸檔文件中：
jar cvfclass.jar Foo.class Bar.class(當然包也可以歸檔)。
jar –t class.jar:可以列出並查看class.jar下的目錄文件。其中有個配置文件目錄，其中有配置文件可以改動。
jar –tf a.jar >c:\2.txt:把輸出的信息寫在2.txt文件中。
jar –tvf a.jar只是在dos中顯示
例子：dir >c:\2.txt:在2.txt中列出當前目錄結構。
------- android培訓、java培訓、期待與您交流！ ----------詳細請查看：http://edu.csdn.net