重載，重寫，類型轉換

首先來看重載和類型轉化

package com.cxy;

public class OverriiderDemo {
    public static void main(String[] args) {
        byte a =20;
        test(a);

    }
    public static void test(int a){
        System.out.println("iiiiiiiiiiiiiiii");
    }
  /*  public static void test(byte a){
        System.out.println("bbbbbbbbbbbbb");
    }*/
    public static void test(short a){
        System.out.println("ssssssssssss");
    }
    public static void test(long a){
        System.out.println("llllllllllllll");
    }
    public static void test(char a){
        System.out.println("cccccccccccccccccccc");
    }
}

 

 重載的原理：看參數類表，參數類型，參數個數，參數順序

那麼java中存在自動類型轉換，那麼到底怎麼結果呢

能夠看到結果，爲byte的，那麼就意味中重載的時候，首先看參數個數，再看類型，再看參數順序，

那麼註釋掉byte的方法會執行結果爲哪一個呢：、

 

 那麼爲何轉化爲int呢，要轉換爲short呢

解釋：基礎數據類型，首先考慮的是精度問題，byte佔一個字節，那麼二進制的時候是八位，short爲兩個字節，int爲4字節，因此在這個過程當中

首先轉爲short，那麼再註釋掉，short呢，首先考慮的是int，而後再是long，

 

 

在這種狀況下，是不報錯的，就是因爲類型轉換。重載首先考慮的就是參數個數，能夠得出

 

因此能夠看出。第二點看的就是參數順序。

 

最後考慮的是類型。

 

重寫：

package com.cxy;

public class Override {
    public  void test(int a){
        System.out.println("iiiiiiiiiiiiiiii");
    }
    public  void test(byte a){
        System.out.println("bbbbbbbbbbbbbb");
    }
    public  void test(byte a,String b){
        System.out.println("bbbbbbbbbbbbb");
    }
    public  void test(String b,byte a){
        System.out.println("bbb+++++++++++aaaaa");
    }

}

package com.cxy;

public class OverrideDemo1 extends Override {
    @java.lang.Override
    public void test(int a) {
        super.test(a);
        System.out.println("cxyaaaaaaaaaaaaa");
    }

    @java.lang.Override
    public void test(byte a, String b) {
        super.test(a, b);
    }

    @java.lang.Override
    public void test(String b, byte a) {
        super.test(b, a);
    }


}

能夠看到子類中沒有從新父類的btye參數類型的方法，

執行結果：

 

 

執行的是父類的方法，沒有去執行子類那個int的方法，再看下，若是註釋掉父類的那個，如何執行呢：

package com.cxy;

public class Override {
    public  void test(int a){
        System.out.println("iiiiiiiiiiiiiiii");
    }

    public  void test(byte a,String b){
        System.out.println("bbbbbbbbbbbbb");
    }
    public  void test(String b,byte a){
        System.out.println("bbb+++++++++++aaaaa");
    }

}

package com.cxy;

public class OverrideDemo1 extends Override {
    @java.lang.Override
    public void test(int a) {
        super.test(a);
        System.out.println("cxyaaaaaaaaaaaaa");
    }

    @java.lang.Override
    public void test(byte a, String b) {
        super.test(a, b);
    }

    @java.lang.Override
    public void test(String b, byte a) {
        super.test(b, a);
    }
    public  void test(byte a){
        System.out.println("cxy ++++++++++++bbbbbbbbbbbbbb");
    }

}

package com.cxy;

public class Demo {
    public static void main(String[] args) {
        OverrideDemo1 overrideDemo1 =new OverrideDemo1();
        byte a =10;
        overrideDemo1.test(a);
    }
}

執行結果：

 

 

 接下來看第三種：

package com.cxy;

public class OverrideDemo1 extends Override {
    @java.lang.Override
    public void test(int a) {
        super.test(a);
        System.out.println("cxyaaaaaaaaaaaaa");
    }

    @java.lang.Override
    public void test(byte a, String b) {
        super.test(a, b);
    }

    @java.lang.Override
    public void test(String b, byte a) {
        super.test(b, a);
    }
   /* public  void test(byte a){
        System.out.println("cxy ++++++++++++bbbbbbbbbbbbbb");
    }*/

}

註釋掉那個同參的方法：

 

 兩個都執行了，在修改：

package com.cxy;

public class Override {
    public  void test(int a){
        System.out.println("iiiiiiiiiiiiiiii"+(a+20));
    }

    public  void test(byte a,String b){
        System.out.println("bbbbbbbbbbbbb");
    }
    public  void test(String b,byte a){
        System.out.println("bbb+++++++++++aaaaa");
    }

}

package com.cxy;

public class OverrideDemo1 extends Override {
    @java.lang.Override
    public void test(int a) {
        super.test(a);
        System.out.println("cxyaaaaaaaaaaaaa"+(a+30));
    }

    @java.lang.Override
    public void test(byte a, String b) {
        super.test(a, b);
    }

    @java.lang.Override
    public void test(String b, byte a) {
        super.test(b, a);
    }
   /* public  void test(byte a){
        System.out.println("cxy ++++++++++++bbbbbbbbbbbbbb");
    }*/

}

package com.cxy;

public class Demo {
    public static void main(String[] args) {
        OverrideDemo1 overrideDemo1 =new OverrideDemo1();
        byte a =10;
        overrideDemo1.test(a);

System.out.println(a);

} }

再執行：

 

 能夠看到執行以後值仍是沒變。

值傳遞的是值副本。

若是變量採用volite關鍵字修飾呢：

 

 能夠看到是報錯的，多線程操做下的關鍵字，不能夠修飾，一般用它那個修飾類變量，多線程的原理，就是線程操做資源類