Java基礎 - 面向對象

時間 2021-02-20

標籤 java 編程安全 ide oop this 設計 code 對象繼承欄目 Java 简体版

原文原文鏈接

面向對象

1、概念

面向對象編程（Object-Oriented Programming,OOP）
- 本質：以類的方式組織代碼，以對象的組織(封裝)數據
類是對象的模版，對象是具體的，類是抽象的

2、對象的建立分析

變量類型 變量名 = 值
Student mo = new Student()

使用new關鍵字建立對象時，會對建立好的對象進行默認初始化，分配內存空間，以及對類中構造器的調用java

類的構造器：又稱構造方法，在建立對象時必需要調用的編程

快捷鍵：Alt+Ins安全
特色：ide
1. 必須和類的名字相同
2. 必須沒有返回類型，也不能寫void
做用：oop
1. 使用new關鍵字，本質是在調用構造器
2. 用來初始化值

劃分：this

無參構造設計

public class Creation {
    String name;
    public Creation(){
        this.name = "mo";
    } 
    public static void main(String[] args) {
        Creation creation = new Creation();
        System.out.println(creation.name);		//mo
    }
}

有參構造code

public class Creation {
    String name;
 public Creation(){}             //無參構造【加上無參構造，new時既可帶參數，也可不帶參數】
     public Creation(String na){       //有參構造
         this.name = na;
     }
     public static void main(String[] args) {
         Creation creation = new Creation("mo");
         System.out.println(creation.name);		//mo
     }
}

3、面向對象的三大特性

封裝

數據的隱藏【應禁止直接訪問一個對象中數據的實際表示，而應經過操做接口來訪問】
程序設計追求「高內聚，低耦合」
- 高內聚：類的內部數據操做細節本身完成，不容許外不干涉
- 低耦合：僅暴露少許的方法給外部使用
做用
- 提升了程序的安全性，保護數據
- 隱藏代碼的實現細節
- 統一接口
- 系統可維護性增長
快捷鍵：Alt+Ins

public class Packaging {
    private String name;
    private int age;
    public String getName(){    		//get得到這個數據
        return this.name;
    }
    public void setName(String name){	//set設置這個數據
        this.name = name;
    }
    public int getAge(){
        return this.age;
    }
    public void setAge(int age){
        if (age>=0 && age<=120){
            this.age = age;
        }else {
            this.age = 3;
        }
    }
    public static void main(String[] args) {
        Packaging packaging = new Packaging();
        packaging.setName("mo");
        System.out.println(packaging.getName());	//mo
        packaging.setAge(6);
        System.out.println(packaging.getAge());		//6
    }
}

繼承

繼承是類與類之間的關係，一個爲子類(派生類)、父類(基類)對象
- 子類繼承父類，使用關鍵字 extends 表示
- 子類繼承父類，會擁有父類全部方法，但私有屬性、方法不能繼承
- java中類只有單繼承，沒有多繼承
快捷鍵：Ctrl+H繼承
Object類
- 全部的類都默認直接或間接繼承Object
super
- super調用父類的構造方法，必須在構造方法的第一個
- 子類構造器中默認調用了父類構造器，且若顯示的話，必須放在子類構造器的第一行，不然會報錯

public class Blank{
    public static void main(String args[]){
        Student student = new Student();        //同時調用了子類無參構造和父類無參構造
        student.eat();
    }
}

class Person{
    public Person(){
        System.out.println("person的無參構造在調用");
    }
    public void eat(){
        System.out.println("person正在吃·····");
    }
}
class Student extends Person{
    public Student(){
        //隱藏代碼，調用子類構造器時會默認調用父類的無參構造
        super();  //若是顯示父類的無參構造，要放在子類無參構造的第一行    //person的無參構造在調用
        System.out.println("student的無參構造在調用");              //student的無參構造在調用
    }
    public void eat(){
        super.eat();                                       //"person正在吃·····"
        System.out.println("Student正在吃·····");                //"Student正在吃·····"
    }
}

方法重寫【override】
- 方法名相同，方法體不一樣
- 快捷鍵：Alt+Ins
- 前提：須要有繼承關係，子類重寫父類的方法
1. 方法名必須相同
2. 參數列表必須相同
3. 修飾符：範圍可擴大，但不能縮小【Public>Protected>Default>Private】
4. 拋出的異常：範圍能夠縮小，但不能擴大【Exception(大)】
- 不能進行方法重寫
  - static 方法，屬於類，不屬於實例
  - final 常量
  - private 私有

多態

多態：同一方法能夠根據發送對象的不一樣而採用多種不一樣的行爲方式
- 一個對象的實際類型是肯定的，但能夠指向對象的引用類型有不少

存在條件

須要有繼承關係
子類重寫父類方法
父類引用指向子類對象【father f1 = new son()】

public class Polymorphic {
    public static void main(String[] args) {
        student s1 = new student();
        Person s2 = new student();
        Object s3 = new student();

        s1.eat();   //st_eat
        s2.eat();   //st_eat        子類重寫父類的方法，執行子類的方法
        ((student) s2).run();   //st_run        父類不能調用子類獨有的方法，但能夠將父類強制轉爲子類(高轉低)，執行子類的方法
    }
}

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

class student extends Person{
    public void eat(){
        System.out.println("st_eat");
    }
    public void run(){
        System.out.println("st_run");
    }
}

A instanceof B -> 用於判斷A是不是B的實例
- 由於new Student()，故三個實例對象的實際類型都是Student，student的父類都會返回true
- 同時因爲存在引用類型的不一樣，與引用類型相聯繫返回false，無聯繫則會報錯
類型轉換【父(高) -> 子(低)：強制轉換】【子 -> 父：自動轉換，但可能丟失子類中獨有的方法】

//Person是Student的父類
Person obj = new Student();
Student student = (Student)obj	//強制轉換，並賦值
student.eat()		//轉換後就可使用子類的方法

4、抽象類

修飾符 abstract，修飾方法則爲抽象方法，修飾類則爲抽象類

抽象的抽象：約束

抽象類中能夠沒有抽象方法，但有抽象方法的類必定要聲明爲抽象類
抽象類中能夠有具體方法
抽象類不能使用 new 來建立對象，它是用來讓子類繼承的
抽象方法只有方法的聲明，沒有方法的實現，它是用來讓子類實現的
子類繼承抽象類，那麼就必需要實現抽象類沒有實現的抽象方法，不然該子類也要聲明爲抽象類

public class Abstract {
    public static void main(String[] args) {
        //new up1()   //報錯：'up1' is abstract; cannot be instantiated
    }
}

abstract class up1{
    public abstract void doSomething();     //抽象方法，只有方法名字，沒有方法的實現
}

class up2 extends up1{      //子類繼承抽象類，要對抽象方法進行重寫
    @Override
    public void doSomething() {
    }
}