static(靜態）

1.概念

關鍵字，修飾符 變數，方法，程式碼塊，內部類

2.靜態變數

靜態變數隨着類的載入（方法區的靜態常數池）而載入到方法區的靜態區， 相當於與類同級也叫類變數，通過類名。形式來呼叫靜態變數也可以通過物件來
呼叫靜態變數。儲存在方法區靜態區時會預設給靜態變數賦予系統預設初始值。
類產生的物件共用同一個靜態變數。看靜態變數是否需要被所有的物件來共用， 如果需要共用就設定成靜態變數。

方法裡可以定義靜態變數？ 靜態變數與類同級，只有方法被呼叫時裏面的內容才能 纔能出現，前後矛盾，不能 定義

package cn.tedu.staticx;
public class StaticDemo1 {
    public static void main(String[] args) {
        //建立Person類的物件
        Person p=new Person();
        p.name="郭靖";
        p.age=19;
        p.gender='男';
        Person p1=new Person();
        p1.name="黃蓉";
        p1.age=18;
        p1.gender='女';
        //輸出
        System.out.println(p.toString());
        System.out.println(p1.toString());
    }
}
//定義代表人的類
class Person{
    //屬性
    String name;
    int age;
    static char gender;
    //定義方法來輸出物件的屬性值
    public String toString(){
        return this.name+","+this.age+","+this.gender;
    }
}

*3.靜態方法

靜態方法會隨着類的載入而載入到方法區的靜態區，與類同級也叫做類方法， 通過類名.形式來呼叫也可以通過物件呼叫。靜態區不會對靜態方法賦予初始化
值但是被呼叫就會被載入到棧中執行。

java中靜態資訊可以直接使用靜態資訊，但是非靜態資訊可以直接使用非靜態以及 靜態。

package cn.tedu.staticx;
public class StaticDemo2 {
    //靜態變數
    static int i=1;
    //非靜態變數
    int j=2;
    //靜態方法
    //靜態方法可以直接使用靜態資訊不能直接使用非靜態資訊
    public static void m(){
        System.out.println(i);
        //System.out.println(j);
    }
    //非靜態方法
    //非靜態方法可以直接使用靜態資訊以及非靜態資訊
    public void n(){
        System.out.println(i);
        System.out.println(j);
    }
}

支援過載？支援過載
支援重寫？不支援重寫 靜態方法與類同級，重寫針對的是物件級別不一樣，靜態方法沒有提供重寫。父子類中要麼出現方法簽名一致的都是非靜態方法（重寫）要麼都是靜態方法（ 沒有重寫）。

Arrays.sort()、Arrays.copyOf()、System.arraycopy()、Arrays.toString()

package cn.tedu.staticx;
public class StaticDemo3 {
    public static void main(String[] args) {
        //向上造型
        SDemo s=new SDemo1();
        //向上造型物件執行的是子類方法證明發生重寫
        s.m();
    }
}
class SDemo{
    public void m(){
        System.out.println(1);
    }
    public static void n(){}
}
class SDemo1 extends SDemo{
    //註解---給計算機看的註釋
    // @Override表面下面 下麪的方法是重寫方法
    @Override
    public void m(){
        System.out.println(2);
    }
    //加註 加注解在報錯說明不是重寫方法
    //靜態方法與類同級
    //重寫---執行時多型---針對的是物件---和物件一個級別
    //靜態方法就沒有提供重寫
    //@Override
    public static void n(){}
}

4.靜態程式碼塊

a.可以給靜態變數進行初始化 b.預先載入資源 c.隨着類的載入而載入只載入一次 d.static修飾的靜態資訊都只載入一次
e.父子類執行順序（父類別靜態資訊-子類靜態資訊-父類別物件級別資訊- 子類物件級別資訊）

package cn.tedu.staticx;
public class StaticDemo4 {
    public static void main(String[] args) {
        //匿名物件
        new SDemo2();
        new SDemo2();
    }
}
//
class SDemo2{
    static int i;//靜態變數
    //靜態程式碼塊
    //給靜態變數進行初始化
    //預先載入資源
    //因爲靜態程式碼塊隨着類的載入而載入，但是類只載入一次
    static {
        i=1;
        System.out.println("靜態程式碼塊");
    }
    {
        System.out.println("構造程式碼塊");
    }
    public SDemo2(){
        System.out.println("構造方法");
    }
}

package cn.tedu.staticx;
import javax.crypto.spec.PSource;
public class StaticText2 {
    public static void main(String[] args) {
        System.out.println(new STDemo().i);
    }
}
class STDemo{
   /* int i=5;
    {
        i+=1;
    }*/
   {
       i=1;
   }
   int i=3;
}

package cn.tedu.staticx;
public class StaticText3 {
    public static void main(String[] args) {
        System.out.println(new STDemo1().x+","+new STDemo1().y);
    }
}
class STDemo1{
    //StackOverflowError---棧溢位錯誤
   /* STDemo1 st=new STDemo1();//屬性
    int age=1;
    static int x;
    static int y=3;
    public STDemo1(){
        x++;
        y++;
    }*/




    /*
           載入        執行第一步   執行第二步   執行第三步
    *      st=null     st=0x01    st=0x01     st=0x01
           x=0          x=1        x=1         x=1
           y=0          y=1        y=1         y=3
    *
    * */
    static STDemo1 st=new STDemo1();
    static int x;
    static int y=3;
    public STDemo1(){
        x++;
        y++;
    }
}

package cn.tedu.staticx;
public class StaticText1 {
    public static void main(String[] args) {
        //
        new SB();
        new SB();
    }
}
class SA{
    //靜態變數---屬性初始化
    //static SD sd=new SD();
    //成員變數---非靜態
    //和構造程式碼塊一個級別，誰在前誰先執行
    SC sc=new SC();
    static {
        System.out.println("SA 1");
    }
    {
        System.out.println("SA 2");
    }
    public SA(){
        System.out.println("SA 3");
    }
}
class SB extends SA{
    static {
        System.out.println("SB 1");
    }
    {
        System.out.println("SB 2");
    }
    public SB(){
        System.out.println("SB 3");
    }
}
class SC{
    public SC(){
        System.out.println("SC");
    }
}
class SD extends SC{
    public SD(){
        System.out.println("SD");
    }
}

final（最終）

1.概念

關鍵字，修飾符 數據，方法，類

*2.最終值

當final修飾基本型別數據時，值不能改變
當final修飾參照數據型別時，地址值不能改變
當final修飾成員變數，保證物件建立完成之前給值
當final修飾靜態變數時（靜態常數），保證類載入完成之前給值

package cn.tedu.finalx;
public class FinalDemo1 {
    public static void main(String[] args) {
        //當參照指向數據可以改變時表面是變數
        int x=1;
        //當final修飾基本型別數據時保證值不能改變
        //當參照指向數據不能改變時就是常數
        final int i=1;//自定義常數
        int j=i+1;
        //i++;
        //當final修飾參照型別數據時是地址值不能改變
        final int[] arr={1,2,3};
        arr[0]=10;
        //arr=new int[3];
        //陣列長度是被final修飾
        //arr.length=10;
    }
}

package cn.tedu.finalx;
public class FinalDemo2 {
}

class FDemo{
     //保證類載入完成之前給值
     final static int i;//靜態常數

     //靜態程式碼塊可以給靜態變數進行初始化
     static {
         i=2;
     }

    /*//屬性--成員變數
    //保證物件建立完成之前給值
    final int i;
    //來一個構造程式碼塊
    {
        i=2;
    }
    //保證每個構造方法都要賦值
    public FDemo(){
        i=2;
    }
    public FDemo(int j){
        i=j;
    }*/
}

3.最終方法

支援過載
不支援重寫

package cn.tedu.finalx;
public class FinalDemo3 {
}
class FDemo1{
    public final void n(){}
    //支援過載
    public final void n(int i){}
}
class FDemo2 extends FDemo1{
    //@Override
    //不支援重寫
    //public final void n(){}
}

4.最終類

可以繼承別的類不能不能被別的類繼承

package cn.tedu.finalx;
public class FinalDemo4 {
}
//最終類不能被繼承
final class FDemo3{}
//最終類可以繼承別的類
//class FDemo4 extends FDemo3{}

抽象類、介面、內部類、包