精华内容
下载资源
问答
  • Java中的方法重载

    2020-10-28 15:23:45
    Java中的方法重载 ** 定义: 方法重载 是指一个类中定义多个同名的方法,但是要求每个方法具有不同的参数类型或者参数的个数。在调用重载方法时,Java编译器能通过检查调用方法的参数类型和个数选择一个恰当的方法...

    **

    Java中的方法重载

    **
    定义: 方法重载 是指一个类中定义多个同名的方法,但是要求每个方法具有不同的参数类型或者参数的个数。在调用重载方法时,Java编译器能通过检查调用方法的参数类型和个数选择一个恰当的方法。

    作用域: 方法重载一般是用于创建完成一组相似但参数的类型或者参数的个数或者参数的顺序不同的方法。

    解释: Java中的方法重载就是在类中可以创建多个方法,它们可以有相同的名字,但必须具有不同的参数,或者是参数的个数不同,或者是参数的类型不同。调用方法时通过传递给它们不同个数和类型的参数,以及传入参数的顺序来决定具体使用哪个方法。

    Java方法的重载: 返回类型修饰符可以相同,也可以不相同。要求同名的方法必须有不同的参数表,仅有返回类型不同是不足以区分两个重载的方法。 通过以下两个例子就能够说明在Java如何实现方法的重载的。

    例1:

    public class MethodOverloading{
        public void show(String str){
                ... ...
        }
        public void show(int i){
               ... ...
        }
        public void show(double d){
            ... ...
        }
        public void show(int i,double d){
            ... ...
        }
    }
    public class TestDemo {
        public static void main(String[] args) {
            //此时将根据参数的类型和个数的不同执行不同的方法体
            System.out.println(add(10, 20));
            System.out.println(add(30, 40, 50));
            System.out.println(add(1.1, 2.1));
        }
        public static int add(int x, int y) {
            return x + y;
        }
        //此时方法名称相同,参数的个数不同
        public static int add(int x, int y, int z) {
            return x + y + z;
        }
        public static double add(double x, double y) {
            return x + y;
        }
    }
    

    例2:

    class MethodOverloading {
     
        void receive(int i) {
            System.out.println("Received one int data");
            System.out.println("i="+i);
        }
         
        void receive(float f) {
            System.out.println("Received one float data");
            System.out.println("f="+f);
        }
         
        void receive(String s) {
            System.out.println("Received a String data");
            System.out.println("s="+s);
        }
         
        public static void main(String [] args){
            MethodOverloading m = new MethodOverloading();
            m.receive(3456);
            m.receive(34.56f);
            m.receive("方法重载");
        }
    }
    
    展开全文
  • java中的方法重载

    千次阅读 2020-05-05 22:26:59
    一、简介 (一)定义 方法重载:如果同一个类包含了两个及两个以上方法名相同,方法参数的个数、顺序或者类型不同的方法,则称为方法的重载。 二、 ...

    在大多数程序设计语言中(eg:C)要求每个方法(或者函数)都有独一无二的方法名。但是在java和C++中是允许一个类中包含多个方法名相同,但具体动作有细微差别的方法,即本章我们要了解的方法重载。
    一、简介
    (一)定义
    方法重载:如果同一个类中包含了两个及两个以上方法名相同,方法参数的个数、顺序或者类型不同的方法,则称为方法的重载。
    (二)判断方法重载的依据
    在这里插入图片描述

    1.同一个类中,方法名称一致;
    2.方法参数的个数、类型或者顺序不一致;
    有多个方法名相同,编译器只能通过独一无二的参数列表来表示。参数个数、类型、顺序不同均可表示。(顺序不同也可以区分两个方法,但是建议不要这样用,否则将增加代码维护的难度)。
    3.与返回值、访问修饰符无关。
    重载的判断依据调用时能否区分开,故传入参数类型、参数个数都是可以区分,然而返回类型当调用时是不能区分开的(这样应该就可以理解特点2和特点3的原因了吧……——……)。
    *区分重载的方法是只能依据类名和方法的形参列表作为标准,这种正向使用方法的角度进行判断更利于程序员的运用。
    二、从构造方法和普通方法两个角度解析重载
    (一)构造方法的重载
    关于构造方法的介绍,可以参看https://blog.csdn.net/qq_44801116/article/details/105909833
    通过上面定义,显然我们知道当一个类中既包含默认构造器又包含带参构造器,其实就是进行了方法的重载(构造器的定义(类名=方法名)+多个不同构造,则势必用到方法重载)。
    在这里插入图片描述
    (二)普通方法的重载
    在这里插入图片描述
    (三)重载方法及构造器的调用
    在这里插入图片描述
    三、基本类型的重载
    当基本类型传入重载时,会牵涉到类型的转换,在视觉上可能会存在混淆,下面将简单介绍一下java中基本数据类型的自动类型提升(后续有时间再详细的进行样例展示)。
    1.java中基本类型及所占空间大小

    基本类型 boolean byte char short float int long double
    所占空间 8bit/1byte 8bit/1byte 16bit/2byte 16bit/2byte 32bit/4byte 32bit/4byte 64bit/8byte 64bit/8byte

    2.自动类型转换
    正向过程:传入的数据类型(实际参数类型)小于方法中声明的形式参数类型,实际类型就会被提升
    byte->short->int->long->float->double
    char类型略有不同,如果无法找到恰好接收char参数的方法,就会把char直接提升到int类型,如果无int类型继续转化为->long->float->double
    boolean类型不允许继续进行任何类型的转化处理。

    逆向过程:传入的实际参数大于重载方法声明的形式参数,将使用强制转化,即窄化转化,带来的结果就是可能丢失精度。

    展开全文
  • java方法重载和重载方法 Java中的方法重载 (Method Overloading in Java) Method overloading is a concept that allows to declare multiple methods with same name but different parameters in the same class....

    java方法重载和重载方法

    Method overloading is a concept that allows to declare multiple methods with same name but different parameters in the same class.

    方法重载是一个概念 ,它允许在同一类中声明具有相同名称但参数不同的多个方法。

    Java supports method overloading and always occur in the same class(unlike method overriding).

    Java支持方法重载,并且总是在同一个类中发生(与方法重写不同)。

    Method overloading is one of the ways through which java supports polymorphism. Polymorphism is a concept of object oriented programming that deal with multiple forms. We will cover polymorphism in separate topics later on.

    方法重载是Java支持多态性的方法之一。 多态是一个面向对象的编程概念,涉及多种形式。 稍后我们将在单独的主题中介绍多态。

    Method overloading can be done by changing number of arguments or by changing the data type of arguments.

    方法重载可以通过更改参数数量更改 参数 的数据类型来完成

    If two or more method have same name and same parameter list but differs in return type can not be overloaded.

    如果两个或更多个方法具有相同的名称和相同的参数列表, 但返回类型不同,则不能重载。

    Note: Overloaded method can have different access modifiers and it does not have any significance in method overloading.

    注意:重载的方法可以具有不同的访问修饰符,并且在方法重载中没有任何意义。

    方法重载有两种不同的方法。 (There are two different ways of method overloading.)

    1. Different datatype of arguments

      参数的不同数据类型

    2. Different number of arguments

      参数数量不同

    通过更改参数的数据类型来重载方法。 (Method overloading by changing data type of arguments.)

    Example:

    例:

    In this example, we have two sum() methods that take integer and float type arguments respectively.

    在此示例中,我们有两个sum()方法分别采用整数和浮点型参数。

    Notice that in the same class we have two methods with same name but different types of parameters

    请注意,在同一个类中,我们有两个名称相同但参数类型不同的方法

    class Calculate
    {
      void sum (int a, int b)
      {
        System.out.println("sum is"+(a+b)) ;
      }
      void sum (float a, float b)
      {
        System.out.println("sum is"+(a+b));
      }
      Public static void main (String[] args)
      {
        Calculate  cal = new Calculate();
        cal.sum (8,5);//sum(int a, int b) is method is called.
        cal.sum (4.6f, 3.8f); //sum(float a, float b) is called.
      }
    }

    Sum is 13 Sum is 8.4

    总和是13总和是8.4

    You can see that sum() method is overloaded two times. The first takes two integer arguments, the second takes two float arguments.

    您可以看到sum()方法被重载了两次。 第一个带有两个整数参数,第二个带有两个浮点参数。

    通过更改编号重载方法。 论据。 (Method overloading by changing no. of argument.)

    Example:

    范例

    In this example, we have two methods

    在这个例子中,我们有两种方法

    class Demo
    {
      void multiply(int l, int b)
      {
        System.out.println("Result is"+(l*b)) ;
      }
      void multiply(int l, int b,int h)
      {
        System.out.println("Result is"+(l*b*h));
      }
      public static void main(String[] args)
      {
        Demo  ar = new Demo();
        ar.multiply(8,5);   //multiply(int l, int b) is method is called
        ar.multiply(4,6,2);   //multiply(int l, int b,int h) is called
      }
    }

    Result is 40 Result is 48

    结果是40结果是48

    In this example the multiply() method is overloaded twice. The first method takes two arguments and the second method takes three arguments.

    在这个例子中, multiply()方法被重载了两次。 第一个方法带有两个参数,第二个方法带有三个参数。

    When an overloaded method is called Java look for match between the arguments to call the method and the its parameters. This match need not always be exact, sometime when exact match is not found, Java automatic type conversion plays a vital role.

    调用Java的重载方法时,请在调用该方法的参数与其参数之间进行匹配。 这种匹配不一定总是精确的,有时在找不到精确匹配时,Java自动类型转换起着至关重要的作用。

    带类型升级的方法重载示例。 (Example of Method overloading with type promotion.)

    Java supports automatic type promotion, like int to long or float to double etc. In this example we are doing same and calling a function that takes one integer and second long type argument. At the time of calling we passed integer values and Java treated second argument as long type. See the below example.

    Java支持自动类型提升,例如int到long或float到double等等。在此示例中,我们正在做同样的事情,并调用一个接受一个整数第二个long类型参数的函数。 在调用时,我们传递了整数值,Java将第二个参数视为长型。 请参见以下示例。

    class Demo
    {
     void sum(int l,long b)
     {
      System.out.println("Sum is"+(l+b)) ;
     }
     void sum(int l, int b, int h)
     {
      System.out.println("Sum is"+(l+b+h));
     }
     public static void main (String[] args)
     {
      Demo  ar = new Demo();
      ar.sum(8,5);
     }
    }

    Sum is 13

    总和是13

    如果参数顺序更改,则方法重载 (Method overloading if the order of parameters is changed)

    We can have two methods with same name and parameters but the order of parameters is different.

    我们可以有两个具有相同名称和参数的方法,但是参数的顺序不同。

    Example:

    例:

    In this scenario, method overloading works but internally JVM treat it as method having different type of arguments

    在这种情况下,方法重载是有效的,但是在内部JVM中,它被视为具有不同类型参数的方法

    class Demo{
    
        public void get(String name,  int id)
       { 
    System.out.println("Company Name :"+ name);
      System.out.println("Company Id :"+ id); 
        } 
    
        public void get(int id, String name)
       { 
    System.out.println("Company Id :"+ id); 
      System.out.println("Company Name :"+ name);
        } 
    } 
    
    class MethodDemo8{ 
        public static void main (String[] args) { 
      Demo obj = new Demo();
      obj.get("Cherry", 1);
      obj.get("Jhon", 2);
        } 
    }
    parameter-different-method-overloading

    重载主要方法 (Overloading main Method)

    In Java, we can overload the main() method using different number and types of parameter but the JVM only understand the original main() method.

    在Java中,我们可以使用不同数量和类型的参数来重载main()方法,但是JVM仅了解原始的main()方法。

    Example:

    例:

    In this example, we created three main() methods having different parameter types.

    在此示例中,我们创建了三个具有不同参数类型的main()方法。

    public class MethodDemo10{ 
        public static void main(intargs) 
        { 
    System.out.println("Main Method with int argument Executing"); 
      System.out.println(args);
        } 
        public static void main(char args) 
        { 
    System.out.println("Main Method with char argument Executing");
      System.out.println(args); 
        } 
        public static void main(Double[] args) 
        { 
    System.out.println("Main Method with Double Executing"); 
      System.out.println(args);
        } 
        public static void main(String[] args) 
        { 
    System.out.println("Original main Executing"); 
      MethodDemo10.main(12);
      MethodDemo10.main('c');
      MethodDemo10.main(1236);
        } 
    }
    overloading-main

    方法重载和空错误 (Method overloading and null error)

    This is a general issue when working with objects, if same name methods having reference type parameters then be careful while passing arguments.

    当使用对象时,这是一个普遍的问题,如果具有引用类型参数的同名方法在传递参数时要小心。

    Below is an example in which you will know how a null value can cause an error when methods are overloaded.

    下面是一个示例,您将了解在方法重载时null值如何导致错误的情况。

    Example:

    例:

    Null value is a default value for all the reference types. It created ambiguity to JVM that reports error.

    空值是所有引用类型的默认值。 它给报告错误的JVM造成了歧义。

    public class Demo 
    { 
        public void test(Integer i) 
        { 
    System.out.println("test(Integer ) "); 
        } 
        public void test(String name) 
        { 
    System.out.println("test(String ) "); 
        } 
        public static void main(String [] args) 
        { 
            Demo obj = new Demo();  
    obj.test(null); 
        } 
    }

    The method test(Integer) is ambiguous for the type Demo

    test类型的test(Integer)模棱两可

    原因: (Reason:)

    The main reason for getting the compile time error in the above example is that here we have Integer and String as arguments which are not primitive data types in java and this type of argument do not accept any null value. When the null value is passed the compiler gets confused which method is to be selected as both the methods in the above example are accepting null.

    在上面的示例中出现编译时错误的主要原因是,这里我们将Integer和String作为参数,它们不是java中的原始数据类型,并且这种类型的参数不接受任何null值。 当传递null值时,编译器会感到困惑,因为上面示例中的两个方法都接受null,因此该选择哪种方法。

    However, we can solve this to pass specific reference type rather than value.

    但是,我们可以解决此问题以传递特定的引用类型而不是值。

    Example:

    例:

    In this example, we are passing specific type argument rather than null value.

    在此示例中,我们传递特定的类型参数而不是null值。

    public class MethodDemo9 
    { 
        public void test(Integer i) 
        { 
    System.out.println("Method ==> test(Integer)"); 
        } 
        public void test(String name) 
        { 
    System.out.println("Method ==> test(String) "); 
        } 
        public static void main(String [] args) 
        { 
            MethodDemo9 obj = new MethodDemo9 ();  
      Integer a = null;
    obj.test(a);
      String b = null;
    obj.test(b); 
        } 
    }
    method-overloading-null-error

    翻译自: https://www.studytonight.com/java/method-and-overloaded-method.php

    java方法重载和重载方法

    展开全文
  • 在本篇文章里小编给大家整理了关于java中的方法重载知识点总结,有兴趣的朋友们可以跟着学习参考下。
  • JAVA中的方法重载 重载解决的问题 重载的规则 重载的使用 可变参数编程 一、重载解决的问题 有时我们需要用一个函数,同时兼顾多种参数的情况。这时就需要用到方法的重载。 二、重载的规则 针对同一个类: 方法名...

    JAVA中的方法重载

    • 重载解决的问题
    • 重载的规则
    • 重载的使用
    • 可变参数编程

    一、重载解决的问题

    有时我们需要用一个函数,同时兼顾多种参数的情况。这时就需要用到方法的重载。

    二、重载的规则

    针对同一个类:

    1. 方法名相同
    2. 方法的参数不同(参数的个数或者参数的类型)
    3. 方法的返回值不做要求,不影响重载

    三、重载的使用

    代码如下:

    public static int add(int a,int b){
            return a + b;
        }
    
        public static double add(double a,double b){
            return a + b;
        }
    
        public static int add(int a,int b,int c){
            return a + b + c;
        }
    
        public static void main(String[] args) {
            System.out.println(1 + 8);
            System.out.println(3.0+8.8);
        }
    
    

    运行结果
    在这里插入图片描述

    ************************错误示范*************************
     public static int add(int a,int b){
            return a + b;
        }
     public static double add(int a,int b){    //编译出错
            return a + b;
        }
    
    

    运行结果
    在这里插入图片描述
    当两个方法方法名相同,参数也相同,只有返回值不同时,不构成函数重载。

    四、 可变参数编程

    定义时,在最后一个形参后加上三点 …,就表示该形参可以接受多个参数值。且传入的一组数据,本质上被编译器看作一个数组。需要注意的是,这一组数据的数据类型必须相同。

    public static int sum(int...array){
            int ret = 0;
            for(int x:array){
                ret += x;
            }
            return ret;
        }
     public static void main(String[] args) {
            System.out.println(sum(1,2,2));
            System.out.println(sum(1,2,4,5,6,7));
        }
    

    运行结果在这里插入图片描述

    总结

    我理解的是重载是几个方法使用同一种思想,实现同一功能,只是需要传入的参数不同(包括类型和个数)。

    展开全文
  • Java中的方法重载(Overload)和方法覆盖/方法重写(Override)一、方法重载二、方法覆盖/方法重写 一、方法重载 1.方法重载又称为Overload 2.方法重载什么时候使用? 当在一个类中,方法完成的功能是相似的,建议...
  • 一个小例子让你立马理解java中的方法重载 说起重载呢,大家应该也都不陌生,java中的重载实际上也比较好掌握。我们先看一下什么是方法重载。 在同一个类中,方法名相同,但方法的参数类型或参数个数不同,就构成了...
  • 方法重载是指在一个类中定义多个同名的方法,但要求每个方法具有不同的参数的类型或参数的个数。方法重载一般用于创建一组任务相似但是参数不同的方法方法重载有以下几种规则: 方法中的参数列表必须不同。比如:...
  • Java的方法重载 方法的重载在Java开发经常用到,所谓的重载就是:在相同类有同名的方法,但方法的参数列表不相同(参数的类型,参数的个数)这是衡量是否是方法重载的一个标准。被重载的方法 ...
  • Java中的方法重载应用

    千次阅读 2017-04-12 09:54:26
    方法重载介绍如果一个类包含了两个或两个以个以上的方法名相同,但形参列表不同,则称为方法重载。   二 方法重载应用1 代码示例 public class Overload { // 下面定义了两个test()方法,但方法的形参...
  • 重载是在同一类,声明多个同名方法,通过参数列表来区分不同的方法重载规则:参数列表的数量、类型、顺序不同 重写: 重写是发生在具有继承关系的两个类之间,子类可以继承父类非私有的方法,当父类的方法...
  • 方法重载和方法覆盖区别 1、重载发生在编译时,而覆盖在运行时发生: 重载方法调用与其定义绑定在编译时发生,但是覆盖方法调用与其定义绑定在运行时发生。 2、静态方法可以重载,这意味着一个类可以有多个...
  • 方法重载是指在一个类定义多个同名的方法,但要求每个方法具有不同的参数的类型或参数的个数.具体有以下几种。先定义一个求和的方法` public static int add(int a, int b) { int sum = a + b; return sum...
  • 1 方法重载 (出现在同类)  :类同一种功能多种实现方式。  ①方法名相同  ②参数类型,个数,顺序至少有一项不同  ③方法返回类型可以不同  ④方法修饰符可以不同
  • 方法重载指的是当同一个类有两个或两个以上相同命名的方法。 1. 方法重载的规则 当方法重载时,必须要保证每两个方法之前的方法签名(Signature)是不同的。这意味着这两个方法有着不同数量的参数或者参数的类型...
  • //返回较大整数 public int getMax(int i ,int j) { if(i>=j){ return i ; } else { return j; } } //返回较大浮点数 public float getMax(float m,float n) { if(m>=n){ ...
  • 方法重载(Overload): 方法重写(Override):
  • 方法重载有哪几种形式?为什么改变返回类型不算是方法重载?可以重载 main 方法吗?
  • Java中的方法重载和重写(覆盖)

    千次阅读 2016-05-10 11:08:02
    * 方法重载的判定:同一类,方法名相同,参数列表不同(参数个数不同,参数列表对应位置参数类型不同),其他方法返回值 * 和访问修饰符都随意。 */ public class OverloadTest { public void testFunc...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,064
精华内容 4,825
关键字:

java中的方法重载

java 订阅