面向對象

什么是面向對象

• 面向對象編程（Object-Oriented Programming,OOP）

• 面向對象編程的本質就是：以類的方式組織代碼，以對象的形式封裝數據

• 抽象

• 三大特征：

  • 封裝
  • 繼承
  • 多態

---

類與對象的創建

• 使用new關鍵字創建對象
• 使用new關鍵字創建的時候，除了分配內存空間之外，還會給 創建好的對象 進行默認的初始化以及 對類中構造器的調用
• 類中的構造器也成為構造方法，是在進行創建對象的時候必須要調用的。并且構造早期有以下兩個特點：
  • 1.必須和類的名字相同
  • 2.必須沒有返回類型，也不能寫void

---

構造器詳解

構造器：

? 1.和類名相同

? 2.沒有返回值

作用：

? 1.new本質在調用構造方法

? 2.初始化對象的值

注意點：

? 1.一個類即使什么都不寫，也會存在一個空的構造方法

? 2.定義有參構造后，無參構造消失，如果想使用無參構造，就必須顯式定義無參構造，即創建一個空函數體的無參構造

? 3.alt+Insert快捷鍵創建構造器

? 4.this.name指代當前對象name

---

創建對象內存分析

---

封裝

• 該露的露，該藏的藏

  • 我們程序設計要追求**“高內聚，低耦合”**。高內聚就是類的內部操作細節自己完成，不允許外部干涉；低耦合：僅暴露少量的方法給外部使用。

• 封裝（數據的隱藏）

  • 通常，應禁止直接訪問一個對象中數據的實際表示，而應通過操作接口來訪問，這稱為信息隱藏。

• 記住：屬性私有get/set（快捷鍵：Alt+Insert）

//主函數 package com.hao.OOP;import com.hao.OOP.Demo04.Student;public class Application {public static void main(String[] args) {Student s1 = new Student();s1.setAge(13);System.out.println(s1.getAge());} } //學生類 package com.hao.OOP.Demo04;public class Student {private String Name;private int Age;public String getName() {return this.Name;}public void setName(String name) {this.Name = name;}public int getAge() {return this.Age;}public void setAge(int age) {this.Age = age;} }

---

繼承

• JAVA中類只有單繼承，沒有多繼承！（一個父有多個兒，一個兒只有一個父）。
• 繼承是類和類之間的一種關系。除此之外，類和類之間的關系還有依賴，組合，聚合等。
• 子類繼承父類，使用關鍵字extends來表示。public class Teacher extends Person
• 繼承后，子類擁有父類的全部方法。
• 快捷鍵Ctrl+H打開繼承樹
• 在JAVA中，所有的類都默認直接或間接繼承Object類

---

super

super：調用父類對象和方法

私有屬性不可繼承

this/super調用方法的方式跟調用屬性相同

子類new了一個對象后，會先執行父類的無參構造，再執行子類的無參構造

調用父類的構造器（super();），或者調用自身（this(形參);）有參構造，必須在子類構造器函數體里的第一行，所以super和this不能同時調用構造方法。

重寫

重寫：需要有繼承關系，子類重寫父類的方法！

1. 方法名，參數列表必須相同，方法體不同2. 修飾符：范圍可以擴大但不能縮小（假設private可以繼承，父類private，子類可以public） 3. public>protected>default（默認）>private 4. 拋出的異常：范圍可以縮小但不能擴大

為什么需要重寫：

• 父類的功能，子類不一定滿足

快捷鍵：Alt+Insert，選中override

---

多態

• 即同一方法可以根據發送對象的不同而采用多種不同的行為方式
• 一個對象的實際類型是確定的，可以指向對象的引用的類型有很多
• 多態存在的條件
  • 有繼承關系
  • 子類重寫父類方法
  • 父類引用指向子類對象

//Person父類 package com.hao.OOP.Demo06;public class Person {public void run(){System.out.println("run");}}//Student子類 package com.hao.OOP.Demo06;public class Student extends Person{public void run(){System.out.println("son");}public void eat(){System.out.println("eat");} }//Application主函數 package com.hao.OOP;import com.hao.OOP.Demo06.Person; import com.hao.OOP.Demo06.Student;public class Application {public static void main(String[] args) {//一個對象的實際類型是確定的，可以指向的引用類型不確定Student s1 = new Student();Person s2 = new Student();//new Stuedent(實際類型) Person(引用類型)Object s3 = new Student();s1.run();//son s2.run();//son //子類重寫了父類的方法(子類父類都有run)，執行子類//父類不能調用子類獨有的方法//Person無法直接調用eat()，但是可以類型轉換((Student)s2).eat(); //eat}}

注意事項：

多態是方法的多態，屬性沒有多態

父類和子類要有聯系才能轉換，否則轉換異常！ClassCastException!

存在條件：繼承關系，方法需要重寫，父類引用指向子類對象！Father f1 = new Son();

哪些方法不能被重寫？

static方法，靜態的，屬于類，不屬于實例

final，常量，被final修飾也不能重寫

private方法

---

instanceof和類型轉換

X和Y存在直系父子關系，則TRUE，同級比較，則編譯錯誤

類型之間的轉換：（同基本類型的強制轉換相似）

Person obj = new Student();//高->低：自然轉換Student student = (Student) obj;//低->高：強制轉換Person person = student;//Person轉成student，自然轉換，但是轉換后會失去子類獨有的方法

---

static關鍵字詳解

package com.hao.OOP.Demo07;public class Student {//想要很多類去操作這個變量，就可以定義靜態private static int age; //靜態變量 到后面多線程會具體講解，先了解private double score; //非靜態變量public void run(){}public static void go(){}public static void main(String[] args) {//屬性Student s1 = new Student();System.out.println(Student.age);/*如果是靜態的就推薦使用類名去使用，很明顯知道是靜態。*/System.out.println(s1.age);System.out.println(s1.score);//方法Student.go();//靜態的可以不new直接調用go(); //同個類中的靜態方法可以不加類名.} } package com.hao.OOP.Demo07;public class Person {{System.out.println("匿名代碼塊");//2 和對象同時產生，一般可以用來賦初值}static{System.out.println("靜態代碼塊");//1 只執行1次}public Person() {System.out.println("構造方法");//3}public static void main(String[] args) {Person person1 = new Person();System.out.println("=====================");Person person2 = new Person();} } //輸出： 靜態代碼塊 匿名代碼塊 構造方法 ===================== 匿名代碼塊 構造方法 package com.hao.OOP.Demo07;//靜態導入包 import static java.lang.Math.random; import static java.lang.Math.PI;public class Test {public static void main(String[] args) {System.out.println(random());System.out.println(PI);} }

---

抽象類

package com.hao.OOP.Demo08;//抽象類 public abstract class Action {//約束~希望有人幫我們實現//抽象方法，只有方法名字，沒有方法的實現！public abstract void doSomething(); } package com.hao.OOP.Demo08;//抽象類的所有方法，繼承它的子類需要重寫父類的抽象方法，除非子類也是抽象類 public class A extends Action{@Overridepublic void doSomething() {} }

不能new這個抽象類，只能靠子類去實現它。約束！

抽象類中可以寫普通的方法，有抽象方法的類必須是抽象類

思考：

• 既然不能new對象，那是否存在構造器？
• 存在的意義是什么？

---

接口

普通類：只有具體實現

抽象類：具體實現和規范（抽象方法）都有

接口：只有規范！自己無法寫方法~專業的約束！ 可以實現約束和分離：面向接口編程

接口的本質是契約，就像人間的法律，制定后都必須遵守。

OO的精髓，是對對象的抽象，最能體現這一點的就是接口。

//接口package com.hao.OOP.Demo09;//interface定義的關鍵字 public interface UserService {//常量,默認修飾public static finalint AGE=99;//很少人會用，一般不會這么用//接口中所有的方法都默認修飾 public abstractvoid add(String name);void delete(String name);void udpate(String name);void query(String name); }//鍛煉抽象的思維->架構師 //實現接口的類package com.hao.OOP.Demo09;//抽象類：extends //類 可以實現接口 implements接口 //實現了接口的類，就需要重寫接口中的方法//多繼承->利用接口實現public class UserServiceImpl implements UserService,接口1,接口2 public class UserServiceImpl implements UserService{@Overridepublic void add(String name) {}@Overridepublic void delete(String name) {}@Overridepublic void udpate(String name) {}@Overridepublic void query(String name) {} }

接口的作用：

約束

定義一些方法，讓不同的人實現。（10個人實現同一個接口，10種不同的方式）

接口沒有構造方法（實現類），不能被實例化

implement可以實現多個接口

必須要重寫接口中的方法

內部類（了解）

總結

以上是生活随笔為你收集整理的Study13（从小白到大佬）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。