java 重载类型转换_重载，重写，类型转换

首先来看重载和类型转化

package com.cxy;public classOverriiderDemo {public static voidmain(String[] args) {byte a =20;

test(a);

}public static void test(inta){

System.out.println("iiiiiiiiiiiiiiii");

}/*public static void test(byte a){

System.out.println("bbbbbbbbbbbbb");

}*/

public static void test(shorta){

System.out.println("ssssssssssss");

}public static void test(longa){

System.out.println("llllllllllllll");

}public static void test(chara){

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 classOverrideDemo1 extends Override {

@java.lang.Overridepublic void test(inta) {

super.test(a);

System.out.println("cxyaaaaaaaaaaaaa");

}

@java.lang.Overridepublic void test(bytea, String b) {

super.test(a, b);

}

@java.lang.Overridepublic void test(String b, bytea) {

super.test(b, a);

}

}

可以看到子类中没有重新父类的btye参数类型的方法，

执行结果：

执行的是父类的方法，没有去执行子类那个int的方法，再看下，如果注释掉父类的那个，如何执行呢：

package com.cxy;public classOverride {public void test(inta){

System.out.println("iiiiiiiiiiiiiiii");

}public void test(bytea,String b){

System.out.println("bbbbbbbbbbbbb");

}public void test(String b,bytea){

System.out.println("bbb+++++++++++aaaaa");

}

}

package com.cxy;public classOverrideDemo1 extends Override {

@java.lang.Overridepublic void test(inta) {

super.test(a);

System.out.println("cxyaaaaaaaaaaaaa");

}

@java.lang.Overridepublic void test(bytea, String b) {

super.test(a, b);

}

@java.lang.Overridepublic void test(String b, bytea) {

super.test(b, a);

}public void test(bytea){

System.out.println("cxy ++++++++++++bbbbbbbbbbbbbb");

}

}

package com.cxy;public classDemo {public static voidmain(String[] args) {

OverrideDemo1 overrideDemo1=newOverrideDemo1();byte a =10;

overrideDemo1.test(a);

}

}

执行结果：

接下来看第三种：

package com.cxy;public classOverrideDemo1 extends Override {

@java.lang.Overridepublic void test(inta) {

super.test(a);

System.out.println("cxyaaaaaaaaaaaaa");

}

@java.lang.Overridepublic void test(bytea, String b) {

super.test(a, b);

}

@java.lang.Overridepublic void test(String b, bytea) {

super.test(b, a);

}/*public void test(byte a){

System.out.println("cxy ++++++++++++bbbbbbbbbbbbbb");

}*/}

注释掉那个同参的方法：

两个都执行了，在修改：

package com.cxy;public classOverride {public void test(inta){

System.out.println("iiiiiiiiiiiiiiii"+(a+20));

}public void test(bytea,String b){

System.out.println("bbbbbbbbbbbbb");

}public void test(String b,bytea){

System.out.println("bbb+++++++++++aaaaa");

}

}

package com.cxy;public classOverrideDemo1 extends Override {

@java.lang.Overridepublic void test(inta) {

super.test(a);

System.out.println("cxyaaaaaaaaaaaaa"+(a+30));

}

@java.lang.Overridepublic void test(bytea, String b) {

super.test(a, b);

}

@java.lang.Overridepublic void test(String b, bytea) {

super.test(b, a);

}/*public void test(byte a){

System.out.println("cxy ++++++++++++bbbbbbbbbbbbbb");

}*/}

package com.cxy;public classDemo {public static voidmain(String[] args) {

OverrideDemo1 overrideDemo1=newOverrideDemo1();byte a =10;

overrideDemo1.test(a);

System.out.println(a);

} }

再执行：

可以看到执行之后值还是没变。

值传递的是值副本。

如果变量采用volite关键字修饰呢：

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