面向對象的這些核心技術，你掌握後包你面試無憂

面向對象簡介

面向對象是相對於面向過程來講的，面向過程是一種以「過程」爲中心的編程思想，分析出解決問題所需的步驟，而後用函數把這些步驟一步步的實現，使用的時候一個個依次調用就好。而面向對象，是一種以「對象」爲中心的編程思想，把問題當作一個個對象，經過對象的屬性和行爲，將問題解決的。面向過程強調的是模塊化，而面向對象強調的是把事物對象化。

複雜來講面向對象是以「對象」爲基本單元構建系統，對象是把數據和數據操做方法放在一塊兒，做爲一個相互依存的總體。把同類的對象抽象出其共性，造成類。因此說類是對象的抽象，對象是類具體化的體現（類是大範圍的，一個類能夠有多個對象），類中的大多數數據只能經過本類的方法實現，類包含說明和實現，說明部分被外界所看到，經過簡單的外部接口與外界進行聯繫；實現部分不被外界所看到，在內部經過不一樣方法的構建，實現不一樣的功能。對象與對象之間經過消息進行溝通，程序流程由用戶在使用中決定。

面向對象用以解決愈來愈複雜的需求，提升了軟件的重用性，靈活性和拓展性。

static關鍵字

static表示「靜態」的意思，能夠用來修飾成員變量和成員方法。 static的主要做用在於建立獨立於具體對象的域變量或者方法 簡單理解： 被static關鍵字修飾的方法或者變量不須要依賴於對象來進行訪問，只要類被加載了，就能夠經過類名去進行訪問， 而且不會由於對象的屢次建立而在內存中創建多份數據。

1. 靜態成員 在類加載時加載並初始化。
2. 不管一個類存在多少個對象 , 靜態的屬性, 永遠在內存中只有一份( 能夠理解爲全部對象公用 )
3. 在訪問時： 靜態不能訪問非靜態 , 非靜態能夠訪問靜態 !
   靜態方法調用的三種方式：
   1.new xx().靜態(); //使用對象調用，不推薦
   2.xx.靜態(); //類名調用，正規調用方法，推薦
   3.靜態(); //本類的靜態方法在本類調用，直接調用
   注意事項：
   在同包不一樣類調用的時候，能夠直接 類名.方法() 調用，無需建立對象。
   在不一樣包調用的時候，須要引包再調用。

代碼示例：

package com.vedio.highobject;

public class Pool {
    public static int water=0;//靜態變量

    public static void outlet() {//放水
        if(water>=2) {
            water=water-2;
        }else {
            water=0;
        }
    }

    public static void inlet() {//進水
        water=water+3;
    }

    public static void main(String[] args) {
        System.out.println("水池的水量："+water);
        System.out.println("水池注水兩次。");
        Pool.inlet();
        Pool.inlet();
        System.out.println("水池的水量："+water);
        System.out.println("水池放水一次。");
        Pool.outlet();
        System.out.println("水池的水量："+water);
    }
}

注意：在類中調用靜態方法和靜態方法時，須要使用類名.變量名或類名.方法名調用，在本類中調用靜態方法和靜態方法時，能夠不加類名。

instanceof關鍵字

只有存在繼承關係，才能使用instanceof關鍵字，不然會報錯

代碼示例：

//只有存在繼承關係，才能使用instanceof關鍵字，不然會報錯
public class Computer {//電腦類
    public static void main(String[] args) {
        Pad ipad=new Pad();
        LenovoPad lenovoPad=new LenovoPad();
        System.out.println("Pad是否繼承自電腦?"+(ipad instanceof Computer));
        System.out.println("LenovoPad是否繼承自Pad?"+(lenovoPad instanceof Pad));
        System.out.println("Pad是否繼承自LenovoPad?"+(ipad instanceof LenovoPad));
       // System.out.println("Pad是否繼承自人類?"+(ipad instanceof Person));//ipad與Person這個類沒有任何的繼承關係
    }
}

class Pad extends Computer{//平板電腦
}
class LenovoPad extends Pad{//聯想平板電腦
}

public class Person {
    public Person(String name){
        System.out.println("您好，我叫"+name);
    }
}

ipad和Person兩個類沒有任何繼承關係，因此使用instanceof時，會直接報錯。

euqals()方法

查看equals()源碼，以下

public boolean equals(Object obj) {
        return (this == obj);
    }

因此在object類中equals方法只能用來比較地址是否同樣，與==做用同樣。但當咱們能夠本身重寫equals方法，使之知足咱們的需求。

好比咱們定義一個Person類，只有id和name都同樣時，才肯定他們是同一我的。代碼示例：

package com.vedio.highobject;

public class Person {
    String name;
    String id;

    public boolean equals(Person p) {
        return this.name.equals(p.name)&&this.id.equals(p.id);
    }
}

package com.vedio.highobject;

public class Demo1 {
    public static void main(String[] args) {
       Person p1=new Person();
       Person p2=new Person();
       Person p3=new Person();

       p1.name="小明";
       p1.id="123";

       p2.name="小紅";
       p2.id="123";

       p3.name="小明";
       p3.id="123";

       System.out.println(p1.equals(p2));
       System.out.println(p1.equals(p3));
       System.out.println(p2.equals(p3));
    }
}

能夠觀察到，只有id和name徹底同樣是，才爲true。經過重寫equals方法，知足了咱們的需求。

equals與==的區別

String可使用equals比較地址是由於它重寫了equals方法
查看String對equals方法的重寫源碼，以下：

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

equals是判斷兩個變量或者實例指向同一個內存空間的值是否是相同，而==是判斷兩個變量或者實例是否是指向同一個內存空間，
舉個通俗的例子來講，==是判斷兩我的是否是住在同一個地址，而equals是判斷同一個地址裏住的人是否是同一個
代碼示例：

package com.vedio.highobject;

public class Demo2 {
    public static void main(String[] args) {
        String s1=new String("123");
        String s2=new String("123");
        System.out.println(s1.equals(s2));
        System.out.println(s1==s2);
        String s3="123";
        String s4="123";
        System.out.println(s3.equals(s4));
        System.out.println(s3.equals(s1));

    }
}

toString()方法

package com.object.high;

//全部類的父類 --Object類
//在Java中，全部的類都直接或間接繼承了java.lang.Object類
//因爲全部的類都是Object類的子類，因此任何類均可以重寫Object類中的方法

public class Hello {

    //重寫toString()方法
    public String toString(){
        return "Say \""+getClass().getName()+"\" to Java";//getClass().getName()獲取類的名稱
    }

    public static void main(String[] args) {
        System.out.println(new Hello());//當打印某個類對象時，將自動調用重寫的toString()方法
    }
}

最後

感謝你看到這裏，文章有什麼不足還請指正，以爲文章對你有幫助的話記得給我點個贊，天天都會分享java相關技術文章或行業資訊，歡迎你們關注和轉發文章！