### 問題
~~~
public class DianWorker {
String name;
String sex;
public void work() {
System.out.println(name+"做著電工的工作");
}
}
~~~
~~~
public class QianWorker {
String name;
String sex;
public void work() {
System.out.println(name+"做著鉗工的工作");
}
}
~~~
~~~
public class WaWorker {
String name;
String sex;
public void work() {
System.out.println(name+"做著瓦工的工作");
}
}
~~~
三個類當中存在著相同的屬性和行為，這里寫了三次，為了解決這個問題--**繼承**
***
### 繼承(泛化)（extends）
#### 概念
一個Java類可以從一個現有的類（父類，基類，超類）當中派生出來，派生出來的類（子類）具有父類的所有屬性和方法，除了**構造器**和**私有成員**
#### 特點
子類還可以增加自己獨有的屬性和方法來拓展功能
Java中的繼承--單繼承（一個類只能有一個直接父類）
繼承提高了代碼的復用性，也是實現**開閉原則**的基礎
**開閉原則：對拓展開放，對修改關閉**
#### 如何判斷繼承關系
1.A is a kind of B（A是一種B）-->B就是A的父類
2.**里氏替換原則**--任何父類可以出現的地方，子類一定可以出現，子類能夠完全替代父類的功能
### 子類實例化過程
實例化子類對象，子類構造器先默認去調用父類的無參構造器先生成父類對象，然后再生成子類對象,如果父類沒有無參構造器，子類構造器就必須顯式調用父類的其他有參構造器
### super關鍵字
代表父類對象，使用與this完全一樣
1.super.屬性，super.方法名()
2.super()父類構造器
***
### 封裝
#### 訪問權限操作符
#### 概念
將屬性和方法用不同的訪問權限操作符修飾（控制可見范圍），放入一個類中的過程
### 方法重寫（override覆蓋，rewrite，運行時多態）
一定發生在子類當中，與父類**同名，同參，同返回值類型**的方法，子類覆蓋方法的訪問權限要不小于父類中被覆蓋方法的訪問權限
#### 重寫（運行時多態，override）與重載（編譯時多態,overload）的區別？
~~~
// 重寫一定發生在子類當中，與父類方法同名，同參，同返回值類型的方法，子類覆蓋方法的訪問權限要不小于父類中被覆蓋方法的訪問權限
// 重載：同一個類當中，同名不同參的方法，與返回值類型無關
~~~
### 多態（解耦合）
字面意義：一個事物的不同形態（對同一消息做出的不同響應）
編碼意義：一個方法的不同實現
設計意義：將做什么和怎么做分開
前提：
1.要有泛化（繼承）關系
2.要有方法重寫
3.要有上溯造型（父類引用指向子類對象）
***
### static靜態
static能修飾方法，屬性。
static修飾的方法（靜態方法）和屬性（靜態屬性），可以直接通過類名調用，所以靜態屬性和靜態方法不在堆區當中，而在方法區當中的靜態區（共享區）
靜態區中的靜態屬性和靜態方法歸這個類所有對象共享
靜態方法只能直接訪問靜態成員
#### 備注：
1.static不能修飾類
2.static不能修飾構造器
3.static不能修飾局部變量
4.static不能修飾抽象方法
### 靜態塊 : 給靜態屬性初始化
執行時機：類型信息被加載到方法區中時
~~~
static {
System.out.println("靜態塊被調用");
num = 100;
}
~~~
***
### 單例模式（保證一個類只有一個實例-->對象）
~~~
public class Singleton {
// 餓漢模式--餓加載
private static Singleton s = new Singleton();
/*
* 單例模式：
* 保證一個類只有一個實例（對象）
*/
// 構造器私有--不讓其他類隨意new對象
private Singleton() {
}
// 返回一個實例的方法--公有，靜態的，返回值類型為Singleton的方法
public static Singleton getInstance() {
return s;
}
}
~~~
**懶加載**
~~~
public class Singleton {
// 懶漢模式--懶加載
private static Singleton s;
/*
* 單例模式：
* 保證一個類只有一個實例（對象）
*/
// 構造器私有--不讓其他類隨意new對象
private Singleton() {
}
// 返回一個實例的方法--公有，靜態的，返回值類型為Singleton的方法
public static Singleton getInstance() {
if(s == null){
s = new Singleton();
}
return s;
}
}
~~~
***
### final關鍵字
final能修飾類，方法，屬性
final修飾類，最后的類，不能被繼承
final修飾方法，最后的方法，不能被重寫
final修飾屬性，最后的屬性，不能被修改
***
### 抽象類（abstract）
抽象方法：沒有方法體（塊），如果一個類當中存在抽象方法，那么這個類必須是抽象類
**抽象類不能實例化**（但是有構造器），它唯一的作用-->被繼承（充當父類）
一旦一個子類繼承了一個抽象類，就必須重寫父類的所有抽象方法，除非這個子類也是抽象類
#### 思考：abstract與final能不能同時修飾一個類？
不能，abstract類唯一的作用就是被繼承；final類不能被繼承，即使能修飾，這個類也毫無意義
***
### 接口（interface）
如果一個類當中的所有方法都是抽象方法，這個類可以定義為一個接口--接口不是類
接口只能用**public**和默認修飾，**工作不存在默認接口**
因為Java類是單繼承，所以出現了接口，為的是彌補單繼承的缺點
接口不能實例化（沒有構造器），一個類實現了一個接口，必須實現它所有方法，除非這個類是抽象類
#### 接口中的成員
1.只允許聲明常量
2.只允許聲明抽象方法
屬性，存在默認前綴**public static final**
方法，存在默認前綴**public abstract**
**類與類的關系--單繼承**
**類與接口的關系--多實現**
~~~
public class InterfaceAImp implements InterfaceA{
public void test() {
System.out.println("實現A接口");
}
}
~~~
**接口與接口的關系--多繼承**
~~~
public interface InterB extends InterA,InterC{
}
~~~
***
#### 面試題：抽象類和接口有哪些區別?
1.抽象類和接口都不能實例化
2.抽象類有構造器，接口沒有
3.類是單繼承，接口是多實現
4.抽象類是抽象成員和非抽象成員的集合體，接口中只允許存在常量和抽象方法
***
### 接口的應用
接口就是一套規范
~~~
public interface News {
// 增加一條新聞
void addNews();
}
~~~
~~~
public class Sports implements News{
public void addNews() {
System.out.println("發布一條體育新聞到體育模塊");
}
}
~~~
~~~
public class Happy implements News{
public void addNews() {
System.out.println("發布一條娛樂新聞到娛樂模塊");
}
}
~~~
~~~
public class ZhengZhi implements News{
public void addNews() {
System.out.println("發布一條政治新聞到政治模塊");
}
}
~~~
~~~
public class Main {
public static void main(String[] args) {
News n = null;
while(true) {
Scanner scan = new Scanner(System.in);
System.out.println("請輸入要發布什么新聞：");
System.out.println("1--------體育新聞;");
System.out.println("2--------娛樂新聞;");
System.out.println("3--------政治新聞;");
System.out.println("4--------退出程序;");
int option = scan.nextInt();
if(option < 0 || option > 4) {
System.out.println("無效數字");
continue;
}
switch(option) {
case 1:
n = new Sports();
break;
case 2:
n = new Happy();
break;
case 3:
n = new ZhengZhi();
break;
case 4:
System.out.println("謝謝！！！！");
return;
}
n.addNews();
}
}
}
~~~
***
### 內部類（innerClass）
內部類的唯一作用：能夠直接訪問外部類成員，包括私有
解決接口中方法同名同參問題：
~~~
public class InterImpTest implements Interface1{
public void test() {
System.out.println("1");
}
public class InnerClass implements Interface2{
public int test() {
System.out.println("2");
return 0;
}
}
}
~~~
***
#### 總結：
**1.面向對象的四大特性**
①繼承
一個Java類可以從一個現有的類（父類，基類，超類）當中派生出來，派生出來的類（子類）具有父類的所有屬性和方法，除了**構造器**和**私有成員**，子類還可以增加自己獨有的屬性和方法來拓展功能
②封裝
將屬性和方法用不同的訪問權限操作符修飾（控制可見范圍），放入一個類中的過程
③多態（解耦合）
對同一消息做出的不同響應
前提：
1.要有泛化（繼承）關系
2.要有方法重寫
3.要有上溯造型（父類引用指向子類對象）
④抽象
將事物的主要特征和行為抽象成概念模型，在Java中抽象類和接口都是抽象的體現
***
**2.static**
static能修飾方法，屬性。
static修飾的方法（靜態方法）和屬性（靜態屬性），可以直接通過類名調用，所以靜態屬性和靜態方法不在堆區當中，而在方法區當中的靜態區（共享區）
靜態區中的靜態屬性和靜態方法歸這個類所有對象共享
靜態方法只能直接訪問靜態成員
#### 備注：
static不能修飾類
static不能修飾構造器
static不能修飾局部變量
static不能修飾抽象方法
***
**3.單例模式**
懶加載
***
**4.抽象類和接口**
抽象類和接口都不能實例化
抽象類有構造器，接口沒有
類是單繼承，接口是多實現
抽象類是抽象成員和非抽象成員的集合體，接口中只允許存在常量和抽象方法
***
**5.final關鍵字**
final能修飾類，方法，屬性
final修飾類，最后的類，不能被繼承
final修飾方法，最后的方法，不能被重寫
final修飾屬性，最后的屬性，不能被修改
***
**6.方法的重寫**
一定發生在子類當中，與父類**同名，同參，同返回值類型**的方法，子類覆蓋方法的訪問權限要不小于父類中被覆蓋方法的訪問權限
***
**7.上塑造型**
父類引用指向子類對象
