### 問題
~~~
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.上塑造型**
父類引用指向子類對象