java问题：请问同一个类中可以有2个名字相同的函数吗？为啥啊？

Posted 2023-04-23

参考技术A 可以，函数的重载，名字相同，参数列表不同，或者参数类型不同，都是可以的 参考技术B package dl.java.baidu.faq;

/*******************************************************************************
* 重载
*
* @author ZZY
* @date 200-09-03
*/
public class MyOverLoad

// 主函数，入口
public static void main(String[] args)
System.out.println("main function ...");
// 这里调用重载的函数
main();
main(12);
main("Tom",12);
main(12,"Tom");
System.out.println(main(1,2));



// 重载类型1： 重载main函数,没有参数列表实现重载
public static void main()
System.out.println("overload main function ...");


//重载类型2：相同参数列表数，不同参数类型
public static void main(int args)
System.out.println(args);


//重载类型3：不同的参数列表，同时可以改变参数列表的数据类型实现重载
public static void main(String name,int age)
System.out.println(name+" 年龄： "+ age);


//重载类型4：相同参数个数及相同参数数据类型，但参数数据类型顺序不同实现重载
public static void main(int age,String name)
System.out.println(name+" 年龄： "+ age);


//重载类型4：根据函数返回值不同，重载
public static boolean main(int a,int b)

return a==b;




打印结果：
main function ...
overload main function ...
12
Tom 年龄： 12
Tom 年龄： 12
false本回答被提问者采纳

Java 子类继承父类成员中的问题

　　之前搞错了，变量没有“重写”一说，只有方法才能被“重写”。如果我们在子类中声明了一个和父类中一样的变量，那么实际的情况是，子类的内存堆中会有类型和名字都相同的两个变量。

　　现在考虑一种情况，如下所示，我们在子类中声明一个名字与父类中变量一样，但是类型不同的变量i（一个int，一个double），同时我们在父类中有一个print()打印i，那么当我们从子类的对象中调用这个print()时，他到底会打印哪一个i？

class SuperClass {
    public  int i;
    SuperClass(){
        i=10;
        System.out.println("SuperClass() is construted.");
    }
    public void print(){
        System.out.println("the i in SuperClass: "+i);
    }
}

class SubClass extends SuperClass {
    public double i;
    SubClass(){
        i=20.0;
        System.out.println("SubClass() is constructed.");
    }
    public void printSub(){
        System.out.println("the i in SubClass: "+i);
    }
}

public class TestDemo {
    public static void main(String[] args) {
        SubClass sub=new SubClass();
        System.out.println("sub.i is: "+sub.i);
        sub.printSub();
        sub.print();
    }
}

输出结果为：
SuperClass() is construted.
SubClass() is constructed.
sub.i is: 20.0
the i in SubClass: 20.0
the i in SuperClass: 10

 　　我们很清楚，如果在子类中重新声明一个同样的print()函数，父类的print()函数就会被覆盖掉，这时print()输出的是在子类中定义的double i=20.0，所以对这种情况我没有讨论。

　　从输出结果来看，通过子类SubClass的对象sub访问到的i的值为double i=20.0，然而通过子类对象调用在父类中定义的print()，打印的仍然是父类中的int i=10，如何解释这种情况？

 

　　现在我们把SubClass进行修改：

class SubClass extends SuperClass {
    public int i;
    SubClass(){
        i=20;
        System.out.println("SubClass() is constructed.");
    }
    public void printSub(){
        System.out.println("the i in SubClass: "+i);
    }
}

/*测试结果为*/
SuperClass() is construted.
SubClass() is constructed.
sub.i is: 20
the i in SubClass: 20
the i in SuperClass: 10

　　我们看到，就算是在子类SubClass中声明了一个完全一样的i，通过子类对象调用在父类中定义的print()，打印的仍然是父类中的int i=10。