本文主要是介绍java重载方法和类初始化详解，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

• 1 重载问题
  • 1.1 重载中null和有形参
  • 1.2 重载中string和stringbuffer
  • 1.3 重载中无参和不定长参数
• 2 初始化问题
  • 2.1 初始化顺序
  • 2.2 子类继承父类
  • 2.3 保护构造函数

1 重载问题

我们先看两段代码：

public classTest2 {  
   
    public static void main(String[] args) {  
        f1(null);  
        f2();  
    }  
    public static void f1(String s) {  
        System.out.println("执行哪个方法？我是String");  
    }  
   
    public static void f1(Object o) {  
        System.out.println("执行哪个方法？我是Object");  
    }  
    public static void f2(){  
        System.out.println("执行哪个方法？我是无参数");  
    }  
    public static void f2(String...strings){  
        System.out.println("执行哪个方法？我是不定长参数");  
    }  
}  

1.1 重载中null和有形参

我们在调用f1(null)，理论上调用两个方法都是可以运行的，但是jvm肯定不能两个方法都运行，只能选择其中的一个，它会选择哪个？jvm会选择 String参数的方法，因为根据方法重载中准确性的原则，从层次上看Object处在更上层，String是从Object继承过来的，调用String将更准确。

1.2 重载中string和stringbuffer

如果我再加一个方法

public static void f1(StringBuffer s) {  
        System.out.println("执行哪个方法？我是String");  
    }  

这时再调用f1(null);就不能通过编译，为什么呢？由于StringBuffer和String并没有继承上的关系，因此编译器感觉StringBuffer和String作为参数的方法都很准确，它就不知道该执行哪个方法了，会出现编译错误，违反了重载中唯一性的原则

1.3 重载中无参和不定长参数

而我们在调用f2();方法时，jvm又会执行哪个？答案是无参数的。其实不定长参数在编译器编译之后它会将这个f2(String...strings)编译成参数为数组的方法，我们可以通过代码证明：

Class clazz=Test2.class;  
        Method[]methods=clazz.getDeclaredMethods();  
        for (Method method :methods) {  
            System.out.println(method);  
        }      

结果为：public static void Test2.f2(java.lang.String[])

所以直接调用不传参数调用f2()自然就是调用无参数方法最正确。而如果没有f2(){......};这个方法我们调用f2()依然可以运行，这是因为不定长参数支持无参数，但是这里的支持无参数其实是编译器自动帮我们填充一个new String[]{""}的形式调用，所以，本质上来讲，就是一个以数组为参数的调用方法。并且如果我们定义一个void f2(String[] s)的方法会提示重复

2 初始化问题

2.1 初始化顺序

先说下java对象初始化步骤：

• 本类：静态变量->静态初始化块->变量->初始化块->构造函数
• 继承类：父类静态变量->父类静态初始化块->子类静态变量->子类静态初始化块->父类变量->父类初始化块->父类构造函数->子类变量->子类初始化块->子类构造函数

2.2 子类继承父类

缺省构造函数的问题：假如base类是父类，derived类是子类，首先要
说明的是由于先有父类后有子类，所以生成子类之前要首先有父类。
class是由class的构造函数constructor产生的，每一个class都有
构造函数，如果你在编写自己的class时没有编写任何构造函数，那么
编译器为你自动产生一个缺省default构造函数。这个default构造函数
实质是空的，其中不包含任何代码。但是一牵扯到继承，它的问题就出现
了。

如果父类base class只有缺省构造函数，也就是编译器自动为你产生的。
而子类中也只有缺省构造函数，那么不会产生任何问题，因为当你试图产生
一个子类的实例时，首先要执行子类的构造函数，但是由于子类继承父类，
所以子类的缺省构造函数自动调用父类的缺省构造函数。先产生父类的实例，然后再产生子类的实例。

class base{
}
class derived extends base{
public static void main(String[] args){
derived d=new derived();
}
}

下面我自己显式地加上了缺省构造函数：

class base{
base(){
	System.out.println("base constructor");
}
}
class derived extends base{
derived(){
	System.out.println("derived constructor");
}
public static void main(String[] args){
derived d=new derived();
}
}

执行结果如下：说明了先产生 base class然后是derived class

base constructor
derived constructor

我要说明的问题出在如果base class有多个constructor
而derived class也有多个constructor,这时子类中的构造函数缺省
调用那个父类的构造函数呢？答案是调用父类的缺省构造函数。
但是不是编译器自动为你生成的那个缺省构造函数而是你自己显式地
写出来的缺省构造函数。

class base{
base(){
System.out.println("base constructor");
}
base(int i){
System.out.println("base constructor int i");
}
}
class derived extends base{
derived(){
System.out.println("derived constructor");
}
derived(int i){
System.out.println("derived constructor int i");
}
public static void main(String[] args){
derived d=new derived();
derived t=new derived(9);
}
}

运行结果
base constructor
derived constructor
base constructor
derived constructor int i

如果将base 类的构造函数注释掉，则出错。

class base{
// base(){
// System.out.println("base constructor");
// }
base(int i){
System.out.println("base constructor int i");
}
}
class derived extends base{
derived(){
System.out.println("derived constructor");
}
derived(int i){
System.out.println("derived constructor int i");
}
public static void main(String[] args){
derived d=new derived();
derived t=new derived(9);
}
}

运行结果
derived.java:10: cannot resolve symbol
symbol : constructor base ()
location: class base
derived(){
^
derived.java:13: cannot resolve symbol
symbol : constructor base ()
location: class base
derived(int i){
2 errors

说明子类中的构造函数找不到显式写出的父类中的缺省构造函数，所以出错。

2.3 保护构造函数

那么如果你不想子类的构造函数调用你显式写出的父类中的缺省
构造函数怎么办呢？
如下例：

class base{
// base(){
// System.out.println("base constructor");
// }
base(int i){
System.out.println("base constructor int i");
}
}
class derived extends base{
derived(){
super(8);
System.out.println("derived constructor");
}
derived(int i){
super(i);
System.out.println("derived constructor int i");
}
public static void main(String[] args){
derived d=new derived();
derived t=new derived(9);
}
}

运行结果
base constructor int i
derived constructor
base constructor int i
derived constructor int i

super(i)表示父类的构造函数base(i)请大家注意
一个是super(i)一个是super(8)

结论：子类如果有多个构造函数的时候，父类要么没有构造函数，让编译器自动产生，那么在执行子类构造函数之前先执行编译器自动产生的父类的缺省构造函数；要么至少要有一个显式的缺省构造函数可以让子类的构造函数调用

这篇关于java重载方法和类初始化详解的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！