前言

一、面向物件基礎

1、面向物件思想

1. 面向程序到面向物件的思想層面的轉變
2. 面向程序關注的是執行程序
3. 面向物件關注的是 具備功能的物件
4. 面向程序到面向物件，從程式員思想上是 從執行者到指揮者的轉變

2、三大特性

1.封裝性：所有的內容外界不可見
2.繼承性：將其他的功能繼承下來
3.多型性：方法的多載本身就是一個多型性的體現

3、類與物件

類必須通過物件才可以使用，物件的所有操作都在類中
類由屬性和方法組成：
		屬性：相當于人的特征 例如：姓名、年齡、愛好...
		方法：相當于人的行為 例如：吃飯、睡覺、打豆豆...

1. 類的定義格式

class 類名稱{
   成員屬性;
   成員方法;
}

2. 屬性與方法

屬性定義格式：
   屬性型別  屬性名;
屬性定義及賦值格式;
   屬性型別 屬性名=屬性值;
方法定義格式：
   權限修飾符 回傳值 方法名稱(形參串列){
   			//方法體
   			return 回傳值;
   }
   例如：
   public int number(){
   	int i=10;
   	return i;
   }

3. 物件的創建

//創建物件的格式
類名  物件名=new 類名(有引數/無引數);
//要使用物件中的屬性和方法
//我們可以把 . 看做成 的 ，也就是 物件名的屬性/物件名的方法
物件名.屬性
物件名.方法

4. 物件的使用

public class Demo2 {
   public static void main(String[] args) {
       //類名 物件名稱=new 類名();
           //創建物件
       Book book=new Book();
       //給物件中的屬性賦值
       book.BookName="金蘋果";
       book.money=16.4;
       //呼叫物件中的方法
       book.say();
   }
}
class Book{
   String BookName;
   double money;
   public void say(){
       System.out.println("===>我是"+BookName+"我的價格為===>"+money);
   }
}

4、物件創建時記憶體

5、構造方法（構造器）

執行時機：在創建物件時，自動呼叫
提示：當我們new物件時，會自動呼叫該物件的無引數構造方法，若物件中沒有創建構造方法會默認創建一個無引數構造方法，如果我們寫了有參構造方法或無參構造方法，那么就不會自動創建構造方法（建議自己創建物件時就寫入有參無參構造方法）

class Book{
    String BookName;
    double money;
    //無引數構造方法
    public Book(){};
    //有引數構造方法
    public Book(String name,double money){
        //this指的是當前物件
            //將形參中的name值賦值給this.BookName中
        this.BookName=name;
        this.money=money;
    }
    public void say(){
        System.out.println("===>我是"+BookName+"我的價格為===>"+money);
    }
}

6、方法的多載

//一個類中定義的方法，是允許 方法多載（相同的方法名稱）
    //注意：
        //1.方法名相同
        //2.形參型別、長度不同、引數型別順序不同
    //形參x 和 y
    public int sum(int x,int y){
        int i=x+y;
        return i;
    }
    public double sum(double x,double y){
        double i=x+y;
        return i;
    }

7、匿名物件

匿名：沒有名字，沒有 參考變數來接收堆記憶體中物件的地址，用一次就再也找不到了，
若一個物件要使用兩次及以上，那么我們一定要創建 物件名，

new 類名().方法名()//匿名物件

二、面向物件進階

1、封裝private

概述：封裝是為了保護或防止代碼被惡意修改
保護類的屬性，不讓類以外的程式直接修改訪問

class Person3{
    //給類的屬性添加private修飾符實作對屬性的封裝，此時外部程式不能直接訪問或修改屬性
    private String name;
    private int age;
    //此時我們可以開放一個方法來設定和得到類中私有的屬性 set屬性名 和 get屬性名
    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }
}

2、this關鍵字（this指的是當前物件）

提示：代碼中有就近原則，當我們寫的變數名一樣時，都會找形參的相同變數名，為了起到見名知意，構造器建議寫成這樣

private String name;
    private int age;

    public Person3(String name, int age) {
        this.name = name;
        this.age = age;
    }

3、靜態static

1. 提示：當我們的一個物件有一個屬性是所有人相同時，那么我們就可以把該屬性設定為static屬性，static屬性屬于當前類，不管創建多少個物件，這個static修飾的屬性不會改變
帶有static關鍵字的屬性存盤在方法區中，我們的類設定了static關鍵字屬性，那么我們的這個類就持有static的記憶體地址，不管創建多少個物件，static的屬性都是一致的，
重點：無論這個類創建了多少個物件，這個static靜態屬性在記憶體中只有一份！！！

2. 靜態方法（直接通過類.靜態方法名來執行，不需要new物件）
提示：靜態修飾的方法，被呼叫時，可能物件還沒有被創建
非靜態方法可以呼叫靜態方法，而靜態方法不能調用非靜態方法

public class Demo5 {
   public static void main(String[] args) {
       Student.say();
   }
}
class Student{
   public static void say(){
       System.out.println("我是靜態方法，直接通過 類.靜態方法名就可以執行");
   }
}

4、包（可以理解為檔案夾）

1. 包的定義：通常由多個單詞組成，所有單詞字母小寫，單詞與單詞之間用 " . "分割 ，一般命名為：com.公司名.專案名.模塊名 …

package com.study.demo; //指的是當前包路徑

public class Demo1 {
    
}

4、導包(import)

1. 導包：當我們需要使用某一個包的物件時，但是我們的兩個com.study.test和com.study.test2這兩個包中都有Person這個類，我們需要匯入這個test2包中的Person類，我們就必須要匯入test2這個包的Person類

import 包名.類名
import java.util.Scanner;

5、權限修飾符

6、構造代碼塊

提示：構造代碼塊：隨著物件的每次創建，執行一次，并且執行在構造方法之前！
區別于構造方法的是：無論用戶呼叫哪一個構造方法來創建物件，都會執行構造代碼塊
靜態代碼塊:類加載的時候（第一次使用），靜態代碼塊執行，因為類只加載一次，所以靜態代碼塊只執行一次

public class Demo1 {
    //構造代碼塊
    {
        System.out.println("我執行在構造方法之前");
    }
    //靜態代碼塊:類加載的時候（第一次使用），靜態代碼塊執行，因為類只加載一次，所以靜態代碼塊只執行一次
    static{
		
	}
    //構造方法
    public Demo1(){
        System.out.println("我執行在構造代碼塊之后");
        
    }
}

面試題：構造方法、構造代碼塊和靜態代碼塊執行順序
靜態代碼塊 – > 構造代碼塊 – > 構造方法

三、面向物件高級

1、繼承(extends)

1. 格式：

class 父類{
   
}
class 子類 extends 父類{
   
}

2. 概念：什么叫做繼承，簡單來說，子類繼承了父類，那么子類可以用父類的東西

public class Demo1 {
    public static void main(String[] args) {
        Student student=new Student();
        student.setName("張三");
        student.setAge(20);
        student.say();
    }
}
class Person{
    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) {
        this.age = age;
    }
    public void say(){
        System.out.println("我叫"+name+"今年"+age+"歲");
    }
}
class Student extends Person{

}

提示：我們可以看到Student學生類沒有寫任何屬性和方法，但是繼承了Person類后，我們可以使用Person類的屬性和方法，只有權限修飾符是 public 和protected 子類才可以繼承使用

2、super關鍵字

class Person{
    private String name;
    private int age;
    public Person(){
        System.out.println("無引數Person類");
    }
    public Person(String name,int age){
        System.out.println("有引數Person類");
    }
}
class Student extends Person{
    public Student(){
        //當我們不寫super()時，系統會自動給我們加入super()
        //super()有參和無參只能存在一個
        super();//默認呼叫父類的無引數構造方法
        super("無名稱",20);//呼叫父類的有引數構造方法
    }
}

3、重寫(Override)

1. 當我們子類繼承了父類時，我們不滿足于父類的方法，需要重寫父類的方法，叫做重寫，當我們重寫父類的方法后，我們呼叫子類的say方法就會先找子類中是否有say方法，如果有呼叫子類的say方法，沒有則呼叫父類的say方法

public class Demo2 {
    public static void main(String[] args) {
        Student2 student2=new Student2();
        student2.say();
    }
}
class Person2{
    public void say(){
        System.out.println("我是父類的say方法");
    }
}
class Student2 extends Person2{
    @Override
    public void say() {
        System.out.println("我是重寫后的say方法");
    }
}

4、final關鍵字

1. 用于修飾屬性、變數，使用final修飾變數后，變數成為常量，不能再次賦值，
   1.1 使用final修飾變數后，變數成為常量，不能再次賦值，
   1.2 final修飾的區域變數，只能賦值一次(可以先宣告，后賦值)
   1.3 final修飾的成員變數，必須在宣告時賦值，
2. final用于修飾類
   2.1 final修飾的類，不能被繼承
3. final用于修飾方法
   3.1 final修飾的方法：不能被子類重寫

5、abstract 抽象類

4. 抽象類必須使用 abstract class 宣告
5. 一個抽象類中可以沒有抽象方法，抽象方法必須寫在抽象類中

格式：
	abstract class 類名{//抽象類
		//抽象方法
		public abstract void 方法名();//抽象方法，只宣告為實作
	}
	

6. 一個抽象類不能被實體化(也就是不能被 new 抽象物件類名),當我們子類繼承(extends)抽象父類時，必須重寫所有父類的抽象方法來加以實作，

abstract class Test{//抽象類
   //抽象方法
   public abstract void d1();
}
class Test1 extends Test {
   //實作(重寫)抽象類中的抽象方法
   @Override
   public void d1() {
       
   }
}

6、interface(介面)

6.1 格式

interface 介面名稱{
	全域常量(public static final修飾的屬性):
	抽象方法:
}

6.2 面向介面編程

1. 降低程式的偶爾度
2. 易于程式的擴展
3. 有利于程式的維護

6.3 全域常量和抽象方法

public interface Demo3 {
    //全域常量
    public static final int a=0;
        //全域常量簡寫
    int a=0;

    //抽象方法
    public void demo3();
        //抽象方法簡寫
    void demo3();
}

6.4 介面的實作

提示：1. 格式 public class 類名 implements 介面名1,介面名2…{}

public interface Demo3 {
    //全域常量
    public static final int a=0;
        //全域常量簡寫
//    int a=0;

    //抽象方法
//    public void demo3();
        //抽象方法簡寫
    void demo3();
}
//介面實作  implements 介面名
public class Demo4 implements Demo3{
    @Override
    public void demo3() {

    }
}

7、 多型

提示：父型別參考指向子型別物件

7.1多型格式

public class Demo5 {
    public static void main(String[] args) {
        //父型別參考 person 指向子型別物件   new Student5();
            //把new Student5()的地址給了 person
            //Student屬于Person
            //執行方法時執行的是子類物件的方法，若子類沒有該方法就執行父類的該方法
        Person5 person=new Student5();
        person.say();
    }
}
class Person5 {
    public void say(){
        System.out.println("Person5 say方法執行");
    }
}
class Student5 extends Person5{
    @Override
    public void say() {
        System.out.println("Student5 say方法執行");
    }
}

7.2向上向下轉型

向上轉型：將子類實體變成父類實體
	格式： 父類  父類名稱=new 子類物件

向下轉型：將父類實體變成子類實體
	格式： 子類  子類名稱=(子類)new 父類物件
	

8、Object類

8.1 概念

Object類是所有型別的父類，如果一個類沒有明確繼承某一個類，那么默認繼承Object類

例：
public class Student{
}
======
public class Student extends Object{
}

9、內部類（了解即可）

9.1概念

在Java程式中，可以將一個類定義在另一個類或者方法里面，這樣成為內部類

9.2 成員內部類

特點：成員內部類可以無條件訪問外部類的屬性和方法，包括private成員和靜態成員

class Out{
    private String name;
    //成員內部類
    class In{
        public void say(){
            System.out.println(name);
        }
    }
}

9.3 匿名內部類

格式：
	new 介面名(){
		//實作介面的方法
	}

10、包裝類

10.1 概述

概述：當我們的方法需要一個傳入一個Object物件時，我們只有一個int，但是我們呼叫的方法需要傳入的引數是Object型別，我們就創建一個包裝類，把int基本型別放入到Integer中，就可以呼叫方法

10.2 裝箱和拆箱

概述：裝箱就是把基本型別放入到相對應的包裝類中，就是裝箱，
拆箱就是把包裝類中的相對應的基本型別拿出來，就是拆箱

		//裝箱
        Integer integer = new Integer(100);
        //拆箱
        integer.intValue();

10.3 自動裝箱和自動拆箱

		//自動裝箱，內部會自動把基本資料型別int 100轉換為包裝類Integer
        Integer integer1=100;
        //自動拆箱，內部會自動把包裝類中的基本資料型別拿出來，變成int型別
        int i1=integer1;

11、可變長引數

11.1 格式

語法：

	權限修飾符 回傳值型別 方法名稱(資料型別... 形參名稱){
		//引數在方法內部，以陣列的形式接收
	}

public int test(int... nums){
        int n=0;
        for (int i = 0; i <nums.length ; i++) {
            n+=nums[i];
        }
        return n;
    }

12、try catch（捕獲例外）

12.1概述：

程式中例外分兩種，受檢例外（寫代碼時預知會出現的例外），和非受檢例外（運行時可能會出現的例外，也可能不出現），當出現例外時程式會中斷，所以我們需要捕獲例外來保證程式不中斷，
格式：

try{
	//可能發生例外的代碼段	
}catch(例外型別) 物件名1{
	//例外的處理操作
}catch(例外型別 物件名2){
	//例外的處理操作
}finally{
	//無論程式是否出錯都會執行finally陳述句塊里的代碼段
}

12.2 try catch處理流程

1.當例外發生時，系統會自動創建一個例外類的物件
2.如果發生的例外代碼在try中，則會執行自動匹配catch捕獲的相對應的例外，如果沒有在try中，則會拋出例外

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int i=0;
        try{
            System.out.println("輸入一個數字");
            i= scanner.nextInt();

        }catch (InputMismatchException e){
            //補救措施
            System.out.println("必須輸入數字默認為1");
            i=1;
        }finally {
            //無論程式是否拋出例外，都會執行finally陳述句塊中的內容
            System.out.println(i);
        }
    }

總結

提示：面向物件篇已經更新完畢，喜歡的留下jio印，后面的內容會陸陸續續更新！！！