JAVA基礎（面向對象）

什麼是面向對象

面向對象編程（OOP）

面向對象&面向對象

面向過程的語言
- 步驟清晰簡單，第一步做什麼，第二步做什麼。。。
- 面對過程適合處理一些較爲簡單的問題
面向對象思想
- 物以類聚，分類的思維模式，思考問題首先會解決問題需要哪些分類，然後對這些分類進行獨立思考。最後，纔對某個分類下的細節進行面向過程的思索。
- 面向對象適合處理複雜的問題，適合處理需要多人協作的問題！
對於描述複雜的事物，爲了從宏觀上把握、從整體上合理分析，我們需要使用面向對象的思路來分析整個系統。但是，具體到微觀操作，仍然需要面向過程的思路去處理。

什麼是面向對象

面向對象編程（Object-Oriented Programming，OOP）
面向對象編程的本質就是：以類的方式組織代碼，以對象的組織（封裝）數據。
抽象
三大特性：
- 封裝
- 繼承
- 多態
從認識論角度考慮是先有對象後有類。對象，是具體的事物。類，是抽象的，是對對象的抽象
從代碼運行的角度考慮是先有類後有對象，類是對象的模板

回顧方法

方法的定義
- 修飾符
- 返回類型
- break和return的區別
- 方法名
- 參數列表
- 異常拋出
方法調用
- 靜態方法
- 非靜態方法
- 形參和實參
- 值傳遞和引用傳遞
- this關鍵字

修飾符&返回類型

package OOP;

//java01 類
public class java01 {

    //main 方法
    public static void main(String[] args) {

    }


    /*
    修飾符  返回值類型 方法名(...){
        //方法體
        return 返回值;
    }
     */
    public String Hello(){
        return "Hello";
    }

    public void Holle(){
        return;
    }

    public int max(int a,int b){
        return a>b?a:b;//三元運算符！
    }
}

break和return的區別

break結束循環
return結束方法（返回一個結果）

方法名

注意規範，見名知意

參數列表

(參數類型,參數名)

異常拋出

===========

方法的調用

ps：以下是兩個文件的代碼

package OOP;

public class java02 {
    public static void main(String[] args) {
        Student.say();//靜態

        //實例化這個類
        //對象類型 對象名=對象值
        Student student = new Student();//非靜態
        student.say01();

        System.out.println(Student.add(1,2));


    }
    public static void a(){
        b();
    }
    public static void b(){
    //static
    }
}
==============================================
package OOP;

//學生類
public class Student {

    //靜態方法
    public static void say(){
        System.out.println("學生說話了");
    }
    public void say01(){
        System.out.println("學生吃零食");
    }

    public static int add(int a,int b){
        return a+b;
    }
}

package OOP;

//值傳遞
public class java03 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);

        java03.change(a);
        change(a);
        System.out.println(a);
    }

    //返回值爲空
    public static void change(int a){
        a=5;
    }

}

package OOP;

//引用傳遞：對象，本質還是值傳遞
//對象  ，內存
public class java04 {
    public static void main(String[] args) {
        Perosn perosn = new Perosn();

        System.out.println(perosn.name);//null

        java04.change(perosn);

        System.out.println(perosn.name);
    }
    public static void change(Perosn perosn){
        //perosn是一個對象：指向--->Perosn perosn = new Perosn();這是一個具體的人
        perosn.name="小明";
    }

}

//定義了一個Preosn類，有一個屬性：name
class Perosn{
    String name;//null
}

類與對象的關係

類是一種抽象的數據類型，它是對某一類事物整體描述定義，但是並不能代表某一個具體的事物
- 動物、植物、手機、電腦········
- Person類、Pet類、Car類，這些類都是用來描述/定義某一類事物應該具備的特點和行爲
對象是抽象概念的具體實例
- 張三就是人的一個具體實例，張三家裏的旺財就是狗的一個具體實例
- 能夠體現出特點，展現出功能的是具體的實例，而不是一個抽象的概念

創建與初始化對象

使用new關鍵字創建對象
使用new關鍵字創建的時候，除了分配空間之外，還會給創建好的對象進行默認的初始化以及對類中構造器的使用
類中的構造器也稱爲構造方法，是在進行創建對象的時候必須要調用的。並且構造器有以下兩個特點：
1. 必須和類名相同
2. 必須沒用返回值類型，也不能寫void
構造器必須掌握

ps:以下是兩個文件代碼

package OOOP;

//一個項目應該只存一個main方法
public class Open {
//面向對象編程的本質就是:以類的方式組織代碼，以對象的組織(封裝)數據
    public static void main(String[] args) {

        //類:抽象的，需要實例化
        //類實例化後會返回一個自己的對象
        //student對象就是一個Student類的具體實例
        Student xiaoming = new Student();
        Student xiaohong = new Student();

        xiaoming.name="小名";
        xiaoming.age=3;

        xiaohong.name="小紅";

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);
    }
}

//Person-->身高。體重

=========================================
package OOOP;

//學生類
public class Student {
//一個類只有屬性和方法

//    //屬性：字段
    String name;//字段
    int age;

//    //方法
    public void study(){
        System.out.println(this.name+"學生在學習");
    }

}

構造器

ps：以下是兩個文件代碼

package 構造器;

public class java01 {
    //一個類即使什麼都不寫，它也會存在一個方法
    //顯示的定義構造器
    String name;

    //實例化初始值
    //使用 new 關鍵字，必須要有構造器
    //使用 new 關鍵字，本質是在調用構造器
    //用來初始化值
    public java01(){
        this.name="小明";
    }

    //有參構造:一旦定義了有參構造，無參構造就
    public java01(String name){
        this.name=name;
    }
}
/*
構造器：
  1.和類名相同
  2.沒有返回值
作用：
   1.new本質在調用構造方法
   2.初始化對象的值
注意點：
   1.定義有參構造之後，如果要使用無參構成，就必須定義

   Alt + insert
 */
==============================================
package 構造器;

public class java02 {
    public static void main(String[] args) {

        //new 實例化了一個對象
        java01 a = new java01("123");

        System.out.println(a.name);
    }
}

封裝

ps：以下還是兩個文件代碼，此後不再提示，======分割文件

package OOOP;

/*
   1.提高程序安全性，保護數據
   2.隱藏代碼的實現細節
   3.統一接口
   4.系統可維護性增加
 */
public class java1 {
    public static void main(String[] args) {
        java2 s1 = new java2();
        s1.setName("小明");

        s1.setAge(20);
        //方法名，參數列表
        System.out.println(s1.getName());
        System.out.println(s1.getAge());
    }
}
=============================================
package OOOP;

//類   privote私有
public class java2 {

    //屬性私有
    private String name;//姓名
    private int id;//學號
    private char sex;//性別
    private int age;

    //提供一些可以操作這些屬性的方法！
    //提供一些public 的get、set方法

    //get獲得這個數據
    public String getName(){
        return this.name;
    }

    //set 給這個數據設置值
    public void setName(String s){
        this.name=s;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>150||age<0){
            System.out.println("年齡不合法");
        }else{
            this.age = age;
        }

    }
}

繼承

import Person.Student;

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

        System.out.println(student.getMoney());


        student.text("我");
    }
}
==============================================
    package Person;

//學生 is 人    派生類   子類

//子類繼承了父類，就會擁有父類的全部方法
public class Student extends Person{

    private String name="蘭若生";

    public void text(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}
==============================================
    package Person;
//JAVA中類只有單繼承，沒有多繼承
//一個兒子只能有一個爸爸，一個爸爸可以有多個兒子

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

//Person 人    父類   基類
public class Person /*extends Object*/{


    protected String name = "小明";


    //public 公共的
    //protected  受保護的
    private int money=10_0000_0000;
    //default 默認的
    //private  私有的

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

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

super

super注意點：

super調用父類的構造方法，必須在構造方法的第一個
super必須只能出現在子類的方法或者構造方法中
super和this不能同時調用構造方法

Vs this：

代表的對象不同：

this：本身調用者這個對象

super：代表父類對象的引用

前提

this：沒有繼承也可以使用

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

構造方法

this（）；本類的構造

super（）：父類的構造

方法的重寫

需要有繼承關係，子類重寫父類的方法

方法名必須相同
參數列表也必須相同
修飾符：範圍可以擴大；
public>Protected>Default>Private
拋出異常；範圍，可以被縮小，但不能擴大

重寫方法和父類一致，方法體不同

爲什麼重寫：

1.父類的功能，子類不一定需要。或者不一定

多態

package java1.com.java01;
//多態
//即同一種方法可以根據發送對象的不同而採用多種不同的行爲方式。
//一個對象的實際類型是確定的 ，但可以指向對象的引用的類型有很多
//（父類，有關係的類）

//多態存在條件
//有繼承關係
//子類重寫父類方法
//父類引用指向子類對象

//注意：多態是方法的多態，屬性沒有多態
import java.time.Period;

public class Main {
    public static void main(String[] args) {

        //一個對象的實現類型是確定的
        //new Student()
        //new Person

        //可以指向的引用類型就不確定了：父類的引用指向子類

        //Student 能調用的方法都是自己的或者繼承父類的！
        Student s1 = new Student();
        //Person 父類型，可以指向子類，但是不能調用子類所有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //對象能執行那些方法，主要看對象左邊的類型，和右邊關係不大！
        s1.run();
        //強制轉換  高->低
        ((Student) s2).eat();
        s2.run();//子類重寫了父類的方法，執行子類的方法
    }
}
/*
多態注意事項
1. 多態是方法的多態，屬性沒有多態
2. 父類和子類，有聯繫    類型轉換異常ClassCastException
3. 存在的條件：繼承關係，方法需要重寫

重寫 不能有以下：
        1. static 方法，屬於類，它不屬於實例
        2. final 常量；
        3. private 方法
 */
============================================================================
package java1.com.java01;

public class Person {
    public void run(){
        System.out.println("run");
    }
}
=============================================================================
package java1.com.java01;

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

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

instanceof和類型轉換

package java1.com.java02;

import java.sql.SQLOutput;
import java.time.Year;

public class Main {
    public static void main(String[] args) {
        //類型之間的轉化：基本類型轉換   父  子

        //高    <------------  低
        Person student =new Student();

        //student將這個對象轉換爲Student類型，我們就可以使用Student類型的方法了！
        ((Student) student).go();
        Student dent = (Student) student;
        dent.go();
        //子類轉換爲父類，可能丟失自己本來的一些方法
    }
}

/*
1. 父類引用指向子類對象
2. 把子類轉換爲父類，向上轉型
3. 把父類轉換爲子類，向下轉換  （強制轉換）
4. 方便方法的調用，減少重複的代碼！簡介

封裝、繼承、多態！ 抽象類，接口
 */
==========================================================================
package java1.com.java02;

public class Person {
    public void run(){
        System.out.println("run");
    }
}
/*
       //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object= new Student();


//        System.out.println(X instanceof Y);//能不能編譯通過！接口
        //取決於是否存在父子關係


        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);//編譯報錯

        Student student = new Student();
        System.out.println("===============================");
        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 > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object= new Student();


//        System.out.println(X instanceof Y);//能不能編譯通過！接口
        //取決於是否存在父子關係


        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);//編譯報錯

        Student student = new Student();
        System.out.println("===============================");
        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);//編譯報錯


 */
====================================================================
package java1.com.java02;

public class Student extends Person{
    public void go() {
        System.out.println("go");
    }
}
====================================================================
package java1.com.java02;

public class Teacher extends Person {
}

抽象類

package java1.com.java04;

//抽象類的所有方法，繼承了它的類，都必須要實現它的方法，除非子類也是
// 抽象類，讓這個子類的子類去實現
public class Student extends Action {
    public static void main(String[] args) {

    }
    public void some(){

    }

}
=========================================================
package java1.com.java04;

//abstract 抽象類：類      接口
//extends ：單繼承~ 接口可以多繼承)
public abstract class Action {

    //約束~有人幫我們實現~
    //abstract，抽象方法只有方法名字，沒有方法的實現！
    public abstract void some();

    //1. 不能new這個抽象類，只能靠子類去實現它：約束！
    //2. 抽象類中可以寫普通方法
    //3. 抽象方法必須在抽象類中~
    // 抽象的抽象： 約束~


}

以上筆記還是來自B站狂神說java 視頻中手抄下來的筆記，作爲練習，加深印象，如果有任何不足或者侵權的地方請聯繫我改進或刪除，(￣︶￣*))

最後附上視頻鏈接，我不是宣傳哈，個人感覺這個老師講的真不錯
傳送門

額，剛發現超鏈接這個功能

JAVA基礎（面向對象）學習

JAVA基礎（面向對象）

什麼是面向對象

面向對象&面向對象

什麼是面向對象

回顧方法

修飾符&返回類型

break和return的區別

方法名

參數列表

異常拋出

方法的調用

類與對象的關係

創建與初始化對象

封裝

繼承

super

方法的重寫

多態

instanceof和類型轉換

抽象類

2024年DataOps趨勢預測：AI不會取代數據工程師

雲原生週刊：K8s 中的服務和網絡｜ 2024.4.29

通過Http鏈接地址爬取有贊微信商城商品信息及下載至EXCEL

[轉帖]cpupower

今天，昨天，近七天，近30天，近90天，js封裝

華爲云云原生FinOps解決方案，釋放雲原生最大價值

GUI圖形用戶界面(Swing窗體)---課堂筆記(附源碼)

JAVA基礎（面向對象）學習

HTML5---我的第一個網頁

操作系統（進程控制思維導圖）

Java多線程(課堂筆記)

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結