Java基礎 — 面向物件

阿新 • • 發佈：2022-01-03

面向物件程式設計

1 類的呼叫

靜態方式

  //Student.java
  public class Student {
      public static void sayHi(){
          System.out.println("Hello World!");
      }
  }

  //main.java
  public class main {
      public static void main(String[] args) {
          Student.sayHi();
      }
  }

非靜態方式

//Student.java
  public class Student {
      public void sayHi(){
          System.out.println("Hello World!");
      }
  }
  
  //main.java
  public class main {
      public static void main(String[] args) {
          Student student = new Student();
          student.sayHi();
      }
  }

靜態方法和非靜態方法

//可以直接呼叫
  public static void a(){
      b();
  }
  public static void b(){}
  
  //可以直接呼叫
  public void a(){
      b();
  }
  public void b(){}
  
  //不可以呼叫
  //方法 a 由 static 修飾，與類一起載入
  //方法 b 無 static 修飾符，只有例項化之後才會在記憶體中載入，因此此種呼叫方式錯誤
  public static void a(){
      b();
  }
  public void b(){}

2 值傳遞和引用傳遞

值傳遞

public class main {
      public static void main(String[] args) {
          int num = 5;
          System.out.println(num);		//num = 5
          change(num);
          System.out.println(num);		//num = 5
      }
  
      public static void change(int num){
          num = 100;
      }
  }

引用傳遞

public class main {
      public static void main(String[] args) {
          Person person = new Person();
          System.out.println(person.name);	//null
          main.change(person);
          System.out.println(person.name);	//Bob
      }
  
      public static void change(Person person){
          person.name = "Bob";
      }
  }
  
  class Person {
      String name;
  }

3 類的例項化

建構函式

  // new 的本質，就是在呼叫構造器
  public class Person {
      String name;
      
      //無參構造
      public Person(){
          this.name = "Bob";
      }

      //有參構造
      public Person(String name){
          this.name = name;
      }
  }

記憶體分析

 public class main {
      public static void main(String[] args) {
          Pet dog = new Pet();
          dog.name = "旺財";
          dog.age = 3;
          dog.shout();
          Pet cat = new Pet();
      }
  }
  
  public class Pet {
      public String name;
      public int age;
  
      public void shout(){
          System.out.println("Shout!");
      }
  }

4 三大特性

封裝

public class Pet {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < -1 || age > 120){
            this.age = 3;
        }else{
            this.age = age;
        }
    }
}

public class main {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.setAge(500);
        System.out.println("age = " + dog.getAge()); //age = 3
    }
}

封裝的作用：
- 提高程式安全性，保護資料
- 隱藏程式碼實現細節
- 統一介面 get / set
- 系統可維護性增加

繼承：本質是對一批類的抽象，使用關鍵字 extends

public class Pet {
    private String name = "Bob";
    protected int age = 5;
    int money = 100;
    public void shout(){
        System.out.println("Hi");
    }
}

public class Cat extends Pet {}

public class main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.shout();	//Hi
        System.out.println(cat.name);	//Error
        System.out.println(cat.age);	//5
        System.out.println(cat.money);	//100
    }
}

子類會繼承父類中 public、protected、default 修飾的所有屬性和方法，private 修飾的則不會被繼承
Java 中所有的類，都預設繼承 Object 類
Java 中的類都是單繼承，沒有多繼承
私有屬性和方法均無法被繼承

public class Pet {
    public String name = "Pet";

    public void shout(){
        System.out.println("Father");
    }
}

public class Cat extends Pet {
    public String name = "Cat";

    public void print(){
        System.out.println("Son");
        System.out.println(super.name);
        super.shout();
    }
}

public class main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.print();
        // Son  Pet  Father
    }
}

super 注意點
- super 呼叫父類的構造方法時，必須出現在子類構造方法的第一行
- super 必須只能出現在子類的方法或者構造方法中
- super 和 this 不能同時呼叫構造方法
super VS this
- 代表的物件不同
  - this ：本身呼叫者這個物件
  - super ：代表父類的引用
- 適用前提不同
  - this ：有無繼承均可使用
  - super ：只能在繼承的條件下使用
- 構造方法
  - this ：本類的構造方法
  - super ：父類的構造方法
方法重寫
- 方法名與引數列表必須一致
- 修飾符的範圍可以擴大，但不能縮小 public > protected > default > private
- 丟擲的異常，範圍可以擴大不能縮小
- 子類重寫父類方法，只是方法體不同

//使用 static 關鍵字：方法的呼叫只和左邊的型別有關
public class B {
    public static void test(){
        System.out.println("B ==> test()");
    }
}

public class A extends B{
    public static void test(){
        System.out.println("A ==> test()");
    }
}

public class main {
    public static void main(String[] args) {
        A a = new A();
        a.test();	//A ==> test()
        B b = new A();
        b.test();	//B ==> test()
    }
}


//方法重寫：重寫的定義只針對無 static 修飾的方法
public class B {
    public static void test(){
        System.out.println("B ==> test()");
    }
}

public class A extends B{
    //對父類的 test() 方法進行了重寫
    @Override
    public static void test(){
        System.out.println("A ==> test()");
    }
}

public class main {
    public static void main(String[] args) {
        A a = new A();
        a.test();	//A ==> test()
        B b = new A();
        b.test();	//A ==> test()
    }
}

多型

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

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("Student ==> run()");
    }

    public void eat(){
        System.out.println("Student ==> eat()");
    }
}

public class main {
    public static void main(String[] args) {
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();

        s1.run();				//Student ==> run()
        s1.eat();				//Student ==> eat()
        ((Student) s2).eat();			//Student ==> eat()
    }
}

多型注意事項
- 多型是方法的多型，屬性沒有多型
- 父類與子類必須有聯絡，否則就會轉換異常 ClassCastException
- 子類需要對父類方法進行重寫，父類的引用物件指向子類
類的型別轉化
- 父類的引用指向子類的物件
- 子類轉為父類，是低轉高，向上轉型，直接轉換
- 父類轉為子類，是高轉低，向下轉型，要強制轉換，父類可能會丟失一些原有的方法

5 static 關鍵字

public class Person {

    {
        System.out.println("匿名程式碼塊");
    }

    static {
        System.out.println("靜態程式碼塊");
    }

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

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

/*
靜態程式碼塊
匿名程式碼塊
構造方法
---------
匿名程式碼塊
構造方法
*/

靜態程式碼塊和類一起載入，且只加載一次
匿名程式碼塊在構造方法之前載入

6 抽象類

使用關鍵字 abstract 修飾
抽象類與抽象方法的作用是實現約束
子類如果繼承了抽象類，那麼就必須實現父類的抽象方法，除非子類也是抽象類
不能 new 抽象類，只能靠子類去實現
抽象類裡可以寫普通方法，但是普通類裡不能寫抽象方法，抽象方法只能在抽象方法中

public abstract class Person {

    public abstract void doSomething();
}

public class Student extends Person{
    @Override
    public void doSomething() {

    }
}

抽象類也有構造方法

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

public class Student extends Person{
    @Override
    public void doSomething() {
        System.out.println("doSomeThing()");
    }
}

public class main {
    public static void main(String[] args) {
        Student student = new Student();
    }
}

//構造方法

7 介面

類、抽象類、介面
- 類：只有具體實現
- 抽象類：具體實現的規範（抽象方法）都具有
- 介面：使用關鍵字 interface ，只有規範，自己無法寫方法，實現約束和具體步驟的分離，更加規範
介面中所有的方法，其實都是抽象的，預設使用 public abstract 修飾

public interface UserAction {
    void run();
}

類實現介面使用關鍵字 implements
實現了介面的類，就必須重寫介面中的所有方法，介面可以“多繼承”

public interface UserAction {
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface UserTime {
    void timer(String name, int age);
}

public class UserActionImpl implements UserAction, UserTime{
    @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(String name, int age) {

    }
}

8 內部類

一般內部類（可以訪問外部類的私有屬性）

public class Outer {
    private final int id = 10;

    public void printOut(){
        System.out.println("外部類的方法");
    }

    class Inter {
        public void printIn(){
            System.out.println("內部類方法");
        }

        public void getOutId(){
            System.out.println(id);
        }
    }
}

public class main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inter inter = outer.new Inter();
        inter.getOutId();		//10
    }
}

區域性內部類

public class Outer {

    public void method(){
        class test{
        }
    }
}

匿名內部類

public class main {
    public static void main(String[] args) {
        new Apple().eat();
    }
}

class Apple{
    public void eat(){
    }
}

Java基礎--面向物件

面向物件&面向過程面向過程：線性過程、第一步做什麼、第二步做什麼面向物件：物以類聚、分類的思維模式、處理複雜的問題，多人協作，其本質是：以類的方式組織程式碼，以物件的方式封裝資料。

[Java基礎]面向物件

一.什麼是面向物件　　1.在Java程式設計師眼中,只要是一個例子,一個需求,都能給他變成一個類

Java基礎-面向物件

一、Java中的成員變數和區域性變數定義：成員變數直接定義在類中；區域性變數定義在方法中，引數上，語句中。

JAVA基礎面向物件（四）程式碼塊 static 抽象類內部類

一、static 關鍵字引入 static關鍵字宣告的屬性和方法是類自己的，所有類例項化的物件，都共享這些static屬性和方法。

JAVA基礎面向物件（五）抽象類介面內部類

一、抽象類（abstract）隨著繼承層次中一個個新子類的定義,類變得越來越具體,而父類則更一·般,更通用。類的設計應該保證父類和子類能夠共享特徵。有時將一個父類設計得非常抽象,以至於它沒有具體的

Java 基礎(面向物件; 類和物件)

面向過程(POP)與面向物件(OOP) 1.二者都是一種思想，面向物件是相對於面向過程而言的。面向過程，強調的是功能行為，以函式為最小單位，考慮怎麼做。面向物件，將功能封裝進物件，強調具備了功能的物件，以類/物件為

Java基礎-面向物件（一）

類和物件的建立、屬性和方法、方法過載、值傳遞機制、遞迴方法一、類和物件

Java基礎——面向物件2

Java基礎——面向物件2 繼承子類無法使用父類的私有屬性或方法 Java中只有單繼承，沒有多繼承

Java基礎 — 面向物件

面向物件程式設計 1 類的呼叫靜態方式 //Student.java public class Student { public static void sayHi(){

Java基礎---面向物件

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

Java---(三)面向物件程式設計基礎上

一:面向物件的基本概念　　1.封裝性　　　　含義: 　　　　　　①把物件的屬性和行為看成一個密不可分的整體,把這兩者\"封裝\"在一個不可分割的對立單位中

Java基礎-面向過程與面向物件

1、面向過程POP(Process-oriented programming) 面向過程就是分析出解決問題所需要的步驟，然後用函式把這些步驟一步一步實現，使用的時候再一個一個的依次呼叫就可以了。

跟光磊學Java開發-面向物件程式設計基礎

跟光磊學Java開發-面向物件程式設計基礎跟光磊學Java開發繼承繼承概述和使用

程式設計基礎-Java語言-面向物件

技術標籤：Java後端開發學習 java 封裝調方法 public class RunEncap{ public static void main(String args[]){

【JAVA筆記】JAVA-入門基礎-面向物件04

一、OOP詳解面向物件程式設計（Object-Oriented Programming，OOP）面向物件程式設計的本質就是：以類的方式組織程式碼，以物件的組織（封裝）資料。

C#基礎-面向物件詳解

面向物件詳解一.什麼是面向物件 1>面向物件是一種程式設計思想 2>面向過程和麵向物件是什麼？

python基礎--面向物件基礎(類與物件、物件之間的互動和組合、面向物件的名稱空間、面向物件的三大特性等)

python基礎--面向物件 (1)面向過程VS面向物件面向過程的程式設計的核心是過程（流水線式思維），過程即解決問題的步驟，面向過程的設計就好比精心設計好一條流水線，考慮周全什麼時候處理什麼東西。

Java筆記-面向物件相關

1. 類中變數的分類　　1）區域性變數：在方法中定義的變數　　2）成員變數：類的屬性

java-09面向物件（五）

一、關鍵字 static 1.static關鍵字的使用 static可以用來修飾：屬性、方法、程式碼塊、內部類

淺談Java實現面向物件程式設計java oop

一、物件的綜述面向物件程式設計（OOP）具有多方面的吸引力。對管理人員，它實現了更快和更廉價的開發與維護過程。對分析與設計人員，建模處理變得更加簡單，能生成清晰、易於維護的設計方案。對程式設計師，物件模

Java基礎 — 面向物件

面向物件程式設計

1 類的呼叫

2 值傳遞和引用傳遞

3 類的例項化

4 三大特性

5 static 關鍵字

6 抽象類

7 介面

8 內部類

相關推薦