2. 程式人生 > 其它 >九、Java面對物件

九、Java面對物件

阿新 • • 發佈：2021-08-11

面向物件程式設計（OOP）

java的核心思想

面向過程

思想：

  • 步驟清晰簡單，第一步做什麼，第二步做什麼...
  • 適合處理一些較為簡單的問題

面向物件

  • 思想：

    • 分類的思維模式，思考問題首先會解決問題需要哪些分類，然後對這些分類進行單獨思考，最後，對分類下的細節進行面向過程的思索

    • 適合處理複雜的問題，多人協作的問題

  • 本質：以類的方式組織程式碼，以物件的組織（封裝）資料

  • 抽象

  • 三大特性：

    • 封裝

    • 繼承

    • 多型

方法回顧

方法定義

  • 修飾符 public
  • 返回型別 void、 int、 String
  • break和return的區別 break：跳出switch 結束迴圈 return：方法結束，返回一個結果
  • 方法名 ：見名知意 駝峰命名法
  • 引數列表
  • 異常丟擲

方法呼叫

  • 靜態方法

  • 非靜態方法

    //靜態方法  static  和類一起載入的
  直接呼叫其他類的方法
//非靜態方法
  例項化類後呼叫

  • 形參和實參

  • 值傳遞和引用傳遞

    引用傳遞：物件，本質還是值傳遞

    值傳遞：傳遞過去改變，本身值不會改變

  • this關鍵字

類與物件的關係

  • 類是一種抽象的資料型別
  • 物件是抽象概念的具體例項

建立物件

類是抽象的

類例項化後（new）會返回一個自己的物件

  • 使用new關鍵字建立物件

  • 使用new關鍵字建立的時候，除了分配記憶體空間外，還會給建立好的物件進行預設初始化以及對類中構造器的呼叫

  • 也稱為構造方法，是建立物件必須要呼叫的，並且構造器有兩個特點

    • 構造器

      • 必須與類名相同

      • 必須沒有返回型別，也不能寫void

    • 作用

      • new本質是在呼叫構造方法
      • 初始化物件的值

    • 注意點

      • 定義有參構造之後，想使用無參構造，必須顯示的定義一個無參構造

Alt+Insert快速構造

建立物件記憶體分析

小結

        1、類與物件
        類是抽象的 物件是一個具體的例項
        2、方法
        定義和呼叫
        3、對應的引用
        引用型別：除基本型別（8）
        物件通過引用來操作的：棧裡面的  真實物件是在堆裡的
        4、屬性：成員變數
        預設初始化：
        數字：0 0.0
        char：u0000
        boolean:false
        引用型別：null
        修飾符 屬性型別 屬性名= 屬性值
        5、物件的建立和使用
        - 必須使用new關鍵字創造物件 構造器
        - 物件的屬性
        - 物件的方法
        6、類：
        靜態的屬性
        動態的行為

封裝

高內聚， 低耦合

類的內部資料細節由自己完成， 儘量暴露少量的方法給外部使用

屬性私有 get/set

意義:

  1. 提高程式安全性
  2. 隱藏程式碼實現細節
  3. 統一介面
  4. 系統可維護性
package com.oop.demo03;

public class Student {
    //屬性私有
    private String name;
    private int id;
    private char sex;
    //提供一些可以操作這個屬性的方法
    //提供一些public 的get、set方法

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

繼承

extends

本質是對某一批類的抽象

子類繼承了父類，就會有父類的所有方法（public）

Object

在java中所有的類都預設繼承Object類

    //public 公共的
    //private 私有的  屬性一般是私有的
    //protected 受保護的
    //default 預設的

Ctrl+H顯示類的繼承結構

Java中只有單繼承，沒有多繼承！一個兒子只能有一個爸爸，一個爸爸可以有多個兒子

super

  1. super呼叫父類的構造方法，必須在構造方法中的第一個
  2. super必須只能出現在子類的方法或者構造方法中
  3. super和this不能同時呼叫構造方法

this和super區別

代表物件不同:

​ this:本身呼叫者這個物件

​ super:代表父類物件的應用

前提：

​ this:沒有繼承也能使用

​ super:只能在繼承條件下才能使用

構造方法:

​ this():本類的構造

​ super():父類的構造

私有的無法被繼承

父類
package com.oop.demo04;

//人
public class Person {
    //public 公共的
    //private 私有的  屬性一般是私有的
    //protected 受保護的
    //default 預設的
    protected String name="woman";

    public Person() {
        System.out.println("父類的無參構造");
    }

    public void say(){
        System.out.println("說了一句話");
    }

}        

子類
package com.oop.demo04;

//學生 人
public class Student extends Person{
    private String name ="dy";

    public Student() {
        super();//super和this只能寫一個 並必須放在第一行，定義有參構造要把無參構造也顯示出來
        System.out.println("子類的無參構造");
    }

    public void say(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}
   

main函式
package com.oop;

import com.oop.demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say("小紅");

    }
}

方法重寫：重點——>多型

需要有繼承關係

子類重寫父類的方法（只有方法，不能屬性）

方法名必須相同，引數列表必須相同

修飾符：範圍可以擴大，不能縮小

丟擲的異常：範圍可以被縮小，但不能擴大

子類和父類方法必須一直，方法體不同

為什麼要重寫：

  1. 父類功能，子類不需要，或者不滿足 Alt+Insert ：Override

多型

動態編譯：型別:可擴充套件性

  1. 多型是方法的多型，屬性沒有多型

  2. 父類和子類，有聯絡 型別轉換異常 ClassCastException

  3. 存在的條件：繼承關係，方法需要重寫，父類引用指向子類物件 father f1 = new Son()

    不能重寫的有：

    static 方法。屬於類，不屬於例項

    final 常量 無法改變 在常量池裡

    private

instanceof 和型別轉換

  1. 父類引用指向子類物件
  2. 把子類轉換為父類，向上轉型；
  3. 把父類轉換為子類，向下轉型，強制轉換
  4. 方便方法呼叫，減少重複的程式碼
父類
package com.oop.demo06;

public class Person {
   public void run(){
       System.out.println("run");
   }
   
}    

子類
    package com.oop.demo06;

public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}


main
package com.oop;

import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;

public class Application {
    public static void main(String[] args) {
        Object object = new Student();
        System.out.println(object instanceof Object);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof Student);
        System.out.println(object instanceof Teacher);
        System.out.println(object instanceof String);
        System.out.println("================");
        Person person = new Student();
        System.out.println(person instanceof Object);
        System.out.println(person instanceof Person);
        System.out.println(person instanceof Student);
        System.out.println(person instanceof Teacher);
        //System.out.println(person instanceof String);
        System.out.println("================");
        Student student = new Student();
        System.out.println(student instanceof Object);
        System.out.println(student instanceof Person);
        System.out.println(student instanceof Student);
        //System.out.println(student instanceof Teacher);
        //System.out.println(student instanceof String);

        //低轉高的 直接轉  高轉低的  需要強轉
        //高                   低
        Person ps = new Student();
        //將person轉換為student型別 可以使用student型別的方法
        Student ps1 = (Student) ps;
        ps1.go();
        //子類轉換為父類 會丟失方法
        Student sd = new Student();
        Person sd1=sd;

    }
}

static

package com.oop.demo07;

public class Person {
    {
        //程式碼塊（匿名程式碼塊） 執行在構造方法前
        //賦初始值
        System.out.println("匿名程式碼塊");
    }
    static {
        //靜態程式碼塊
        //類一載入,就執行一次  第一個執行
        System.out.println("靜態程式碼塊");
    }

    public Person() {
        System.out.println("構造方法");
    }

    public static void main(String[] args) {
        Person p1=new Person();
        System.out.println("=======");
        Person p2=new Person();
    }
}

返回結果

靜態程式碼塊
匿名程式碼塊
構造方法
=======
匿名程式碼塊
構造方法

Process finished with exit code 0

抽象類

abstract 抽象類 子類繼承它並實現抽象類中的抽象方法 extends 單繼承

類為單繼承 介面可以多繼承

  1. 不能new抽象類，只能靠子類去實現
  2. 抽象方法必須在抽象類中，抽象類中可以寫普通方法
抽象類
package com.oop.demo08;

//抽象類：類  extend：單繼承   類是單繼承 介面可以實現多繼承
public abstract class Action {
    //只有方法名，沒有具體實現
    public abstract void doSomething();
    //1.不能new抽象類，只能靠子類去實現：約束
}    

子類
package com.oop.demo08;

//抽象類的所有方法，子類都必須幫其實現  除非子類也是抽象的
public class A extends Action{
    @Override
    public void doSomething() {
		System.out.println("do");
    }
}

介面的定義與實現

普通類：只有具體實現

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

介面：只有規範 interface

介面的本質是契約

作用：

  1. 介面是一種約束
  2. 定義一些方法，讓不同的人實現
  3. public abstract 方法
  4. public static final 屬性
  5. 介面不能例項化，介面中沒有構造方法
  6. 一個類可以實現多個介面 implement
  7. 類必須要重寫介面中的方法
介面timer
package com.oop.demo09;

public interface TimeService {
    void timer();
}
   

介面user
package com.oop.demo09;

//介面需要有實現類
public interface UserService {
    //常量， public static final修飾
    int AGE=99;
    //介面中所有定義都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}    

實現類
package com.oop.demo09;

//類可以實現介面
//實現了介面的類，就需要重寫介面的方法
//介面可以實現多繼承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

內部類

在一個類內部在定義一個類

相關推薦

九、Java面對物件

面向物件程式設計（OOP） java的核心思想 面向過程 思想： 步驟清晰簡單，第一步做什麼，第二步做什麼...

【Java面對物件】this關鍵字的使用

this關鍵字 this關鍵字總是指向呼叫該方法的物件。this可以用來修飾屬性、方法、構造器。

6、java——面向物件：構造器，this，static，block，debug

​ 構造器，this，static，block，debug 1、Constructor : 構造器| 構造方法 | 建構函式 （1）作用: 為物件初始化資訊 (初始化: 第一次賦值) --> 為物件的成員變數在建立物件的同時賦值

8、Java——面向物件：多型，引用資料型別：轉型，抽象的，介面

​ 1、多型 （1）一種事物的多種形態|多種表現形式，行為的多型，一個行為的不同的實現方式。

Java面對物件的三大特徵及理解其一：封裝

@目錄封裝的概念：封裝的好處：封裝的使用：程式碼演示:感謝你的觀看！後續還有繼承和多型的介紹，歡迎批評指正！

九、java版 SpringCloud分散式微服務雲架構之Java 迴圈結構 - for, while 及 do...while

Java 迴圈結構 - for, while 及 do...while 順序結構的程式語句只能被執行一次。 推薦分散式架構原始碼地址

Java面對物件的三大特徵及理解其一：繼承

@目錄繼承的概念：繼承的好處：繼承小知識點：繼承的使用：程式碼演示：執行結果：注意：感謝你的觀看！後續還有多型的介紹，歡迎批評指正！

Java面對物件的三大特徵及理解其一：多型

@目錄多型的概念：多型的實現前提：多型的優勢：多型的使用：程式碼演示：執行結果：多型的理解和程式碼運用已為你雙手呈上，前面還有面對物件三大特徵的繼承，封裝，希望能幫助你更深入的理解面對物件！

7.Java面對物件

Java面對物件 面向過程 面向過程思想 步驟清晰簡單，第一步做什麼，第二步做什麼...

面對物件程式設計(Java)實驗1—陣列、字串、向量與雜湊表

目錄 實驗內容 詞頻統計 二維陣列 字串查詢 主要實驗：詞頻統計，二維陣列、雜湊表、字串

15、Java中級進階 面向物件 繼承

1、何為面向對象 其本質是以建立模型體現出來的抽象思維過程和面向對象的方法（百度百科）是一種編程思維，也是一種思考問題的方式

16、Java中級進階 面向物件 封裝

1、封裝概述 封裝可以被認為是一個保護屏障，將類的某些信息隱藏在類內部，不允許外部程序直接訪問，而是通過類提供的方法來實現對隱藏信息的操作訪問，可以有效的防止該類的代碼和數據被其他類隨意訪問。

java面向物件（下）-- 類的繼承、方法的重寫、super關鍵字

繼承的概念 　　在現實生活中，繼承一般是指子女繼承父類的財產。在程式中，繼承描述的是事物之間的所屬關係，通過繼承可以使多種事物之間形成一種關係體系。

這次齊了！Java面向物件、類的定義、物件的使用，全部幫你搞定

概述 Java語言是一種面向物件的程式設計語言，而面向物件思想是一種程式設計思想，我們在面向物件思想的指引下， 使用Java語言去設計、開發計算機程式。 這裡的物件泛指現實中一切事物，每種事物都具備自己的屬性和

06_面向物件高階篇_02-介面、多型、內部類、列舉、Java常見類、Java垃圾回收機制

本章章節 > 6.1 繼承的基本概念> 6.2 Object類> 6.3抽象類> 6.4 final 關鍵字> 6.5介面(interface)> 6.6物件多型性> 6.7內部類> 6.8列舉> 6.9 Java系統常見類> 6.10 Java垃圾回收機制

java獲取物件屬性型別、屬性名稱、屬性值

原文地址: https://www.cnblogs.com/gmq-sh/p/5942065.html /** * 根據屬性名獲取屬性值 * */

Java面向物件-封裝、繼承、多型

每個元件都可以是一個有屬性和方法的物件。讓元件工作，要知道每個元件是怎麼用的以及是如何與其他元件進行互動的，而無需瞭解這些元件內部是如何工作的。

詳解JAVA面向物件的設計模式 （三）、工廠模式

工廠模式 Factory 介紹 工廠模式（Factory Pattern）是 Java 中最常用的設計模式之一。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。

詳解JAVA面向物件的設計模式 （四）、外觀模式

外觀模式 Facade 外觀模式內容相對簡單，就不寫新的例子了。本篇文章摘錄自 http://c.biancheng.net/view/1369.html

Educoder -Java面向物件 - 封裝、繼承和多型各關卡題目總結

第1關：什麼是封裝，如何使用封裝 　　1、程式設計要求： 　　根據提示，在右側編輯器Begin-End處補充程式碼：