重载，重写，类型转换
首先来看重载和类型转化
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关键字修饰呢：
可以看到是报错的，多线程操作下的关键字，不可以修饰，通常用它那个修饰类变量，多线程的原理，就是线程操作资源类
