----------------------
android培訓、java培訓、期待與您交流！ ----------------------
繼承特點：
1、提高了代碼的複用性。
Java語言中：java只支持單繼承，不支持多繼承。
因爲多繼承容易帶來安全隱患:當多個父類中定義了相同功能，當功能內容不同時，子類對象不確定要運行哪一個。
但是java保留這種機制。並用另一種體現形式來完成表示。多實現。
java支持多層繼承。也就是一個繼承體系。
如何使用一個繼承體系中的功能：
1、想要使用體系，先查閱體系父類的描述，因爲父類中定義的是該體系中共性功能。
2、通過了解共性功能，就可以知道該體系的基本功能。那麼這個體系已經可以基本使用了。
那麼在具體調用時，爲什麼要創建最子類的對象：
一是因爲有可能父類不能創建對象。
二是創建子類對象可以使用更多的功能，包括基本的也包括特有的。
如果子類中出現非私有的同名成員變量時：
子類要訪問本類中的變量，用this
子類要訪問父類中的同名變量，用super。
this代表的是本類對象的引用。
super代表的是父類對象的引用。
重寫(覆蓋)：
當子類出現和父類一模一樣的函數時，當子類對象調用該函數，會運行子類函數的內容。如同父類的函數被
覆蓋一樣。
當子類繼承父類，沿襲了父類的功能，到子類中，但是子類雖具備該功能，但是功能的內容卻和父類不一
致，這時，沒有必要定義新功能，而是使用覆蓋特殊，保留父類的功能定義，並重寫功能內容。
覆蓋的特點：
1、子類覆蓋父類，必須保證子類權限大於等於父類權限，纔可以覆蓋，否則編譯失敗。
2、靜態只能覆蓋靜態。
3、父類中的私有方法不可以被覆蓋。
繼承中的構造方法：
1、子類中所有的構造函數默認都會訪問父類中空參數的構造函數
2、因爲每一個構造函數的第一行都有一條默認的語句super();
3、子類會具備父類中的數據，所以要先明確父類是如何對這些數據初始化的。
4、當父類中沒有空參數的構造函數時，子類的構造函數必須通過this或者super語句指定要訪問的
構造函數。
子類的實例化過程：
1、因爲父類中的數據子類可以直接獲取。所以子類對象在建立時，需要先查看父類是如何對這些數據進行初
始化的。
2、所以子類在對象初始化時，要先訪問一下父類中的構造函數。
3、如果要訪問父類中指定的構造函數，可以通過手動定義super語句的方式來指定。
4、super語句一定定義在子類構造函數的第一行。
5、子類的構造函數第一行也可以手動指定this語句來訪問本類中的構造函數。子類中至少會有一個構造函數
會訪問父類中的構造函數。
final關鍵字：
1、final可以修飾類，方法，變量。
2、final修飾的類不可以被繼承。
3、final修飾的方法不可以被覆蓋。
4、final修飾的變量是一個常量。只能被賦值一次。既可修飾成員變量，也可以修士局部變量。
5、內部類定義在類中的局部位置上是，只能訪問該局部被final修飾的局部變量。
抽象類：
抽象類的特點：
1、抽象方法一定在抽象類中。
2、抽象方法和抽象類都必須被abstract關鍵字修飾。
3、抽象類不可以用new創建對象。因爲調用抽象方法沒意義。
4、抽象類中的抽象方法要被使用，必須由子類複寫起所有的抽象方法後，建立子類對象調用。如果子
類只覆蓋了部分抽象方法，那麼該子類還是一個抽象類。
5、抽象方法不能被static修飾。
抽象類和一般類沒有太大的不同。該如何描述事物，就如何描述事物，只不過，該事物出現了一些看不懂的
東西。這些不確定的部分，也是該事物的功能，需要明確出現。但是無法定義主體。通過抽象方法來表示。
抽象類比一般類多個了抽象函數。就是在類中可以定義抽象方法。抽象類不可以實例化。
Java代碼
<span style="font-size:14px;"> abstract class Employee//抽象類
{
private String name;
private String id;
private double pay;
Employee(String name,String id,double pay)
{
this.name = name;
this.id = id;
this.pay = pay;
}
public abstract void work();//抽象的工作方法
}
class Manager extends Employee
{
private int bonus;
Manager(String name,String id,double pay,int bonus)
{
super(name,id,pay);
this.bonus = bonus;
}
public void work()//實現父類的work方法
{
System.out.println("manager work");
}
}
class Pro extends Employee
{
Pro(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()//實現父類的work方法
{
System.out.println("pro work");
}
} </span>模板方法：
在定義功能時，功能的一部分是確定的，但是有一部分是不確定，而確定的部分在使用不確定的部
分，那麼這時就將不確定的部分暴露出去。由該類的子類去完成。
Java代碼
<span style="font-size:14px;">abstract class GetTime
{
public final void getTime()
{
long start = System.currentTimeMillis();
runcode();//將要改變的方法抽出作爲一個抽象的方法
long end = System.currentTimeMillis();
System.out.println("毫秒："+(end-start));
}
public abstract void runcode();//在子類中只要實現這個方法，就可以得出自己想要的結果
}
class SubTime extends GetTime
{
public void runcode()//實現父類的方法
{
for(int x=0; x<4000; x++)
{
System.out.print(x);
}
}
} </span>接口：
接口中的成員修飾符是固定的：
成員常量：public static final成員函數：public abstract
接口是不可以創建對象的，因爲有抽象方法。
需要被子類實現，子類對接口中的抽象方法全都覆蓋後，子類纔可以實例化。否則子類是一個抽象類。
接口可以被類多實現，也是對多繼承不支持的轉換形式。java支持多實現。
接口與接口之間存在多繼承，但不能在父類中出現同名方法。
接口和抽象類的區別：
相同：
1、都可以在內部定義抽象方法。
2、通常都在頂層。
3、都不可以實例化，都需要子類來實現。
不同點：
1、抽象類中可以定義抽象方法和非抽象方法，而接口中只能定義抽象方法。
2、接口的出現可以多實現。抽象類只能單繼承。
也就是說：接口的出現避免了單繼承的侷限性。
3、繼承和實現的關係不一致。繼承：is a，實現：like a
多態：
1、多態的體現
父類的引用指向了自己的子類對象。
父類的引用也可以接收自己的子類對象。
2、多態的前提
必須是類與類之間有關係。要麼繼承，要麼實現。
通常還有一個前提：存在覆蓋。
3、多態的好處
多態的出現大大的提高程序的擴展性。
4、多態的弊端：
提高了擴展性，但是隻能使用父類的引用訪問父類中的成員。
在多態中成員函數的特點：
1、在編譯時期：參閱引用型變量所屬的類中是否有調用的方法。如果有，編譯通過，如果沒有編譯失敗。
2、在運行時期：參閱對象所屬的類中是否有調用的方法。
簡單總結就是：成員函數在多態調用時，編譯看左邊，運行看右邊。
在多態中，成員變量的特點：
無論編譯和運行，都參考左邊(引用型變量所屬的類)。
在多態中，靜態成員函數的特點：
無論編譯和運行，都參考左邊。
示例：
Java代碼
abstract class GetTime
{
public final void getTime()
{
long start = System.currentTimeMillis();
runcode();//將要改變的方法抽出作爲一個抽象的方法
long end = System.currentTimeMillis();
System.out.println("毫秒："+(end-start));
}
public abstract void runcode();//在子類中只要實現這個方法，就可以得出自己想要的結果
}
class SubTime extends GetTime
{
public void runcode()//實現父類的方法
{
for(int x=0; x<4000; x++)
{
System.out.print(x);
}
}
} 內部類：
訪問特點：
內部類可以直接訪問外部類中的成員，包括私有成員。之所以可以直接訪問外部類中的成員，是因
爲內部類中持有了一個外部類的引用，格式外部類名.this。
而外部類要訪問內部類中的成員必須要建立內部類的對象。
訪問格式：
1,當內部類定義在外部類的成員位置上，而且非私有，可以在外部其他類中。
可以直接建立內部類對象。
格式：
外部類名.內部類名 變量名 = 外部類對象.內部類對象;
Outer.Inner in = new Outer().new Inner();
2,當內部類在成員位置上，就可以被成員修飾符所修飾。
比如，private：將內部類在外部類中進行封裝。
static:內部類就具備static的特性。
當內部類被static修飾後，只能直接訪問外部類中的static成員。出現了訪問侷限。
在外部其他類中，如何直接訪問static內部類的非靜態成員：
new Outer.Inner().function();
在外部其他類中，如何直接訪問static內部類的靜態成員：
Outer.Inner.function();
當內部類中定義了靜態成員，該內部類必須是static的。當外部類中的靜態方法訪問內部類時，內部類也
必須是static的 。
內部類定義在局部時：
1、不可以被成員修飾符修飾。
2、可以直接訪問外部類中的成員，因爲還持有外部類中的引用。但是不可以訪問它所在的局部中的變量。只
能訪問被final修飾的局部變量。
Java代碼
class Outer
{
int x = 3;
void method(final int a)
{
final int y = 4;
class Inner
{
void function()
{
System.out.println(y);
}
}
new Inner().function();
}
} 匿名內部類:
1、匿名內部類其實就是內部類的簡寫格式。
2、定義匿名內部類的前提：內部類必須是繼承一個類或者實現接口。
3、匿名內部類的格式： new 父類或者接口(){定義子類的內容}
4、其實匿名內部類就是一個匿名子類對象。而且這個對象有點胖。 可以理解爲帶內容的對象。
5、匿名內部類中定義的方法最好不要超過3個。
Java代碼
class Outer
{
int x = 3;
void method(final int a)
{
final int y = 4;
class Inner
{
void function()
{
System.out.println(y);
}
}
new Inner().function();
}
} ---------------------- android培訓、java培訓、期待與您交流！ ----------------------
