當前位置：首頁 >

Study13（从小白到大佬）

發布時間：2024/3/7 43 豆豆

生活随笔收集整理的這篇文章主要介紹了 Study13（从小白到大佬）小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

面向對象

什么是面向對象

面向對象編程（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（从小白到大佬）的全部內容，希望文章能夠幫你解決所遇到的問題。

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

大佬