类的成员之方法

Myth丶恋晨 2023-10-04 08:44 32阅读 0赞

# 思维导图 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70][]

# 思考题 #

## 1、实参符合多个重载方法形参要求，如何确认调用哪个重载方法？（重载方法考察） ##

### 重载方法形参类型匹配 ###

public class OverLoadTest2 {
        public void get(Super s){
            System.out.println("super");
        }
    
        public void get(Base b){
            System.out.println("Base");
        }
    
        public static void main(String[] args) {
            OverLoadTest2 o = new OverLoadTest2();
    
            Super s = new Base();
            Base b = new Base();
            o.get(s);
            o.get(b);
        }
    }
    
    class Super{}
    
    class Base extends Super{}

当重载方法间的只有参数类型种类不一致，且参数类型是父子类关系
    
    先匹配（形参是子类类型）的重载方法，若实参可以匹配上（不要做任何强转），则就会调用该重载方法。
    若匹配不上，则
    再匹配（形参是父类类型）的重载方法，若实参可以匹配上（不要做任何强转），则就会调用该重载方法。
    若还匹配不上，则编译报错。

如果还是不很理解，就继续看下面这个代码

public class OverLoadTest {
        public void get(Object obj){
            System.out.println("object");
        }
    
        public void get(String str){
            System.out.println("string");
        }
    
        public static void main(String[] args) {
            new OverLoadTest().get(null);
        }
    }

### 重载方法参数个数匹配（对可变参数方法的重载） ###

public class OverLoadTest3 {
        void test(String... str){
            System.out.println("可变形参方法");
        }
    
        void test(String str){
            System.out.println("只有一个形参方法");
        }
    
        void test(String str1,String str2){
            System.out.println("有两个形参的方法");
        }
    
        public static void main(String[] args) {
            OverLoadTest3 o = new OverLoadTest3();
            o.test("123");
            o.test("123","456");
            o.test("123","456","789");
        }
    }

对于可变形参方法，和固定个数形参的重载方法匹配优先级：
    
    先匹配固定个数形参的重载方法，若匹配则调用该方法
    若不匹配
    再调用可变形参的重载方法

### 重载方法既包括个数匹配，也包括类型匹配，哪个优先级高 ###

public class OverLoadTest4 {
        void test(String... str){
            System.out.println("string...");
        }
    
        void test(Object obj){
            System.out.println("object");
        }
    
        public static void main(String[] args) {
            OverLoadTest4 o = new OverLoadTest4();
            o.test("123");// 个数匹配 优先于 类型匹配
        }
    }

重载方法优先 参数个数匹配，后进行类型匹配

## 2、如果方法定义返回void，则方法体中不能出现return语句？（return关键字作用考察） ##

如果方法定义返回值类型为void，方法体中是可以出现return的。
    
    但是return后不能带有任何返回值。
    
    仅能使用 return;
    
    而且此时 return的作用不是返回值，而是结束方法。

## 3、下面方法会编译出错的是（return关键字作用考察） ##

public class Demo{
    	float fun1(){
    		int i = 1;
    		return;
    	}
    	
    	float fun2(){
    		short i = 2;
    		return i;
    	}
    	
    	float fun3(){
    		long i = 3;
    		return i;
    	}
    	
    	float fun4(){
    		double i = 4;
    		return i;
    	}
    }

fun1 方法体return没有返回值，所以理论上方法返回值类型只能是void，而当前是float，所以fun1会编译报错
    
    fun2 方法体return short值，而short值是可以自动转为float，
    fun3 方法体return long值，而long值是可以自动转为float的
    
    具体数值类型之间的转换规则是
    
    byte->short
                ->int->long->float->double
           char
    
    而fun4 方法体return double,而double是不能自动转换为double的，所以fun4也会编译报错

## 4、下面程序运行结果i是多少?（方法参数传递考察） ##

public class Demo{
    	public static void main(String[] args){
    		Integer i = 10;
    		method(i);
    		System.out.println(i);
    	}
    	
    	public static void method(Integer j){
    		j = j + 10;
    	}
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 1][]

图中①表示对应  代码  method(i)；
    
    由于i是Integer类型，所以method(i)中i实际传递的是地址值，即引用。
    
    所以method方法形参j也指向10这个Integer对象
    
    但是j=j+10;后，j的指向变了，也就是图中②，③两步。
    
    
    所以最终输出的i的值还是10.
    
    这题考察的是方法中参数传递的问题。再Java中方法的参数传递都是值传递，即当前变量的值的拷贝。
    
    对于
    
    基本类型来说，就是单纯的值拷贝。
    
    但是对于
    
    引用类型来说，这里的值拷贝是变量的地址值拷贝。
    
    ---------------------------------------------------------------------
    
    另外这题还有另外一个考察点，就是Integer类的内部实现
    
    public final class Integer{
        private final int value;
        ....
    }
    
    我们需要知道被final修饰的类不是不可变类，是最终类，不能派生子类的类。
    而不可变类是指类的实例的实例变类不可以改变。
    而Integer的唯一实例变量value，也是被final修饰的。
    
    所以Integer j变量的指向可以改变，但是内部0x1255指向的常量，这个指向是不能改变的。

## 5、静态方法中可以使用this关键字吗 ##

不可以。
    
    this在方法中使用时，指代正在调用该该方法的对象。
    
    而静态方法不属于对象，属于类本身。
    
    虽然可以使用对象调用静态方法，但是内部还是使用类去调用静态方法。
    
    所以静态方法的调用者只能是类本身，不会有对象作为调用者。
    
    所以静态方法中不能有this关键字。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210319110702597.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210318224113323.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70