內部類：
將一個類定義在另一個類里面，稱里面那個類為內部類。
舉例：
class Zx
{
public static void main(String []arr)
{
Outer ?o = new Outer();
o.method();
}
}
class Outer
{
class Inner //內部類，可以定義多個內部類
{
void function()
{
System.out.println("inner:"+x);
}
}
int x=3;
void method()
{
System.out.println(x);
Inner in = new Inner();
in.function();
}
}
直接訪問內部類中的成員：
可以在main()中 寫 Outer.inner in = new Outer().new Inner(); ?//內部類可以被私有化，外部類不能，私有化之后不可以這樣寫了。
內部類訪問規則
1，內部類可以直接訪問外部類中的成員，包括私有。
之所以可以直接訪問外部類中的成員，是因為內部類中持有了一個外部類的引用，格式為:外部類.this.變量名。
2，外部類要訪問內部類必須建立內部類對象。
訪問格式：
1，當內部類定義在外部類的成員位置上，而且非私有，可以在外部其他類中。
可以直接建立內部類對象 ，
格式 Outer.inner in = new Outer().new Inner();
2,當內部類在成員位置上，就可以被成員修飾符修飾。
比如，private:將內部類在外部類中進行封裝
static:內部類就具備了靜態的特性。//無法訪問非靜態變量，只能訪問外部類中的靜態成員，優先于對象存在。
內部類定義原則
當描述事物時，事物的內部還有事物，該事物用內部類來描述，因為內部事物在使用外部事物的內容。
class Body
{
private class XinZang
{
}
public void show()
{
new XinZang();
}
}
定義在方法內部的內部類，即不是成員位置
1，不可以被靜態和私有修飾，仍然可以訪問外部類成員變量，因為還持有外部類中的引用
class Zx
{
public static void main(String []arr)
{
new Outer().method();
}
}
class Outer
{
int x=3;
void method()
{
class Inner//不可以被靜態和私有修飾，仍然可以訪問外部類成員變量
{
void function()
{
System.out.println(x);
}
}
new Inner().function();
}
}
2，但是不可訪問他所在的局部變量，只能訪問被final修飾的局部不看了，如method中 int個y，不可與訪問y
匿名內部類
1，其實是內部類簡寫格式。
2，定義匿名內部類的前提
內部類必須是繼承一個類或者實現接口。
3，匿名內部類格式： new 父類或者接口()
{
定義子類的內容
}
4，其實匿名內部類就是一個匿名子類對象，而且對象有點胖，帶內容的對象。
5，匿名內部類中定義的方法最好不要超過三個。
舉例
原來：
class Zx
{
public static void main(String []arr)
{
new Outer().function();
}
}
abstract class A
{
abstract void show();
}
class Outer
{
int x=3;
class Inner extends A
{
void show()
{
System.out.println("show"+x);
}
}
public void function()
{
new Inner().show();
}
}
修改匿名后：
class Zx
{
public static void main(String []arr)
{
new Outer().function();
}
}
abstract class A
{
abstract void show();
}
class Outer
{
int x=3;
public void function()
{
new A() //A 的匿名子類對象
{
void show()
{
System.out.println("show"+x);
}
}.show();
}
}
匿名內部類練習
class Zx
{
public static void main(String []arr)
{
Test.function().method();//補全代碼，運行正常
}
}
interface Inter
{
void method();
}
class Test
{
/*
static Inter ?function()
{
return new Inter()
{
public void method()
{
System.out.println("111");
}
} ;
}
*/
}
異常
異常：程序運行時出現不正常情況。
異常由來：問題時java對問題進行描述，封裝成對象。
對于嚴重的：java通過Error類進行描述。
對于Error，一般不編寫針對性的代碼進行處理
對于非常嚴重的：java通過Exception類進行描述。
對于Exception可以提供針對性代碼進行處理
Throwable //父類
異常處理：
javc提供可特特有語句進行處理，格式：
try
{
需要被檢測的代碼
}
catch(異常類 變量)
{
處理方式
}
finally
{
一定會執行的語句
}
throws Exception //拋出問題
多異常處理
多個catch(x e)即可，x為exception的子類
并且應當把父類放在最后，以方便前面能夠精確識別異常種類
catch(Exception e)
{
}
自定義異常：
將特有的問題，java沒有封裝的異常，進行自定義。
一般情況下，函數內部出現異常，要么在函數內部進行
try
{
}
catch()
{
}
要么在函數頭throws 異常。
例如當除數是負數時，視為異常情況。
class Zx
{
public static void main(String []arr) throws Fushu \\!!
{
System.out.print(new Demo().div(3, 44));
}
}
class Fushu extends Exception
{
private String msg;
void Fushu(String msg)
{
this.msg=msg;
}
public String getMessage()
{
return msg;
}
}
class Demo
{
int div(int a,int b) throws Fushu
{
if (b<0)
throw new Fushu("出現了負數的情況");//手動通過throw拋出異常對象 ?//!!自定義異常
return a/b;
}
}
包
原來對類文件進行管理
可以有多層包目錄
package org.crazyit.net;把類存放在該文件中?org.crazyit.net
不同包中的類互相訪問。
被訪問的包中的類以及類中的成員，需要public修飾
不同包中的子類還可以直接訪問父類中被protected修飾的成員
包與包直接權限只有兩種，public protected，默認
權限區分。
public
portected
default(默認)
private
同一個類中
ok
ok
ok
ok
同一個包中
ok
ok
ok
子類
ok
ok
不同包中
ok
一個java文件中只能產生一個public類
package.類名=新類名
不同包中的類也可繼承，創建對象等等
package zxzx; //在這個包中
public class Zx { ? ? ? ? ? ?//class必須得是public 才能被外部訪問
public void show()
{
System.out.println("show ran");?//函數必須得是public 才能被外部訪問
}
}
public class ArrayTool
{
private ArrayTool (){}
public static void main(String [] arr)
{
zxzx.Zx a = new zxzx.Zx(); //package.類名 為新類名
a.show();
}
}
import
為了簡化類名的屬性
zxzx.Zx a = new zxzx.Zx(); //package.類名 為新類名
improt zxzx.Zx；將包zxzx中的Zx 導入
可以在該類中直接寫Zx a = new Zx(); 了
也可以寫
improt zxzx.*;導入zxzx包中的所有 類。
