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

阿新 • • 發佈：2022-12-07

一、OOP詳解

面向物件程式設計（Object-Oriented Programming，OOP）
面向物件程式設計的本質就是：以類的方式組織程式碼，以物件的組織（封裝）資料。
抽象
三大特性：封裝、繼承、多型、

1、 class類

我們面向物件，就是把一個一個抽象的事務具象化一個類，然後把屬性和行為定義出來。

定義類

public class Cat {
    String name;
    int age;
    
    void eat(){
        System.out.println("小貓吃魚！");
    }
}

　這就是一個類，小貓的名字和年齡是它本身的屬性，吃是小貓的行為　

2、類與物件的關係

類是一種抽象的資料型別，而物件是對這種抽象的類的例項化。

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();

    }

二.類詳解-封裝

1、 this關鍵字

this翻譯出來就是這個，每一個類都有一個this，他是一個引用。通常情況下可以省略。
在例項方法中，或者構造方法中，為了區分區域性變數和例項變數，不能省略。

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

這個時候區分這個this.name代表類種屬性的name而不是區域性變數。

2 、構造方法

每個類都有一個預設的構造方法，和類名一樣的無參構造。
但是如果我們寫了一個構造器，系統就不會自動生成無參構造器了

public class Cat {
    private String name;
    int age;
    public Cat() {
      
    }

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

    void eat(){
        System.out.println("小貓吃魚！");
    }


}

alt+insert可以選擇constrouctor快速的生成構造方法。構造方法可以過載。

3、封裝

一個類的屬性不應該完全暴露，不然就會被隨意更改，我們需要定義一個方法，通過方法來操作我們的屬性，這就是封裝的基本理念

1）private強調是自己來使用

2）預設是給同包下的來使用

3）protected 強調的是給子類使用

4）public 強調的是給大家使用

封裝的意義：

private 是私有的意思，我們把屬性通過private修飾，然後通過方法去取值和賦值，這樣對於一些違規的操作我們就可以在方法裡進行過濾，比如年齡如果傳過來超過一百五十歲這種。

public class Cat {
    private String name;
    private int age;
    public Cat() {

    }

    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 Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void eat(){
        System.out.println("小貓吃魚！");
    }


}

　　alt+inser也可以快速生成

三.類詳解-繼承

類與類直接可以繼承，比如我們定義一個人類，然後男人類和女人類就可以繼承人類。完全繼承他的屬性和方法。還有自己的特定的屬性

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

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

public class Man extends Person {
    private String huzi;
    
    public void niao(){
        System.out.println("站著尿尿");
    }
}

我們就定義是一個人類，基本上每個人都是有年齡名字和吃的行為，但是男人除了人類的特性，還有鬍子和站著尿尿的行為，這樣我們為了不重複宣告屬性和行為，直接繼承即可。　　

一個類只能單繼承，只能繼承一個父類，但是一個父類可以有多個子類。
Object類是所有類的父類。

1、Super關鍵字

之前介紹了this關鍵字，是類的引用，Super關鍵字就是代表父類的引用。

  public void niao(){
        super.eat();
        System.out.println("站著尿尿");
    }

我們子類在尿尿的時候，可以呼叫父類吃的方法，吃完在尿　

不管是顯式還是隱式的父類的構造器,super語句一定要出現在子類構造器中第一行程式碼。所以this和
super不可能同時使用它們呼叫構造器的功能,因為它們都要出現在第一行程式碼位置。

2、方法重寫

方法重寫是發生在子類中，引數和方法名返回值型別都得相同。

重寫例項：

package com.cnblogs;
//本類用於實現
public class Application {
    public static void main(String[] args) {
        //例項化父類
        Person person = new Person();

        //例項化子類
        Student stu = new Student();

        person.getName();//父類屬性
        stu.getName();
        //子類屬性
        //父類屬性
    }
}

package com.cnblogs;
/*
person類
 */
public class Person {
    //父類屬性
    private String name = "父類屬性";
    //父類方法
    public void getName(){
        System.out.println(name);
    }
}

package com.cnblogs;
/*
student類
 */
public class Student extends Person{
    //子類屬性
    private String name = "子類屬性";
    //子類重寫父類方法
    @Override
    public void getName() {
        System.out.println(name);
        //super關鍵字
        super.getName();
    }
}

四.類詳解-多型

定義：父類引用指向子類物件，就是多型

多型的存在要有3個必要條件：要有繼承，要有方法重寫，父類引用指向子類物件　　

1、多型例項：

Animal 父類：

package cn.itcast.demo7;

//定義父類
public class Animal {
    private String name;

    //    空參構造
    public Animal() {

    }

    //    帶參構造
    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    //    成員方法
    public void eat() {
        System.out.println("吃飯");
    }
}

Dog 子類：

package cn.itcast.demo7;

//是Animal的子類
public class Dog extends Animal {
    //對父類eat重寫
    @Override
    public void eat() {
        System.out.println(getName() + "吃骨頭");
    }
}

Mouse 子類：

package cn.itcast.demo7;

//子類-老鼠類
public class Mouse extends Animal {
    @Override
    //對父類eat重寫
    public void eat() {
        System.out.println(getName() + "吃乳酪");

    }

}

Test測試類（寫法1）：

package cn.itcast.demo7;

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

        Animal animal1 = new Dog();
        animal1.setName("哈士奇");
        animal1.eat();

        Animal animal2 = new Mouse();
        animal2.setName("Jerry");
        animal2.eat();

    }
}

測試結果：

哈士奇吃骨頭
Jerry吃乳酪

Test測試類（寫法1）：

package cn.itcast.demo7;

public class Test {
    public static void main(String[] args) {
//        用來測試Dog類和Mouse類
//        測試Dog類
        Dog d = new Dog();
        d.setName("哈士奇");
        showAnimal(d);

//        用來測試老鼠類
        Mouse m = new Mouse();
        m.setName("Jerry");
        showAnimal(m);

    }

    // 多型的使用場景：父型別可以作為形參的資料型別
    public static void showAnimal(Animal an) {
        an.eat();

    }

}

兩種寫法返回結果相同　

備註：

1）多型關係中，成員變數不涉及重寫
簡單記憶：編譯看左，執行看左

2）多型關係中，成員方法
簡單記憶：編譯看左，執行看右

2、多型呼叫子類獨有方法例項：

Animal 父類：

package cn.itcast.demo8;

public class Animal {
    public void eat() {
        System.out.println("吃飯");
    }
}

Dog子類：

package cn.itcast.demo8;

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨頭");
    }

    public void watch() {
        System.out.println("狗會看家");
    }

}

Test 測試類：

package cn.itcast.demo8;

public class Test {
    public static void main(String[] args) {
//        通過多型建立物件呼叫子類的方法
        Animal an = new Dog();
//        呼叫eat()方法
        an.eat();

//        呼叫watch()方法，屬於子類獨有的方法
//        an.watch();   不能直接使用

//1、向下轉型(呼叫子類獨有的方法）
  /*      Dog dog = (Dog) an;
        dog.watch();*/
//      優化、判斷物件是否是Dog物件，如果是再呼叫watch()方法
        if (an instanceof Dog) {
//能走到這裡說明條件滿足
            Dog dog = (Dog) an;
            dog.watch();
        }
    }
}

測試結果：　