重载，重写，类型转换

首先来看重载和类型转化

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，

在这种情况下，是不报错的，就是由于类型转换。重载首先考虑的就是参数个数，可以得出

所以可以看出。第二点看的就是参数顺序。

 这个地方为什么直接报错呢：

char的值是0-65536，没有负数，byte类型有负数，所以没有自动转换，再看案例：

再看

 char转化为unicode编码，所以可以使用数组来

最后考虑的是类型。

重写：

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关键字修饰呢：

 可以看到是报错的，多线程操作下的关键字，不可以修饰，通常用它那个修饰类变量，多线程的原理，就是线程操作资源类