面向物件
- 面向物件定義
- 類與物件的關系
- 創建與初始化物件
- 創建物件記憶體分析，
- 屬性：欄位 Field 成員變數默認初始化
- 類
- 封裝
  - 高內聚低耦合
  - 封裝的意義
- 繼承
  - Object
  - super
  - 方法重寫
- 多型
  - 多型存在的條件
  - 不能多型的方法
- instanceof
- 參考型別轉換
- static
- 抽象類
- 介面
- 內部類
  - 成員內部類
  - 靜態內部類
  - 區域內部類
  - 匿名內部類

面向物件

https://www.bilibili.com/video/BV12J41137hu/?p=60

面向物件定義

面向物件編程 OOP Object Oriented Programming
面向物件編程的本質：以類的方式組織代碼，以物件的方式組織（封裝）資料，
抽象
三大特性
1. 封裝
2. 繼承
3. 多型

類與物件的關系

類是一種抽象的資料型別，它是對某一類事物整體描述/定義，但是并不能代表某一個具體的事物，
物件是抽象概念的具體實體，

創建與初始化物件

使用new關鍵字創建物件，

使用new關鍵字創建物件的時候，除了分配記憶體空間之外，還會給創建好的物件進行默認的初始化以及對類中構造器的呼叫，
類中的構造器也成為構造方法，是在進行創建物件的時候必須要呼叫的，并且構造器有以下兩個特點，
1. 必須和類的名字相同，
2. 必須沒有回傳型別，也不能寫void，
使用new關鍵字，本質是在呼叫構造器，初始化物件的值，
默認會存在隱式無參構造器，
一旦寫了有參構造器，隱式構造器就不存在了，必須也寫無參構造器，否則無參new會報錯，
idea中Alt+insert，生成構造器，

package com.oop.demo01;

public class Person {
    private String name;
    private int age;
}

package com.oop.demo01;

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

    public Person() {
    }
}

創建物件記憶體分析，

物件是通過參考來操作的，堆疊-->堆，

屬性：欄位 Field 成員變數默認初始化

數字： 0 0.0
char：u0000
boolean：false
參考：null

類

靜態的屬性屬性
動態的行為方法

封裝

高內聚低耦合

高內聚就是類的內部資料操作細節自己完成，不允許外部干涉，
低耦合就是僅暴露少量的方法給外部使用，
屬性私有 get/set，

封裝的意義

提高程式的安全性，保護資料，
隱藏代碼的實作細節，
統一介面，
提高程式可維護性，

繼承

Java中類只有單繼承，沒有多繼承，
繼承是類和類之間的一種關系，
繼承關系的兩個類，一個為子類（派生類），一個為父類（基類），
子類繼承父類，使用關鍵字extends來表示，
子類和父類之間，從意義上講應該具有"is a"的關系，

package com.oop.demo01;

public class Student extends Person {
    private int grade;
}

package com.oop.demo01;

public class Student extends Person {
    private int grade;

    public Student() {
    }
}

Object

在Java中，所有的類都默認之間或間接繼承Object，

super

super呼叫父類的屬性和方法，只能出現在子類的方法或構造方法中，
super()呼叫父類的構造方法，必須在構造方法的第一行，
super()和this()不能同時呼叫構造方法，
this，本身物件的參考，
super，父類物件的參考，

public class Student extends Person {
    private int grade;

    public Student() {}

    public Student(int grade) {
        super();
        this.grade = grade;
    }

    public Student(String name, int age, int grade) {
        super(name, age);
        this.grade = grade;
    }
}

方法重寫

需要有繼承關系，子類重寫父類的方法，
重寫不能是靜態方法，靜態方法隨類加載，
方法名必須相同且引數串列必須相同，
修飾符可以擴大，不能縮小，public>protected>default>private
拋出的例外可以縮小，不能擴大，

package com.oop.demo01;

public class A {

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

package com.oop.demo01;

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

B=>test
B=>test

多型

多型即同一方法可以根據呼叫物件的不同采用多種不同的行為方式，
一個物件的實際型別是確定的，但可以指向物件的參考型別有很多（本身，父類，父類的父類...），
父類的參考指向子類，
物件能執行那些方法，看物件的參考型別，
子類重寫方法后，父類參考和子類參考都執行子類方法，

//物件能執行那些方法，看物件的參考型別，
//父類參考a只能調父類A的方法，子類參考b可以調父類A和子類B的方法，子類參考c可以調父類A和子類C的方法，
//如果子類重寫父類方法，都執行子類方法，
A a = new B();
B b = new B();
A c = new C();

多型存在的條件

有繼承關系，
子類重寫父類的方法，
父類參考指向子類物件，

不能多型的方法

static 方法，屬于類，他不屬于實體，
final
private方法，

instanceof

判斷物件型別，
物件是否是類的實體或類的子類的實體或類的子類的子類...的實體，

public static void main(String[] args) {
        //Object > String
        //Object > Person > Student
        //Object > Person > Teacher
        Object object = new Student();

        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false
        System.out.println("=============================");

        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
//        System.out.println(person instanceof String);//編譯報錯
        System.out.println("=============================");

        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
//        System.out.println(student instanceof Teacher);//編譯報錯
//        System.out.println(student instanceof String);//編譯報錯
    }

參考型別轉換

參考型別之間的轉換：父類子類
子類轉父類自動轉換，Object object = person;
父類轉子類強制轉換，Student b = (Student) person;
子類轉為父類，只能呼叫父類的方法，

Person person = new Student();
Object object = person;
Student b = (Student) person;

static

靜態變數：static修飾的變數，也叫類變數，

static int age;
//靜態變數的呼叫
System.out.println(Person.age);

靜態方法：static修飾的方法，
1. 靜態方法不能呼叫非靜態方法，因為靜態方法隨類加載，靜態方法加載時非靜態方法還沒有加載，
2. 非靜態方法可以呼叫靜態方法，
3. 靜態方法不能呼叫非靜態變數，
4. 非靜態方法可以呼叫靜態變數，

public static void test(){}

靜態代碼塊：類加載時執行一次，

package com.oop.demo01;

public class Demo {
    //執行順序：2 一般用來賦初始值
    {
        System.out.println("匿名代碼塊");
    }
    //執行順序：1 只執行一次
    static {
        System.out.println("靜態代碼塊");
    }
    //執行順序：3
    public Demo() {
        System.out.println("無參構造方法");
    }

    public static void main(String[] args) {
        Demo demo1 = new Demo();
        System.out.println("=======================");
        Demo demo2 = new Demo();
    }
}

靜態代碼塊
匿名代碼塊
無參構造方法
=======================
匿名代碼塊
無參構造方法

靜態匯入包

import static java.lang.Math.random;

抽象類

abstract修飾方法，該方法就是抽象方法，
abstract修飾類，該類就是抽象類，
抽象類中可以沒有抽象方法，但有抽象方法的類一定是抽象類，
抽象類中可以有普通方法，
抽象類有默認的無參構造方法，
抽象類，不能使用new關鍵字來創建物件，它是用來讓子類繼承的，
抽象方法，只有方法的宣告，沒有方法的實作，它是用來讓子類實作的，
子類繼承抽象類，必須要實作抽象類沒有實作的抽象方法，否則該子類也要宣告為抽象類，

package com.oop.demo02;

//抽象類
public abstract class Action {
    //抽象方法
    public abstract void test();
}

package com.oop.demo02;

//繼承了抽象類的正常類，必須實作抽象類的所有沒有實作的抽象方法
//繼承了抽象類的抽象類，可以不實作抽象類的抽象方法
public class ActionA extends Action {
    @Override
    public void test() {

    }
}

介面

普通類：只有具體的實作，
抽象類：具體實作和規范（抽象方法）都有，
介面：只有規范，
介面不能被實體化，因為介面中沒有構造方法，
介面中的所有屬性都是常量，默認 public static final
介面中的所有方法其實都是抽象的，默認 public abstract
單繼承，多實作：可以實作多個介面，只能繼承一個父類，
實作了介面的類，就必須重寫介面中的所有方法，

package com.oop.demo03;

//介面,介面都需要有實作類
public interface UserService {
    //介面中的所有屬性都是常量，默認 public static final
    int age = 9999;
    //介面中的所有方法其實都是抽象的，默認 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

package com.oop.demo03;

public interface TimerService {
}

package com.oop.demo03;

//單繼承，多實作
//可以實作多個介面，只能繼承一個父類
//實作了介面的類，就必須重寫介面中的所有方法
//實作類
public class UserServiceImpl implements UserService,TimerService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

內部類

內部類就是在一個類的內部再定義一個類，比如，A類在定義一個B類，那么B類相對A類來說就成為內部類，而A類相對B類就是外部類，

成員內部類

成員內部類可以使用外部類的所有非靜態屬性和方法，包括私有的，

package com.oop.demo04;

public class Outer {
    private int id = 10;
    private void out() {
        System.out.println("這是外部類的方法");
    }
    //成員內部類
    public class Inner {
        public void in() {
            System.out.println("這是內部類的方法");
        }
        //內部類可以使用外部類的私有屬性和方法
        public void getId() {
            System.out.println("內部類輸出外部類私有屬性：" + id);
            out();
        }
    }
}

package com.oop;

import com.oop.demo04.Outer;

//一個專案應該只有一個main方法
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
//        outer.out();
        //通過外部類實體來實體化內部類，內部類必須是public
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getId();
    }
}

靜態內部類

靜態內部類可以使用外部類的靜態屬性和靜態方法，不能使用非靜態屬性和方法，

package com.oop.demo04;

public class Outer {
    private static int id = 10;
    private static void out() {
        System.out.println("這是外部類的方法");
    }
    //靜態內部類
    public static class Inner {
        public void in() {
            System.out.println("這是內部類的方法");
        }
        //內部類可以使用外部類的私有屬性和方法
        public void getId() {
            System.out.println("內部類輸出外部類私有屬性：" + id);
            out();
        }
    }
}

區域內部類

package com.oop.demo04;

public class Outer {
    public void out() {
        //區域內部類
        class Inner {
            
        }
        System.out.println("這是外部類的方法");
    }
}

匿名內部類

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/207963.html

標籤：其他

上一篇：詳解Python input()函式：獲取用戶輸入的字串

下一篇：060_例外機制

050_面向物件

面向物件

面向物件定義

類與物件的關系

創建與初始化物件

創建物件記憶體分析，

屬性：欄位 Field 成員變數 默認初始化

類

封裝

高內聚低耦合

封裝的意義

繼承

Object

super

方法重寫

多型

多型存在的條件

不能多型的方法

instanceof

參考型別轉換

static

抽象類

介面

內部類

成員內部類

靜態內部類

區域內部類

匿名內部類

屬性：欄位 Field 成員變數默認初始化