修飾符static和abstract

赤葉秋楓發表於2021-03-14

修飾符static和abstract

static

static可以修飾類中的方法，屬性等，被修飾後的方法和屬性可以通過類名直接呼叫也可以通過物件呼叫。普通的變數只能通過物件進行呼叫。

靜態方法直接可以互相直接呼叫，非靜態方法也可以直接呼叫靜態方法，但是靜態方法不能直接呼叫非靜態方法。

eg：

package shiyan;

public class Person {
    public static int age; //靜態屬性
    public int score;      //非靜態
    public static void go(){ //靜態方法
        System.out.println("靜態方法");
    }
    public void run()//非靜態
    {
        System.out.println("非靜態");
    }
    public static void main(String[] args) {
      Person.age=1; //通過類呼叫
      Person.go(); //通過類呼叫
      go();     //靜態方法互相呼叫
        Person p1=new Person();//建立物件
             p1.score=22;     //只能通過物件呼叫
             p1.run();        //只能通過物件呼叫
             p1.age=1;        //通過物件
             p1.go();         //通過物件
    }
}

靜態程式碼塊

在類內將程式碼通過static{}括起來，在構造器之前執行，僅執行一次。類似的還有匿名程式碼塊{}。

eg：

package shiyan;

public class StaticStatement {
     static {
        System.out.println("靜態程式碼塊"); //僅執行一次
            }
       {
           System.out.println("匿名程式碼塊");//每次建物件都執行
       }
          public StaticStatement()  //每次建物件都執行
         {
           System.out.println("構造器");
         }


    public static void main(String[] args) {
        StaticStatement s1=new StaticStatement();
        StaticStatement s2=new StaticStatement();
    }
}

執行結果：

靜態程式碼塊
匿名程式碼塊
構造器
匿名程式碼塊
構造器

靜態匯入包

匯入包時，僅僅匯入類內的單個方法或屬性

匯入後可以直接使用該方法，不需要使用類呼叫方法。

eg：

import static java.lang.Math.random; //靜態匯入包random
import static java.lang.Math.PI;  //靜態匯入包 PI為 π是常量
public class Test{
    public static void main(String[] args)
    { 
    System.out.print(random());   //直接呼叫Math類的方法random() 
         System.out.print(PI); 
    }
}

abstract

abstract抽象類，抽象類不能例項化，他只是一個約束後面可以理解為會有人幫我們實現具體的功能。抽象類裡可以有抽象類也可以有普通方法，但是普通類內不能存在抽象方法。

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

eg：

//父類：
package shiyan;

public abstract class Abstract {
    public Abstract(){
        System.out.println("Abstract的構造器");
    }
    public static void go(){
        System.out.println("Abstract的普通方法");
    }

    public abstract void run();//僅僅約束，證明有這個方法方法沒有實現的方法體

    public static void main(String[] args) {

    }
}




//子類：

package shiyan;

public class  Son extends Abstract {//繼承
    @Override
    public void run() { //實現方法
        System.out.println("子類實現父類的抽象方法");
    }

       public Son()
       {
           System.out.println("StaticStatement的構造器");
       }


    public static void main(String[] args) {
    Son s1=new Son();
        s1.run();//抽象方法，實現體已寫
        s1.go();//繼承自抽象類的普通方法
    }
}

主要還是為了提高效率減少重複的程式碼，對於可以直接使用的用普通方法可以直接繼承使用，對於有變化的可以使用抽象方法每次重新寫出實現。

static可以修飾類中的方法，屬性等，被修飾後的方法和屬性可以通過類名直接呼叫也可以通過物件呼叫。普通的變數只能通過物件進行呼叫。

靜態方法直接可以互相直接呼叫，非靜態方法也可以直接呼叫靜態方法，但是靜態方法不能直接呼叫非靜態方法。

eg：

package shiyan;

public class Person {
    public static int age; //靜態屬性
    public int score;      //非靜態
    public static void go(){ //靜態方法
        System.out.println("靜態方法");
    }
    public void run()//非靜態
    {
        System.out.println("非靜態");
    }
    public static void main(String[] args) {
      Person.age=1; //通過類呼叫
      Person.go(); //通過類呼叫
      go();     //靜態方法互相呼叫
        Person p1=new Person();//建立物件
             p1.score=22;     //只能通過物件呼叫
             p1.run();        //只能通過物件呼叫
             p1.age=1;        //通過物件
             p1.go();         //通過物件
    }
}

靜態程式碼塊

在類內將程式碼通過static{}括起來，在構造器之前執行，僅執行一次。類似的還有匿名程式碼塊{}。

eg：

package shiyan;

public class StaticStatement {
     static {
        System.out.println("靜態程式碼塊"); //僅執行一次
            }
       {
           System.out.println("匿名程式碼塊");//每次建物件都執行
       }
          public StaticStatement()  //每次建物件都執行
         {
           System.out.println("構造器");
         }


    public static void main(String[] args) {
        StaticStatement s1=new StaticStatement();
        StaticStatement s2=new StaticStatement();
    }
}

執行結果：

靜態程式碼塊
匿名程式碼塊
構造器
匿名程式碼塊
構造器

靜態匯入包

匯入包時，僅僅匯入類內的單個方法或屬性

匯入後可以直接使用該方法，不需要使用類呼叫方法。

eg：

import static java.lang.Math.random; //靜態匯入包random
import static java.lang.Math.PI;  //靜態匯入包 PI為 π是常量
public class Test{
    public static void main(String[] args)
    { 
    System.out.print(random());   //直接呼叫Math類的方法random() 
         System.out.print(PI); 
    }
}

abstract

abstract抽象類，抽象類不能例項化，他只是一個約束後面可以理解為會有人幫我們實現具體的功能。抽象類裡可以有抽象類也可以有普通方法，但是普通類內不能存在抽象方法。

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

eg：

//父類：
package shiyan;

public abstract class Abstract {
    public Abstract(){
        System.out.println("Abstract的構造器");
    }
    public static void go(){
        System.out.println("Abstract的普通方法");
    }

    public abstract void run();//僅僅約束，證明有這個方法方法沒有實現的方法體

    public static void main(String[] args) {

    }
}




//子類：

package shiyan;

public class  Son extends Abstract {//繼承
    @Override
    public void run() { //實現方法
        System.out.println("子類實現父類的抽象方法");
    }

       public Son()
       {
           System.out.println("StaticStatement的構造器");
       }


    public static void main(String[] args) {
    Son s1=new Son();
        s1.run();//抽象方法，實現體已寫
        s1.go();//繼承自抽象類的普通方法
    }
}

主要還是為了提高效率減少重複的程式碼，對於可以直接使用的用普通方法可以直接繼承使用，對於有變化的可以使用抽象方法每次重新寫出實現。

相關文章