javaSE面向對象編程

• 2021 年 8 月 12 日
• 筆記
• java se學習

面向對象編程

構造器

構造器就是和類名相同但無返回類型的方法。

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

    String name;

    //實例化初始值
    //1.使用new關鍵字,本質是在調用構造器
    //2.用來初始化值
    public Person(){
    }

    //有參構造:一旦定義了有參構造,無參構造就必須顯示定義
    public Person(String name){
        this.name = name;
    }

    //alt+insert自動生成構造器
    /*
    public static void main(String[] args) {

        Person person = new Person("Avirus");
        System.out.println(person.name);

    }
    構造器:
        1.和類名相同
        2.沒用返回值
    作用:
        1.new本質在調用構造方法
        2.初始化對象的值
    注意點:
        1.定義有參構造之後,如果想使用無參構造,就要顯示定義一個無參構造
     */
} 

無參構造器

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

    //無參構造
    public void shout(){
        System.out.println("叫了一聲");
    }

    /*
    1.類與對象
        類是一個模板:抽象,對象是一個具體的實例

    2.方法
        定義,調用!

    3.對應的引用
        引用類型:   基本類型(8)
        對象是通過引用來操作的: 棧-->堆

    4.屬性:欄位Field 成員變數
        默認初始化:
            數字:0    0.0
            char:u0000
            boolean:false
            引用:null

    5.對象的創建和使用
        -必須使用new 關鍵字創造對象,構造器 Person Avirus = new Person();
        -對象的屬性  Avirus.name
        -對象的方法  Avirus.sleep();
     */
}       

如何訪問私有屬性

package oop.Demo04;

/*
1.提高了程式的安全性,保護數據
2.隱藏程式碼的實現細節
3.統一介面
4.系統可維護性增加了
 */

public class Student {

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

    public int getAge() {
        return age;
    }

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

    private int age;

    //提供一些可以操作這個屬性的方法!
    //提供一些public的get,set方法

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

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

封裝

• 該露的露,該藏得藏
  • 我們程式設計要追求”高內聚,低耦合”.高內聚就說類得內部數據操作細節自己完成,不允許外部干涉;低耦合:僅暴露少量方法給外部使用
• 封裝(數據得隱藏)
  • 通常,應禁止直接訪問一個對象中數據得實際表示,而應通過操作介面來訪問,這稱為資訊隱藏.
• 記住一句話:屬性私有,get/set

package oop.Demo04;

/*
1.提高了程式的安全性,保護數據
2.隱藏程式碼的實現細節
3.統一介面
4.系統可維護性增加了
 */

public class Student {

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

    public int getAge() {
        return age;
    }

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

    private int age;

    //提供一些可以操作這個屬性的方法!
    //提供一些public的get,set方法

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

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

繼承

• 繼承得本質是堆某一批類得抽象,從而實現對現實世界更好得建模

• extends得意思是”擴展”.子類是父類得擴展

• Java中類只有單繼承,沒有多繼承!

• 繼承是類和類之間得一直關係.除此之外,類和類之間得關係還有依賴,組合,聚合等.

• 繼承關係得兩個類,一個為子類(派生類),一個為父類(基類).子類繼承父類,使用關鍵字extands來表示

• 子類和父類之間,從意義上講應該具有”is a”得關係

• object類

• super

• 方法重寫

//所有類都繼承了Object類
public class Person {
    //private
    //protected
    //public
    private int money = 10000000;


    public int getMoney() {
        return money;
    }

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

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

public class Student extends Person{
    
}

繼承了父類得子類,可以使用父類中得方法

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

這個地方值得注意的是被final關鍵字修飾的類,就不能被繼承

super

super關鍵字是用來調用父類的屬性和方法

public class Student extends Person{
    private String name = "test";

    public Student() {
        //隱藏程式碼super();
        super();//調用父類得構造器,必須在子類得第一行
        System.out.println("Student無參執行");
    }

    public void test(String name) {
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
    public void test1() {
        print();
        this.print();
        super.print();
    }
    public void print(){
        System.out.println("Student");
    }
}

super注意點

super注意點:
    1.super調用父類得構造器方法,必須在構造器方法得第一個
    2.super必須只能出現在子類得方法或者構造方法中!
    3.super和this不能同時調用構造方法!


Vs this:
    代表得對象不同:
        this: 本身調用這個對象
        super: 代表父類對象得應用

    前提
        this:沒用繼承也可以使用
        super:只能在繼承條件下使用

    構造方法
        this():本類的構造
        super():父類的構造
        
在子類如果想調用父類的無參構造器時,父類要寫無參構造器,子類也可以直接調用父類的有參構造,在super裡面直接加參數.
如果父類裡面只有有參構造器,而沒有無參構造器,子類無法調用父類的無參構造器

方法重寫

//重寫是方法的重寫,與屬性無關
public class B {
    //靜態方法和非靜態方法區別很大
        //方法的調用之後,左邊定義的數據類型有關

    //非靜態:重寫
    public void test(){
        System.out.println("B-->test()");
    }
}

重寫:需要在繼承關係,子類重寫父類的方法!
    1.方法名必須相同
    2.參數列表必須相同
    3.修飾符:範圍可以擴大,但不可以縮小:public>protected>default>private
    4.拋出的異常:範圍可以縮小,但是不能擴大
是在非靜態方法下的
重寫,子類的方法和父類必須要一致,方法體不同!
    1.父類的功能,子類不一定需要,也不一定滿足
    alt+insert: override
    
在自動生成的重寫方法上面會有一個註解

多態

• 即同一方法可以根據發送對象的不同而採用多種不同的行為方式。

• 一個對象的實際類型是確定的，但可以指向對象的引用的類型有很多

• 多態存在的條件

  • 有繼承關係
  • 子類重寫父類方法
  • 父類引用指向子類對象

• 注意:多態是方法的多態，屬性沒有多態性。

• instanceof:是用來判斷兩個類是否有聯繫的

/*
多態注意事項:
1.  多態是方法的多態,屬性沒用多態
2.  父類和子類,有聯繫,沒有聯繫會類型轉換異常! ClassCastException!
3.  存在條件: 繼承關係,方法需要重寫,父類引用指向子類對象! Father f1 = new Son();

    1.static 方法,屬於類,它不屬於實例
    2.final 常量
    3.private方法





//一個對象的實際類型是確定的

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

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

        //對象能執行哪些方法,主要看對象右邊的類型,和右邊關係不大
        s2.run(); //子類重寫了父類的方法,執行子類的方法
        s1.run();
 */

類型轉換

/*
1.父類引用指向子類的對象
2.把子類轉換為父類,向上轉型
3.把父類轉換為子類,向下轉型,強制轉換,可能會丟失一些方法(說的是丟失子類特殊的方法)
4.方便方法的調用,減少重複的程式碼
*/
/*//類型之間的轉換: 父      子

        //高                     低


        //student將這個對象轉換為Student類型,我們就可以使用Student類型的方法了!


        //子類轉換為父類,可能丟失自己的本來的一些方法!
        Student student = new Student();
        student.go();*/

static關鍵字

被static修飾過之後,與類一起載入,所以被第一個調用

public class Teacher {

    //2 賦初始值
    {
        System.out.println("匿名程式碼塊");
    }
    //1 只執行一次
    static {
        System.out.println("靜態程式碼塊");
    }
    //3
    public Teacher(){
        System.out.println("構造程式碼塊");
    }

    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        System.out.println("===================");
        Teacher teacher2 = new Teacher();
    }
}

靜態導入包

//靜態導入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

抽象類

• abstract修飾符可以用來修飾方法也可以修飾類,如果修飾方法,那麼該方法就是抽象方法;如果修飾類,那麼該類就是抽象類。
• 抽象類中可以沒有抽象方法,但是有抽象方法的類一定要聲明為抽象類。
• 抽象類,不能使用new關鍵字來創建對象,它是用來讓子類繼承的。
• 抽象方法,只有方法的聲明,沒有方法的實現,它是用來讓子類實現的。
• 子類繼承抽象類,那麼就必須要實現抽象類沒有實現的抽象方法,否則該子類也要聲明為抽象類。

//抽象類的所有方法,繼承了它的子類,都必須要實現它的方法  除非它自己也是一個抽象類
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

//abstract抽象類  單繼承           {介面可以多繼承}
public abstract class Action {

    //約束~有人幫我們實現~
    //abstract ,抽象方法 ,只有方法名,沒用方法的實現
    public abstract void doSomething();

    //1.不能new這個抽象類,只能靠子類區實現它:約束!
    public void hello(){
        
    }//抽象類中有普通方法是可以的
    //2.抽象類中可以寫普通的方法
    //3.抽象方法必須在抽象類中
    //抽象的抽象:約束

    //思考? new,存在構造器么?
    //抽象類是存在構造器的,不然子類無法重寫方法
            //存在的意義     抽象出來~提高開發效率
}

介面

• 普通類:只有具體實現
• 抽象類:具體實現和規範(抽象方法)都有!
• 介面:只有規範!自己無法寫方法_{專業的約束!約束和實現分離:面向介面編程}
• 介面就是規範，定義的是- -組規則，體現了現實世界中「如果你…則必須能..的思想。如果你是天使,
  則必須能飛。如果你是汽車，則必須能跑。如果你好人，則必須幹掉壞人;如果你是壞人，則必須欺負好人。
• 介面的本質是契約，就像我們人間的法律-樣。制定好後大家都遵守。
• 00P的精髓，是對對象的抽象，最能體現這一 點的就是介面。為什麼我們討論設計模式都只針對具備了抽象
  能力的語言(比如C++、 java、 c#等) ,就是因為設計模式所研究的，實際上就是如何合理的去抽象。
• 聲明類的關鍵字是class,聲明接[的關鍵字是interface

一個介面

//抽象的思維~ Java 架構

//interface定義的關鍵字,  介面都需要實現類
public interface UserService {

    //常量 public static final
    int AGE = 99;

    //介面中的所有定義的方法其實都是抽象的   public abstract默認
    void run();
    void add(String name);
    void delete(String name);
    void update(String name);
    void select(String name);
}

實現類

//抽象類: extends~
//類 可以實現介面 implements 介面
//實現了介面的類,就需要重寫介面中的方法~

//多繼承,利用介面實現多繼承
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void run() {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void select(String name) {

    }

    @Override
    public void timer() {

    }
}

內部類

public class Outer {

    private int ID = 10;

    public void Outer(){
        System.out.println("Out!");
    }

    //局部內部類
    public void method(){
        class test{
            public void tst(){

            }
        }
    }

    public class Inner{
        public void in(){
            System.out.println("In!");
        }

        //獲取外部類的私有屬性
        public void getID(){
            System.out.println(ID);
        }
    }
}

//一個java類中可以有多個class類,但是只能有一個public類
class Apple {
    public void eat(){
        System.out.println("1");
    }
}

interface Avirus{
    void hello();
}