1、繼承概述
繼承：
1、提高了代碼的複用性。
2、讓類與類之間產生了關係。有了這個關係，纔有了多態的特性。
注意：千萬不要爲了獲取其他類的功能，簡化代碼而繼承，必須是類與類之間有所屬關係纔可以繼承。所屬關係爲 is a 。
父類的由來其實是由子類不斷向上抽取而來的。如：學生、工人都繼承了人的特性
java語言中：java只支持單繼承，不支持多繼承。
因爲多繼承容易帶來安全隱患：當多個父類中定義了相同功能，但功能內容不同時，子類對象不確定要運行哪一個。
但是java保留了這種機制。並用另一種表現形式（多實現）來完成。
java支持多層繼承。也就是一個繼承體系。
如何使用一個繼承體系中的功能呢？
想要使用體系，先查閱體系父類的描述，因爲父類中定義的是該體系中的共性功能。通過了解共性功能，就可以知道該體系的基本功能。那麼這個體系已經可以基本使用了。
那麼在具體調用時，要創建最子類的對象，爲什麼呢？
一是因爲有可能父類不能創建對象，如抽象類、接口；
二是創建子類對象可以使用更多的功能，包括基本的也包括特有的。
簡單一句話：查閱父類功能，創建子類對象使用功能。
2、子父類出現後，類成員的特點：
類中成員：（1）變量。（2）函數。（3）構造函數。
（1）子父類中的變量
如果子父類中出現非私有的同名變量時：
子類要訪問本類中的變量，用this。
子類要訪問父類中的同名變量，用super。
super的使用和this的使用幾乎一致。
this代表的是本類對象的引用。
super代表的是父類對象的引用。
（2）子父類中的函數。
當子類出現和父類一模一樣的函數時：
當子類對象調用該函數，會運行子類函數的內容。如同父類的函數被覆蓋一樣。
這種情況是函數的另一個特性：重寫（覆蓋）
當子類繼承父類，沿襲了父類的功能到子類中，但是子類雖具備該功能，但是功能的內容卻和父類不一致，這時沒有必要定義定義新功能，而是使用覆蓋特性，保留父類的功能定義，並重寫功能內容。
覆蓋：沿襲父類功能，定義子類特有內容。
（1）子類覆蓋父類，必須保證子類權限大於等於父類權限，纔可以覆蓋，否則編譯失敗。
（2）靜態只能覆蓋靜態。
記住：
重載：只看同名函數的參數列表。
重寫：子父類方法要一模一樣。包括返回值類型。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Tel
{
void show()
{
System.out.println("number");
}
}
class NewTel extends Tel
{
void show()
{
//System.out.println("number");
super.show();
System.out.println("name");
System.out.println("pic");
}
}</span></span>
（3）子父類中的構造函數。
在對子類對象進行初始化時，父類的構造函數也會運行，
那是因爲子類的構造函數默認第一行有一條隱式的語句 super（）；
super（）：會訪問父類中空參數的構造函數。而且子類中所有的構造函數默認第一行都是super（）；
爲什麼子類一定要訪問父類中的構造函數？
因爲父類中的數據子類可以直接獲取，所以子類對象在建立時，需要先查看父類是如何對這些數據初始化的。所以子類在對象初始化時，要先訪問一下父類中的構造函數。
如果要訪問父類中指定的構造函數，可以通過手動定義super語句的方式來指定。（如果父類中沒有空參數的構造函數，那麼就必須顯示的指定super語句訪問對應的父類中的構造函數。）
注意：super語句一定定義在子類構造函數的第一行。
3、子類的實例化過程
結論：
子類的所有的構造函數，默認都會訪問父類中空參數的構造函數。
子類中至少會有一個構造函數會訪問父類中的構造函數。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Fu //extends object
{
Fu()
{ //super();
System.out.println("fu run");
}
}
class Zi extends Fu
{
Zi()
{
//super();
System.out.println("zi run");
}
}</span></span>
4、final關鍵字
final：最終。作爲一個修飾符，
（1）可以修飾類，函數，變量。
（2）被final修飾的類不可以被繼承。（爲了避免類被繼承，避免類被子類複寫功能。）
（3）被final修飾的方法不可以被複寫。
（4）被final修飾的變量是一個常量只能賦值一次，既可以修飾成員變量，又可以修飾局部變量。
當描述事物時，一些數據的出現，值是固定的，那麼這時爲了增強閱讀性，都給這些值起個名字，以方便於閱讀。而 這個值不需要改變，所以加上final修飾。作爲常量：常量的書寫規範所有字母都大寫，如果由多個單詞組成，單詞間通過_鏈接。如：final double PI = 3.14;
（5）內部類定義在類中的局部位置上時，只能訪問該局部被final修飾的局部變量。
5、抽象類
當多個類中出現相同功能，但是功能主體不同。
這時也可以進行向上抽取。只抽取功能定義，而不抽取功能主體。
抽象：看不懂
抽象類的特點：
（1）抽象方法一定定義在抽象類中。
（2）抽象方法和抽象類都必須被abstract關鍵字修飾。
（3）抽象類不可以用new創建對象。因爲調用抽象方法沒意義。
（4）抽象類中的抽象方法要被使用，必須由子類複寫其所有的抽象方法後，建立子類對象調用。
如果子類只覆蓋了部分抽象方法，那麼該子類還是一個抽象類。
抽象類和一般類沒有太大不同，該怎麼描述事物還怎麼描述事物。
只不過，該事物出現了一些看不懂的東西。這些不確定的部分，也是該事物的功能，需要明確出來，但是無法定義功能主體。通過抽象方法來表示。
抽象類比一般類多了抽象方法。就是在類中可以定義抽象方法。
抽象類不可以實例化。
特殊：抽象類中可以不定義抽象方法，這樣做僅僅是不讓該類建立對象。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">/*
需求：假如我們在開發一個系統時需要對員工進行建模。
員工包含3個屬性：姓名、工號、工資。
經理也是員工，除了含有員工的屬性外，另外還有一個獎金屬性。
請使用繼承的思想設計出員工類和經理類。
要求類中提供必要的方法進行屬性訪問。
*/
/*
分析：
員工類：name id pay
經理類：繼承了員工類，並有自己特有的bonus
*/
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()
{
System.out.println("manager work")
}
}
class Pro extends Employee
{
Pro(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()
{
System.out.println("pro work")
}
}</span></span>
6、模板方法設計模式：
什麼是模板方法呢？
在定義功能時，功能的一部分是確定的，但是有一部分是不確定的，而確定的部分要使用不確定的部分，
那麼這時就將不確定的部分暴露出去，由該類的子類去完成。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">/*
需求:獲取一段程序運行的時間。
原理:獲取程序開始和結束的時間並相減即可。
獲取時間：System.currentTimeMillis();
當代碼完成優化後，就可以解決這類問題。
這種方式就是模板方法設計模式。
*/
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<1000;x++ )
{
System.out.println(x);
}
}
}</span></span>
7、接口
格式：interface{}
接口：初期理解：可以認爲是一個特殊的抽象類
當抽象類中的方法都是抽象的，那麼該類可以通過接口的形式來表示。
class用於定義類。
interface用於定義接口。
接口定義時，格式特點：
1，接口中常見定義：常量，抽象方法。
2，接口中的成員都有固定修飾符。
常量：public static final
方法：public abstract
記住：接口中的成員都是public的。
接口：是不可以創建對象的，因爲有抽象方法。
需要被子類實現，用關鍵字implements表示子類對接口中的抽象方法全部覆蓋後，子類纔可以實例化。否則子類是一個抽象類。
接口可以被類多實現，也是對多繼承不支持的轉換形式，java支持多實現。
接口的特點：
接口是對外暴露的規則。
接口是程序的功能擴展。
接口可以用來多實現。
類與接口之間是實現關係，而且類可以繼承一個類的同時實現多個接口。
接口與接口之間可以有繼承關係，接口與接口之間的關係是繼承關係，且接口支持多繼承。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">abstract class Student
{
abstract void study();
void sleep()
{
System.out.println("sleep");
}
}
interface Smoking
{
public abstract void smoke();
}
interface Drinking
{
public abstract void dtink();
}
class StudentA extends Student implements Smoking,Drinking
{
void study(){}
public void smoke(){}
public void drink(){}
}</span></span>
8、多態概述
定義：某一類事物的多種存在形態。（可以理解爲事物存在的多種體現形態。）
人：男人，女人
動物：貓，狗
貓 x = new 貓（）；
動物 x = new 貓（）；
（1）多態的體現（表現形式）
父類的引用指向自己的子類對象。或者說父類的引用也可以接收自己的子類對象。
（2）多態的前提
必須類與類之間有關係，要麼繼承，要麼實現。
通常還有一個前提：存在覆蓋。
（3）多態的好處：
多態的出現大大的提高了程序的擴展性。
（4）多態的弊端：
提高了擴展性，但是隻能使用父類的引用訪問父類中的成員。
（5）多態的應用
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">abstract class Animal
{
abstract void eat();
}
class Cat extends Animal
{
public void eat()
{
System.out.println("喫魚");
}
public void catchMouse()
{
System.out.println("抓老鼠");
}
}
class Dog extends Animal
{
public void eat()
{
System.out.println("喫骨頭");
}
public void kanjia()
{
System.out.println("看家");
}
}
class Pig extends Animal
{
public void eat()
{
System.out.println("喫飼料");
}
public void gongdi()
{
System.out.println("供地");
}
}
class DuoTaiDemo
{
public static void main(S)
{
function(new Cat());
function(new Dog());
function(new Pig());
}
// Animal a = new Cat();Animal a = new Dog();Animal a = new Pig();
public static void function(Animal a)//父類引用指向子類對象
{
a.eat();
}
}</span></span>
運行結果：
轉存失敗轉型：向上轉型、向下轉型
關鍵字： instanceof 用於判斷對象的具體類型，只能用於引用數據類型，通常在向下轉型前用於健壯性的判斷。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class DuoTaiDemo1
{
public static void main(S)
{
Animal a = new Cat()；//類型提升。向上轉型。
a.eat();
//如果想要調用貓的特有方法時，如何操作？
//強制將父類的引用轉成子類類型。向下轉型。
Cat c = (Cat)a;
c.catchMouse();
}
public static void function(Animal a)//父類引用指向子類對象
{
a.eat();
if (a instanceof Cat)//instanceof 關鍵字用於判斷對象的具體類型。
{
Cat c = (Cat)a;
c.catchMouse();
}
else if (a instanceof Dog)
{
Dog c = (Dog)a;
c.kanjia();
}
}
}</span></span>
9、多態中成員的特點
（1）多態中非靜態成員函數的特點：
在編譯時期：參考引用型變量所屬類中是否有調用的方法。如果有，編譯通過；如果沒有，編譯失敗。
在運行時期：參考對象所屬類中是否有調用的方法。
簡單總結就是：成員函數在多態調用時，編譯看左邊，運行看右邊。
（2）多態中成員變量的特點：
無論 編譯和運行，都參閱左邊（引用型變量所屬的類）。
（3）多態中，靜態成員函數的特點：
無論編譯和運行，都參閱左邊。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Fu
{
int num = 5;
void method1()
{
System.out.println("fu method_1");
}
void method2()
{
System.out.println("fu method_2");
}
static void method4()
{
System.out.println("fu method_4");
}
}
class Zi extends Fu
{
int num = 8;
void method1()//
{
System.out.println("zi method_1");
}
void method3()
{
System.out.println("zi method_3");
}
static void method4()
{
System.out.println("zi method_4");
}
}
class DuoTaiDemo1
{
public static void main(String[] args)
{
Zi z = new Zi();
z.method1();
z.method2();
z.method3();
System.out.println("---------------------------------");
//多態中非靜態成員函數特點：編譯看左邊，運行看右邊
Fu f = new Zi();
f.method1();//zi method_1
f.method2();//fu method_2
//f.method3();//編譯失敗 編譯時對象還沒有產生
System.out.println("---------------------------------");
//多態中成員變量特點：編譯運行都看左邊。
System.out.println(f.num);// 5
System.out.println(z.num);// 8
System.out.println("---------------------------------");
//多態中靜態成員函數特點：編譯運行都看左邊。
f.method4();//fu method_4
}
}</span></span>
運行結果：
有兩個例子：主板例子 操作數據庫例子
10、object類
object：所有類的根類。就是所有對象的直接或間接父類，傳說中的上帝。
該類中定義的肯定是所有對象都具備的功能。
object類中的equals方法：默認根據對象的哈希值判斷兩個對象是否相等。
object類中已經提供了對對象是否相同的比較方法。
如果自定義類中也有比較相同的功能，沒有必要重新定義。只要沿襲父類中的功能，建立自己特有比較內容即可。這就是覆蓋。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Demo//extends object
{
private int num;
Demo(int num)
{
this.num = num;
}
public boolean equals(Object obj)//複寫equals方法
{
if (!(obj instanceof Demo))
return false;
Demo d = (Demo)obj;
return this.num == d.num;
}
}
class objectDemo
{
public static void main(String[] args)
{
Demo d1 = new Demo(4);
Demo d2 = new Demo(4);
System.out.println(d1.equals(d2));
}
}</span></span>
object類中的toString方法：默認返回的內容是”對象所屬的類名+@+對象的哈希值（十六進制）“
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Demo//extends object
{
private int num;
Demo(int num)
{
this.num = num;
}
public boolean equals(Object obj)
{
if (!(obj instanceof Demo))
return false;
Demo d = (Demo)obj;
return this.num == d.num;
}
}
class objectToString
{
public static void main(String[] args)
{
Demo d = new Demo(4);
Class c = d.getClass();
System.out.println(c.getName());
System.out.println(d.hashCode());
System.out.println(Integer.toHexString(d.hashCode()));
System.out.println(d.toString());
}
}</span></span>
運行結果：
11、內部類
定義：將一個類定義在另一個類的裏面，裏面那個類就稱爲內部類（內置類，嵌套類）。
內部類的訪問規則：
（1）內部類可以直接訪問外部類中的成員，包括私有成員。
之所以可以直接訪問外部類中的成員，是因爲內部類中持有了一個外部類的引用，格式：外部類名.this。
（2）外部類要訪問內部類中的成員必須要建立內部類的對象。
訪問格式：
（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的。
（3）當內部類在外部類的局部位置上，不可以被成員修飾符所修飾。
可以直接訪問外部類中的成員，因爲還持有外部類的引用。但是不可以訪問它所在的局部中的變量。只能訪問被final修飾的局部變量。
定義原則：
當描述事物時，事物的內部還有事物，該事物用內部類來描述。
因爲內部事物在使用外部事物的內容。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Outer
{
private int x = 4;
class Inner//內部類
{
int x = 5;
void function()
{
int x = 6;
System.out.println("inner :"+x);
System.out.println("inner :"+this.x);
System.out.println("inner :"+Outer.this.x);
}
}
void method()
{
Inner in = new Inner();
in.function();
}
}
class InnerclassDemo
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method();
System.out.println("-------------");
//直接訪問內部類中的成員。
Outer.Inner in = new Outer().new Inner();
in.function();
}
}</span></span>
運行結果：
12、匿名內部類
（1）匿名內部類其實就是內部類的簡寫格式
（2）定義匿名內部類的前提：
內部類必須是繼承一個類或者實現接口。
（3）匿名內部類的格式： new 父類或者接口（）{定義子類的內容}
（4）其實匿名內部類就是一個匿名子類對象。可以理解爲帶內容的對象。
（5）匿名內部類中定義的方法最好不要超過三個。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class AbsDemo
{
abstract void show();
}
class Outer
{
int x = 3;
/*
class Inner extends AbsDemo
{
void show()
{
System.out.println("show :"+x);
}
}
*/
public void function()
{
//new Inner().show();
new AbsDemo()//匿名內部類
{
void show()
{
System.out.println("show :"+x);
}
}.show();
}
}
class InnerclassDemo1
{
public static void main(String[] args)
{
new Outer().function();
}
}</span></span>