抽象類的特點：
1，抽象方法一定在抽象類中。
2，抽象方法和抽象類都必須被abstract關鍵字修飾。
3，抽象類不可以用new創建對象。因為調用抽象方法沒意義。
4，抽象類中的抽象方法要被使用，必須由子類復寫起所有的抽象方法后，建立子類對象調用。
如果子類只覆蓋了部分抽象方法，那么該子類還是一個抽象類。
抽象類和一般類沒有太大的不同。
抽象類比一般類多個了抽象函數。就是在類中可以定義抽象方法。
抽象類不可以實例化。
特殊：抽象類中可以不定義抽象方法，這樣做僅僅是不讓該類建立對象。
abstract 關鍵字，和哪些關鍵字不能共存。
final：被final修飾的類不能有子類。而被abstract修飾的類一定是一個父類。
private: 抽象類中的私有的抽象方法，不被子類所知，就無法被復寫。
而抽象方法出現的就是需要被復寫。
static：如果static可以修飾抽象方法，那么連對象都省了，直接類名調用就可以了。
可是抽象方法運行沒意義。
抽象類中有構造函數,因為抽象類是一個父類，要給子類提供實例的初始化。
繼承：
1，提高了代碼的復用性。
2，讓類與類之間產生了關系。有了這個關系，才有了多態的特性。
注：不要為了獲取其他類的功能，簡化代碼而繼承。
必須是類與類之間有所屬關系才可以繼承。所屬關系 is a。
Java語言中：java只支持單繼承，不支持多繼承。
因為多繼承容易帶來安全隱患:當多個父類中定義了相同功能，
當功能內容不同時，子類對象不確定要運行哪一個。
但是java保留這種機制。并用另一種體現形式來完成表示。多實現。
java支持多層繼承。也就是一個繼承體系
子父類中的函數。
當子類出現和父類一模一樣的函數時，
當子類對象調用該函數，會運行子類函數的內容。
如同父類的函數被覆蓋一樣。
這種情況是函數的另一個特性：重寫(覆蓋)
當子類繼承父類，沿襲了父類的功能，到子類中，
但是子類雖具備該功能，但是功能的內容卻和父類不一致，
這時，沒有必要定義新功能，而是使用覆蓋特殊，保留父類的功能定義，并重寫功能內容。
覆蓋：
1，子類覆蓋父類，必須保證子類權限大于等于父類權限，才可以覆蓋，否則編譯失敗。
2，靜態只能覆蓋靜態。
重載：只看同名函數的參數列表。
重寫：子父類方法要一模一樣。
3，子父類中的構造函數。
在對子類對象進行初始化時，父類的構造函數也會運行，
那是因為子類的構造函數默認第一行有一條隱式的語句 super();
super():會訪問父類中空參數的構造函數。而且子類中所有的構造函數默認第一行都是super();
子類一定要訪問父類中的構造函數。因為父類中的數據子類可以直接獲取。所以子類對象在建立時，需要先查看父類是如何對這些數據進行初始化的。所以子類在對象初始化時，要先訪問一下父類中的構造函數。
如果要訪問父類中指定的構造函數，可以通過手動定義super語句的方式來指定。
注：super語句一定定義在子類構造函數的第一行。
當父類中沒有空參數的構造函數時，子類必須手動通過super語句形式來指定要訪問父類中的構造函數。
子類的構造函數第一行也可以手動指定this語句來訪問本類中的構造函數。
子類中至少會有一個構造函數會訪問父類中的構造函數。
final : 最終。作為一個修飾符，
1，可以修飾類，函數，變量。
2，被final修飾的類不可以被繼承。為了避免被繼承，被子類復寫功能。
3，被final修飾的方法不可以被復寫。
4，被final修飾的變量是一個常量只能賦值一次，既可以修飾成員變量，有可以修飾局部變量。
當在描述事物時，一些數據的出現值是固定的，那么這時為了增強閱讀性，都給這些值起個名字。方便于閱讀。而這個值不需要改變，所以加上final修飾。作為常量：常量的書寫規范所有字母都大寫，如果由多個單詞組成。
5，內部類定義在類中的局部位置上是，只能訪問該局部被final修飾的局部變量。
接口：初期理解，可以認為是一個特殊的抽象類
當抽象類中的方法都是抽象的，那么該類可以通過接口的形式來表示。
class用于定義類
interface 用于定義接口。
接口定義時，格式特點：
1，接口中常見定義：常量，抽象方法。
2，接口中的成員都有固定修飾符。
常量：public static final
方法：public abstract
記住：接口中的成員都是public的。
接口：是不可以創建對象的，因為有抽象方法。
需要被子類實現，子類對接口中的抽象方法全都覆蓋后，子類才可以實例化。
否則子類是一個抽象類。
接口可以被類多實現，也是對多繼承不支持的轉換形式。java支持多實現。
內部類的訪問規則：
1，內部類可以直接訪問外部類中的成員，包括私有。
之所以可以直接訪問外部類中的成員，是因為內部類中持有了一個外部類的引用，格式 外部類名.this
2，外部類要訪問內部類，必須建立內部類對象。
訪問格式：
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().
}
}
內部類定義在局部時，
1，不可以被成員修飾符修飾
2，可以直接訪問外部類中的成員，因為還持有外部類中的引用。
但是不可以訪問它所在的局部中的變量。只能訪問被final修飾的局部變量。
匿名內部類:
1，匿名內部類其實就是內部類的簡寫格式。
2，定義匿名內部類的前提：
內部類必須是繼承一個類或者實現接口。
3，匿名內部類的格式： new 父類或者接口(){定義子類的內容}
4，其實匿名內部類就是一個匿名子類對象。而且這個對象有點胖。 可以理解為帶內容的對象。
5，匿名內部類中定義的方法最好不要超過3個。
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(9);
out.method(7);
}
}
繼承：
特點：
1，提高了代碼的復用性。
2，讓類與類之間產生關系，是多態性的前提。
Java中的繼承。
1，java只支持單繼承，不支持多繼承。因為繼承了多個父類如果有相同方法時,子 類對象不確定運行哪一個。
2，Java還支持多層繼承。A-->B--->C 原來可以形成繼承體系。
想要使用體系功能，"查閱父類功能，建立子類對象調用功能。"
注：父類的由來其實是由事物中的共性內容不斷向上抽取而來的。
所以父類中定義的是該體系中的最基本，最共性功能。
繼承出現后，代碼上特點：
1，變量。
當子父類中定義了相同的名稱的成員變量，
子類要使用父類中的同名變量時，需要使用關鍵字super來區分。
一般不會出現這種情況，因為父類中有了，子類不需要定義。
而且父類定義時，一般變量都私有化。
2，函數。
子類可以直接訪問父類中非私有的成員函數。
特殊情況：當子類中定義了與父類一模一樣的方法時，會發生覆蓋操作。大多指的是非靜態方法。
最終會運行子類的方法，父類相當于被覆蓋了。
函數的另一個特性：覆蓋（重寫，復寫）。
什么時候用
當父類的功能要被修改時，不建議修改源碼。只要通過一個類繼承原有類，定義一個新的升級后的功能即可。但是功能是相同的，只是實現方法改變。這是子類可以沿襲父類中的功能定義，
并重寫功能內容。這就是覆蓋。
注意事項：
1，子類覆蓋父類時，必須權限要大于等于父類權限。
2，靜態不能覆蓋非靜態。
3，構造函數。
構造函數可以本類進行對象初始化，也可以給子類對象進行初始化。
子類對象初始化過程：
子類中的所有構造方法都會訪問父類中空參數的構造函數，
因為每一個構造函數的第一行，都有一句隱式的super語句。
為什么要有這條語句？
因為子類會獲取到父類中的數據，必須要先明確父類對數據的初始化過程。
當父類中沒有空參數構造函數時，子類構造函數必須通過super句來明確要訪問的父類中指定的構造函數。
當時子類構造函數也可以通過this語句訪問本類中的構造函數。
但是子類中肯定，至少有一個構造函數會訪問父類。
抽象類：在分析事物時，事物中的功能有些是不明確的內容的。這些不明確內容就是抽象的。
可以通過抽象函數來描述。
抽象函數一定要定義在抽象類中，因為，抽象函數所在類，也必須被抽象標識。
寫法特點：
1，抽象函數只對函數進行聲明，沒有函數主體。
2，抽象類和抽象函數都需要用abstract修飾。
3，抽象類不可以進行實例化。
4，想要使用抽象功能，必須通過子類覆蓋了父類中所有的抽象方法后，才可以對子類實例化。
如果只覆蓋了部分抽象方法，那么子類還是一個抽象類。
也可以理解為：抽象類是一個父類，是不斷向上抽取而來的，
在抽取過程中，只抽取了方法聲明，但沒有抽取方法實現。
抽象類和一半類差不多。
區別：
抽象類可以定義抽象方法。
抽象類不可以建立對象。
抽象類一樣用于描述事物，既可以定義抽象方法，也可以定義非抽象方法。
接口
初期理解：接口看上去是一個特殊的抽象類。里面存的都是抽象方法。
特點：
格式：
1，通過interface來定義。
2，接口中常見成員：常量，抽象方法。
而且這些成員都有固定的修飾符。
常量：public static final
方法：public abstract
3，接口中的成員都是共有的。
4，一個類可以對接口進行多實現，用多實現方法來體現多繼承的特性。
5，一個類可以繼承一個類的同時，實現多個接口。
6，接口與接口之間是繼承關系，而且可以多繼承。
應用特點：
1，接口是對外暴露的規則。
2，接口是功能的擴展。
3，接口的出現降低了耦合性。
抽象類和接口異同：
相同：
1，都可以在內部定義抽象方法。
2，通常都在頂層。
3，都不可以實例化，都需要子類來實現。
不同點：
1，抽象類中可以定義抽象方法和非抽象方法，
而接口中只能定義抽象方法。
2，接口的出現可以多實現。
抽象類只能單繼承。
也就是說：接口的出現避免了單繼承的局限性。
3，繼承和實現的關系不一致。繼承：is a，實現：like a
異常：就是程序在運行時出現不正常情況。
異常由來：就是java對不正常情況進行描述后的對象體現。
對于問題的劃分：兩種：一種是嚴重的問題，一種非嚴重的問題。
對于嚴重的，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");
}
}
自定義異常：
必須是自定義類繼承Exception。
繼承Exception原因：
異常體系有一個特點：因為異常類和異常對象都被拋出。
他們都具備可拋性。這個可拋性是Throwable這個體系中獨有特點。
只有這個體系中的類和對象才可以被throws和throw操作。
throws和throw的區別
throws使用在函數上。
throw使用在函數內。
throws后面跟的異常類。可以跟多個。用逗號隔開。
throw后跟的是異常對象。
自定義異常時：如果該異常的發生，無法在繼續進行運算，
就讓自定義異常繼承RuntimeException。
對于異常分兩種：
1，編譯時被檢測的異常。
2，編譯時不被檢測的異常(運行時異常。RuntimeException以及其子類)