精华内容
下载资源
问答
  • Java 方法参数可以有默认值吗?

    万次阅读 2019-03-21 09:49:37
    Java 方法参数可以有默认值吗? 例如 void method(String p1, int p2, bool p3=false); 复制代码回答 Java不支持这种特性, 如果你真的有需求,你可以 通过方法的重载间接的支持默认的参数值 使用工厂模式 重载 ...

    Java 方法的参数可以有默认值吗?

    例如

    void method(String p1, int p2, bool p3=false);
    复制代码

    回答

    Java不支持这种特性, 如果你真的有需求,你可以

    • 通过方法的重载间接的支持默认的参数值
    • 使用工厂模式

    重载

    这个很简单

    void method(String p1, int p2, bool p3){
      // ....
    };
    void method(String p1, int p2){
      bool p3 = false;
      // ... 
    };
    复制代码

    这样就相当于给p3一个默认的参数值。

    但是有的时候如果参数太多,就不适合了。 就要用到下面的工厂方法

    工厂方法

    public class StudentBuilder
    {
        private String _name;
        private int _age = 14;      // this has a default
        private String _motto = ""; // most students don't have one
    
        public StudentBuilder() { }
    
        public Student buildStudent()
        {
            return new Student(_name, _age, _motto);
        }
    
        public StudentBuilder name(String _name)
        {
            this._name = _name;
            return this;
        }
    
        public StudentBuilder age(int _age)
        {
            this._age = _age;
            return this;
        }
    
        public StudentBuilder motto(String _motto)
        {
            this._motto = _motto;
            return this;
        }
    }
    复制代码
    Student s1 = new StudentBuilder().name("Eli").buildStudent();
    Student s2 = new StudentBuilder()
                     .name("Spicoli")
                     .age(16)
                     .motto("Aloha, Mr Hand")
                     .buildStudent();
    复制代码

    在上面的示例中,我们没有直接 的创建一个Student对象,而是 通过StudentBuilder来创建一个工厂, 然后在这个工厂中预先设定了一些模板,

    为什么要创建一个StudentBuilder

    而不是直接这样写:

    Student s1 = new Student().age(16)
    复制代码

    这样写有两个坏处

    • 实例化有些字段没有初始化,可能存在 安全隐患
    • 很多时候,我们创建一个Student之后,并不希望他有一个.age()方法,这个方法可能会被滥用。

    收录于 github.com/fish56/Java…

    转载于:https://juejin.im/post/5c935e14f265da60df41070d

    展开全文
  • Java 方法参数

    千次阅读 多人点赞 2017-12-03 19:20:48
    也就是说,方法得到的是所有参数值的一个拷贝,特别是,方法不能修改传递给它的任何参数的内容。 例如,下面的调用: double percent = 10; harry.raiseSalary(percent);在方法调用之后,percent的值还是10。代码...

    Java 程序设计语言总是采用按值调用。也就是说,方法得到的是所有参数值的一个拷贝,特别是,方法不能修改传递给它的任何参数的内容。

    例如,下面的调用:

    double percent = 10;
    harry.raiseSalary(percent);
    在方法调用之后,percent的值还是10。代码如下:

    public class ParamTest {
    	public static void main(String [] args){
    		System.out.println("Testing tripleValue:");
    		double percent = 10;
    		System.out.println("Before:percent=" + percent);
    		tripleValue(percent);
    		System.out.println("After:percent=" + percent);
    		
    	}
    	public static void tripleValue(double x){
    		 x = 3*x;
    		 System.out.println("End of method: x="+x);
    	}
    
    }

    运行结果:



    可以看到,无论怎样,调用这个方法之后,percent的值还是10。看一下具体的执行过程:

    1)x被初始化为percent值的一个拷贝(也就是10)。

    2)x被乘以3后等于30。但是percent仍然是10。

    3)这个方法结束之后,参数变量x不再使用。



    方法参数共有两种类型:

    1、基本数据类型(数字、布尔值)。

    2、对象引用。

    我已经知道,一个方法不可能修改一个基本数据类型的参数。而对象引用作为参数就不一样了,可以利用下面这个方法实现将一个雇员是的薪金提高两倍的操作:

    public static void tripleSalary(Employee x)
    {
      x.raiseSalary(200);
    
    }
    具体代码:

    public class ParamTest {
    	public static void main(String [] args){
    		System.out.println("\nTesting tripleSalary:");
    		Employee harry = new Employee("Harry",50000);
    		System.out.println("Before: salary=" + harry.getSalary());
    		tripleSalary(harry);
    		System.out.println("After: salary=" + harry.getSalary());
    		
    		
    	}
    	public static void tripleSalary(Employee x){
    	x.raiseSalary(200);
    	System.out.println("End of method: salary=" + x.getSalary());
    	}
    
    }
    public class Employee {
    	private String name;
    	private double salary;
    	
    	public Employee(String n,double s){
    		name = n;
    		salary = s;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	
    
    	public double getSalary() {
    		return salary;
    	}
        public void raiseSalary(double byPercent){
        	double raise = salary*byPercent/100;
        	salary+=raise;
        	
        }
    
    
    }
    
    运行结果:




    具体执行过程:

    1、x被初始化为harry值的拷贝,这里是个对象的引用。

    2、raiseSalary方法应用于这个对象引用。x和harry同时引用的那个Employee对象的薪金提高了200%。

    3、方法结束后,参数变量x不再使用。当然,对象变量harry继续引用那个薪金增至3倍的雇员对象。



         由上可知,实现一个改变对象参数状态的方法并不是一件难事。因为,方法得到的是对象引用的拷贝,对象引用及其他的拷贝同时引用统一个对象。

    很多程序设计语言提供了两种参数传递的方式:值调用和引用调用。有些人认为Java程序设计语言对对象采用的是引用调用,实际上,这种理解是不对的。由于这种理解有一定的普遍性,所以下面给出一个范反例来详细阐述。

         首先,编写一个交换两个雇员对象的方法:

    public static void swap(Employee x,Employee y){
       Employee temp=x;
       x = y;
       y = temp;
    }

    如果Java设计语言对对象采用的是引用调用,这个方法就应该能够实现交换数据的效果:

    Emloyee a = new Emloyee("Alice",...);
    Emloyee a = new Emloyee("Bob",...);
    swap(a,b);
    但是,方法并没有改变存储在变量a和b的对象引用。swap方法的参数x和y被初始化为两个对象引用的拷贝,这个方法交换的是这两个拷贝。具体代码:

    public class Ey {
    	public static void swap(Employee x,Employee y){
    		Employee temp = x;
    		x = y;
    		y = temp;
    		System.out.println("End of method: x="+x.getName());
    		System.out.println("End of method: y="+y.getName());
    		
    	}
    	public static void main(String [] args){
    		Employee a = new Employee("Alice",200);
    		Employee b = new Employee("Bob",400);
    		System.out.println("\nTesting swap:");
    		System.out.println("Before:a=" + a.getName());
    		System.out.println("Before:b=" + b.getName());
    		swap(a,b);
    		System.out.println("After:a=" + a.getName());
    		System.out.println("After:b=" + b.getName());
    	}
    
    }
    public class Employee {
    	private String name;
    	private double salary;
    	
    	public Employee(String n,double s){
    		name = n;
    		salary = s;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	
    
    	public double getSalary() {
    		return salary;
    	}
        public void raiseSalary(double byPercent){
        	double raise = salary*byPercent/100;
        	salary+=raise;
        	
        }
    
    
    }
    
    

    运行结果:

    最终,白费力气。在方法结束时参数变量x和y被丢弃了。原来的变量a和b仍然引用这个方法调用之前所引用的对象


        这个过程说明:Java程序设计语言对对象采用的不是引用调用,实际上,对象引用进行的是值传递。

        下面总结一下Java程序设计语言中方法参数的使用情况:

        1、一个方法不能修改一个基本数据类型的参数(即数值型和布尔型)。

        2、一个方法可以改变一个对象参数的状态。

        3、一个方法不能让对象参数引用一个新的对象。






    展开全文
  • java 方法缺省参数

    千次阅读 2019-03-20 15:49:41
    今天介绍一下java8的方法缺省参数 public Void getAAAA(String A,String.. B){ *********************** } 调用这个方法的时候参数A是必需的! B 是可传可不传, 可以传多个, 保存在一个String数组中 以上 ...

    之前看了许多菜鸟的介绍,

    今天介绍一下java8的方法缺省参数

    public Void getAAAA(String A,String.. B){

    ***********************

    }

    调用这个方法的时候参数A是必需的!

    B 是可传可不传,

    可以传多个,

    保存在一个String数组中

    以上

     

    展开全文
  • java方法可选参数_Java可选参数

    千次阅读 2020-07-05 23:15:52
    java方法可选参数 在Java类中设计方法时,某些参数对于其执行而言可能是可选的。 无论是在DTO,胖模型域对象还是简单的无状态服务类中,可选方法参数都是常见的。 从本文中, 您将学习如何在Java中处理可选参数 ...

    java方法可选参数

    在Java类中设计方法时,某些参数对于其执行而言可能是可选的。 无论是在DTO,胖模型域对象还是简单的无状态服务类中,可选方法参数都是常见的。

    从本文中, 您将学习如何在Java中处理可选参数 。 我们将专注于常规方法,具有可选字段的类构造函数,并快速查看所讨论主题的不良做法。 我们将停下来看看Java 8 Optional,并评估它是否符合我们的需求。

    让我们开始吧。

    1.可选方法参数

    您可以通过几种不同的方法来处理Java可选参数。 我将引导您从最简单到更复杂。

    @Nullable注解

    为什么不传递零值呢? 这是一个简单的解决方案,不需要任何额外的工作。 您没有任何需要作为方法参数之一的对象吗? 没问题。 只需传递null即可,编译器很高兴。

    这里的问题是可读性。 调用方法的程序员如何知道他是否可以安全地传递null? 对于哪些参数可以接受空值,哪些是必需的?

    为了清楚说明null是有效输入,可以使用@Nullable批注。

    User createUser(String name, @Nullable Email email) {
       // ...
    }

    您不同意此方法声明是不言自明的吗?

    可选参数

    尽管简单,但是null传递方法的问题在于它很容易失控。 团队可能会Swift开始过度使用它,并使代码库难以维护,并带有大量的空检查条件

    不过,还有其他选择。

    可选清单

    代替null,我们有时可以创建类的空表示。 考虑一下Java集合。 如果方法接受列表或映射,则永远不要使用null作为输入。

    空集合总是比空集合好,因为在大多数情况下,不需要任何特殊处理。

    您可能想知道为什么要浪费内存来创建空集合。 毕竟,null不会花费您任何费用。

    您的怀疑是有道理的。 幸运的是,有一个简单的解决方案。

    每当需要空的代表时,就不应创建集合的新实例。 在代码库中重复使用同一实例。

    你知道吗? Java已经具有您可以使用的所有集合的空实例。 您可以在Collections实用程序类中找到它们

    User createUser(String name, List<Rights> rights) {
       // ...
    }
    import java.util.Collections;
    // ...
    create("bob", Collections.emptyList());

    空对象模式

    空集合的概念也适用于其他类。 空集合只是具有零元素的常规集合。 同样,您可以考虑应用程序中的其他对象。

    Null对象是表示缺失值的类的特殊实例。 如果某些方法希望将对象作为参数,则始终可以传递Null对象表示形式,而不必担心它将在运行时引起意外的异常。

    可选参数

    您可以通过两种方式实现Null对象模式。

    对于简单值对象,将预定义值分配给属性的默认实例就足够了。 通常,您将此Null对象公开为常量,以便可以多次重用。 例如:

    public class User {
    
       public static final User EMPTY = new User("", Collections.emptyList());
    
       private final String name;
       private final List<Rights> rights;
    
       public User(String name, List<Rights> rights) {
           Objects.requireNonNull(name);
           Objects.requireNonNull(rights);
           this.name = name;
           this.rights = rights;
       }
    
       // ...
    
    }

    如果您的Null对象还需要模仿通过方法公开的某些行为,则简单实例可能无法工作。 在这种情况下,您应该扩展类并覆盖此类方法。

    这是扩展前一个示例的示例:

    public class AnonymousUser extends User {
    
       public static final AnonymousUser INSTANCE = new AnonymousUser();
    
       private AnonymousUser() {
          super("", Collections.emptyList());
       }
    
       @Override
       public void changeName(String newName) {
           throw new AuthenticationException("Only authenticated user can change the name");
       }
    
    }

    专用的Null对象类使您可以将多个角落案例放在一个地方,这使维护更加轻松。

    方法重载

    如果您设计的方法带有可选参数,则可以公开该方法的重载版本。 每种方法应仅接受必需的参数。

    使用这种方法,您不必期望调用方将为可选参数提供默认值。 您可以通过自己的内部重载方法传递默认值。 换句话说,您对方法的调用者隐藏了可选参数的默认值。

    User createUser(String name) {
       this.createUser(name, Email.EMPTY);
    }
    
    User createUser(String name, Email email) {
       Objects.requireNonNull(name);
       Objects.requireNonNull(rights);
       // ...
    }

    重载的方法可以互相调用,但这不是强制性的。 如果更方便,则可以独立实现每种方法。 但是,通常您会验证所有参数,并将逻辑放在参数列表最长的方法中。

    值得一提的是,方法重载已在标准Java库中广泛使用。 当您学习如何设计API时,请向经验丰富的人学习。

    参数对象模式

    大多数开发人员都同意,当方法参数列表过长时,将变得难以阅读。 通常,您可以使用Parameter Object pattern处理问题。 参数对象是一个命名的容器类,它对所有方法参数进行分组。

    是否解决了可选方法参数的问题?

    不,不是。

    它只是将问题移至参数对象的构造函数。

    让我们看看如何用…解决这个更普遍的问题。

    2.可选的构造函数参数

    从带有可选参数的问题的角度来看,简单的构造函数与常规成员方法没有什么不同。 您可以成功使用我们已经在构造函数中讨论过的所有技术。

    但是,当构造函数参数列表越来越长并且其中许多是可选参数时,应用构造函数重载似乎很麻烦。

    如果您同意,则应签出Builder模式。

    建造者模式

    让我们考虑一个具有多个可选字段的类:

    class ProgrammerProfile {
    
       // required field
       private final String name;
       // optional fields
       private final String blogUrl;
       private final String twitterHandler;
       private final String githubUrl;
    
       public ProgrammerProfile(String name) {
           Objects.requireNonNull(name);
           this.name = name;
           // other fields assignment...
       }
    
       // getters
    
    }

    如果创建了一个构造函数来覆盖所有可能的带有可选参数的组合,那么最终将得到不胜枚举的清单。

    如何避免多个构造函数? 使用构建器类。

    您通常将构建器实现为它应该构建的类的内部类。 这样,两个类都可以访问其私有成员。

    看一下前面示例中的类的构建器:

    class ProgrammerProfile {
    
       // fields, getters, ...
    
       private ProgrammerProfile(Builder builder) {
           Objects.requireNonNull(builder.name);
           name = builder.name;
           blogUrl = builder.blogUrl;
           twitterHandler = builder.twitterHandler;
           githubUrl = builder.githubUrl;
       }
    
       public static Builder newBuilder() {
           return new Builder();
       }
    
       static final class Builder {
          
           private String name;
           private String blogUrl;
           private String twitterHandler;
           private String githubUrl;
    
           private Builder() {}
    
           public Builder withName(String val) {
               name = val;
               return this;
           }
    
           public Builder withBlogUrl(String val) {
               blogUrl = val;
               return this;
           }
    
           public Builder withTwitterHandler(String val) {
               twitterHandler = val;
               return this;
           }
    
           public Builder withGithubUrl(String val) {
               githubUrl = val;
               return this;
           }
    
           public ProgrammerProfile build() {
               return new ProgrammerProfile(this);
           }
    
       }
    
    }

    代替公共构造函数,我们只为内部构建器类公开一个静态工厂方法。 专用构造函数(构建器在build()方法中调用)使用构建器实例来分配所有字段并验证是否存在所有必需的值。

    一想起来,这是一种非常简单的技术。

    仅设置选定的可选参数的该构建器的客户机代码可能如下所示:

    ProgrammerProfile.newBuilder()
           .withName("Daniel")
           .withBlogUrl("www.dolszewski.com/blog/")
           .build();

    使用构建器,您可以使用对象的可选参数创建所有可能的组合。

    可选参数

    编译时安全的类生成器

    不幸的是,仅通过查看上一段落中构建器的方法,您就无法真正分辨出哪些参数是可选的,哪些是必需的。 而且,在不知不觉中您可能会偶然忽略所需的参数。

    查看以下错误使用的构建器示例

    ProgrammerProfile.newBuilder()
           .withBlogUrl("www.dolszewski.com/blog/")
           .withTwitterHandler("daolszewski")
           .build();

    编译器不会报告任何错误。 您将仅在运行时意识到缺少必需参数的问题。

    那么,您如何解决这个问题?

    您需要稍微修改构建器工厂方法,以便仅可以使用必需参数来调用它,而仅对可选参数使用左构建器方法。

    这就是您需要更改的所有内容:

    class ProgrammerProfile {
       
       // ...
    
       public static Builder newBuilder(String name) {
          return new Builder(name);
       }
    
       public static final class Builder {
    
          private final String name;
          // ...
    
          private Builder(String name) {
              this.name = name;
          }
    
          // ...
    
       }
    }

    生成器类的生成

    您可能会认为构建器需要大量代码。

    不用担心

    您不必自己键入所有代码。 所有流行的Java IDE都具有允许生成类生成器的插件。 IntelliJ用户可以检查InnerBuilder插件 ,而Eclipse爱好者可以看看Spart Builder Generator 。 您也可以在官方存储库中找到替代插件。

    如果您使用项目Lombok ,它还可以简化与类构建器的合作。 如果需要开始的地方,可以查看有关Lombok建筑商的简短介绍

    3. Java可选参数反模式

    在浏览网络以寻找使用Java可选参数的方法时,除了我们已经介绍的内容之外,您还可以找到一些其他建议。 让我解释一下为什么您应该将它们视为错误的方法。

    地图

    从技术上讲,方法的输入是一组键值对。 在Java中,我们有一个符合此描述的标准内置数据结构-Map。

    编译不会阻止您将HashMap <String,Object>用作所有可选方法参数的容器,但是您的常识应该如此。

    尽管您可以在HashMap中放入任何内容,但这是错误的想法。 这种方法难以理解,难以理解,并将Swift成为您维护的噩梦。

    还是不服气?

    您绝对应该考虑将您的职业转到JavaScript开发人员。 在公司哭泣要容易得多。

    Java变量

    需要明确的是,使用Java varargs绝对没有错。 如果您不知道您的方法将被调用多少个参数,那么varargs非常适合。

    但是将varargs用作单个值的容器(可能存在或不存在)是一种滥用。 这样的声明允许使用比预期更多的可选值来调用方法。 我们讨论了用于处理单个可选参数的更具描述性的方法。

    为什么不将Optional作为方法参数?

    最后,最有争议的方法-Java 8 Optional作为方法输入。 我已经写了一篇关于可选用例的文章 ,其中还介绍了方法参数。 让我扩展您在那里可以找到的内容。

    内存使用情况

    创建Optional类的实例时,必须为其分配内存。 尽管使用Optional.empty()访问的空可选实例是可重用的单例(就像我们已经讨论过的空集合一样),但非空实例将占用操作内存。

    如果将此方法与其他方法进行比较,仅出于调用将立即解开对象的方法的目的而使用Optional工厂方法包装对象就没有意义。

    但是,如今,垃圾收集器可以很好地处理短寿命的物品。 内存分配没什么大不了的。 我们还有其他缺点吗?

    可选参数

    铭记读者

    代码的可读性如何?

    createProfile("Daniel", Optional.of("www.dolszewski.com/blog/"),
           Optional.of("daolszewski"), Optional.of("https://github.com/danielolszewski"));

    也许这只是个人喜好问题,但对于许多开发人员而言,多个Optional工厂调用会分散您的注意力。 阅读器代码中的噪音。 但同样,这只是一个口味问题。 让我们找到更令人信服的东西。

    可选参数

    Java语言设计师的意见

    Oracle公司Java语言架构师Brian Goetz 曾表示 ,将Optional添加到标准库中时要考虑方法的结果,而不是方法的输入。

    但是软件开发人员是叛逆者,不喜欢听当局的话。 这种说法似乎也很微弱。 我们必须更深入。

    可选参数

    Optional是否解决了可选参数问题?

    如果您有这样的方法声明:

    doSomethingWith(Optional<Object> parameter);

    您应该期望多少输入?

    该参数可以是包装值或空的可选实例。 答案是2,对吗?

    错误。

    真正的答案是3,因为您还可以将null用作参数。 当您不知道谁将成为您的API的调用者时,您应该对输入具有有限的信任。

    在这种情况下,在处理参数之前,应检查Optional是否不等于null,然后检查该值是否存在。 非常复杂,您不同意吗?

    我敢肯定我还没有穷尽这个话题。 由于这是Java编程的潜在圣战之一,因此您应该形成自己的见解。 如果要向Optional的参数列表中添加某些内容作为方法参数,请在注释中分享您的想法。 非常受欢迎。

    结论

    让我们回顾一下我们学到的东西。 Java无法为方法参数设置默认值。 该语言为我们提供了许多其他可选参数来处理可选参数。

    这些替代方法包括@Nullable批注,空对象,方法重载和参数对象模式。 我们还熟悉具有多个可选字段的对象的类构建器。 最后,我们回顾了常见的不良做法和潜在的滥用行为。

    如果您觉得这篇文章有帮助,请与您的关注者分享。 我也很想知道您的想法,欢迎提出所有意见。

    翻译自: https://www.javacodegeeks.com/2018/11/java-optional-parameters.html

    java方法可选参数

    展开全文
  • java 方法中的参数类型是类类型的

    千次阅读 2019-08-02 22:03:09
    今天做作业遇到方法中的参数类型是类类型的...1方法参数类型是基本数据类型的: public void test(int a) { a=6; System.err.println(a); } public static void main(String[] args) { Student student= new...
  • Java方法输出参数

    千次阅读 2014-08-07 15:28:36
    在写Java代码的时候,自定义方法的时候,都会牵扯到参数问题,方法参数包括输出参数和输入参数。 下面主要说说输出参数: 1.没有输出参数的时候就直接把输出参数写成void就可以。 2.当输出参数只有一个数据的时候...
  • Java方法可以有默认参数

    万次阅读 2016-03-05 13:41:02
    Java中的方法可以有默认参数,只能通过重载来实现: public class ParameterDefault { /** * @param args */ public String getName(String givenName,String familyName){ return givenName+"."+f
  • java方法参数带双引号和不带双引号的区别 比如map.put( " billNum","订单编号", +stateStr); 为什么会有加号,难道方法参数还可以是一个运算表达式
  • java如何获取方法参数

    万次阅读 多人点赞 2015-08-05 11:33:32
    java中,可以通过反射获取到类、字段、方法签名等相关的信息,像方法名、返回值类型、参数类型、泛型类型参数等,但是不能够获取方法参数名。在实际开发场景中,有时需要根据方法参数名做一些操作,比如像...
  • java 数组作为方法参数

    千次阅读 2019-12-02 10:30:55
    数组作为方法参数 例:定义方法,打印输出数组元素的值 public void printArray(int[] arr){} 数组明指向数组的第一个的元素; 数组作为方法参数的方法调用。数组作为方法参数,当传参的时候,传递的是数组的名字...
  • java当中的方法参数可以有n个不同类的对象吗 java当中的方法参数可以有n个不同类的对象吗
  • java中关于方法参数的介绍

    千次阅读 2019-04-10 20:37:13
    一个方法可以修改传递引用所对应的变量值,而不能修改传递值调用所对应的变量值。而Java程序设计语言总是采用按值调用,也就是说,方法得到的是所有参数值的一个拷贝。下面我将举一些实例来具体说明: #基本数据类型...
  • java方法参数和泛型参数有什么区别 方法是可以省略参数数据类型的 泛型可以省略吗
  • java 方法参数过多解决方法

    千次阅读 2017-01-06 16:37:17
    http://www.importnew.com/8926.html
  • Java方法的可变参数个数

    万次阅读 多人点赞 2014-08-29 10:00:37
    原文:Java方法的可变参数类型许多Java新人在看到下面的这段代码的时候,都会问一个问题:dealArray方法里那三个小点点是什么啊?[java] view plaincopyprint?public class TestVarArgus { public static ...
  • 定义java方法可变参数

    千次阅读 2020-01-16 10:26:55
    以校验参数非空为例: public class checkParams { //非空校验 public static boolean checkString(String ... params) { boolean boo=true; if(params ==null||"".equals(params)) { return false; }...
  • Java 泛型作为方法参数

    千次阅读 2019-12-22 21:20:29
    Java 泛型作为方法参数 例程源码: import java.util.List; public class GoodsSeller { public void sellGoods(List<? extends Goods> goods){ //调用集合中的sell方法 for(Goods g:goods...
  • JAVA 方法参数是按值传递还是引用传递?
  • java main方法参数传递

    万次阅读 2017-06-22 14:35:01
    一般情况下 我们的main方法是不需要参数传入的 但是如果在工作中需要我们写一些小的应用程序 并且以jar包的方式发给其他人员直接在dos界面使用 并且需要输入参数的时候就需要用到main的参数传递 首先main方法中...
  • Java方法的可选参数 可变参数

    万次阅读 2018-11-07 13:13:21
    Java方法的可选参数 可变参数
  • Java方法中通过传递参数改变变量的值
  • 深入理解java方法调用时的参数传递

    千次阅读 2017-11-09 18:08:20
    深入理解java方法调用与参数传递,解决以下问题:Java方法调用是如何传递参数的?被调用方法对调用方法内的变量有什么影响?java能使用返回值void的中间方法对变量进行加工吗?为什么静态成员变量的改变影响是全局的...
  • 参数位置调用void方法 确定JAVA中void方法被成功调用
  • 使用java命令,直接启动main方法类,假设类名为Main.java,则命令为: ...main方法启动时还有可能需要配置一些java虚拟机的参数,例如: java -Xms256M -Xmx512M Main 这个命令设置了虚拟...
  • 1 java返回多参数方法 在编写程序时经常遇到从一个方法中返回多个有用信息的情况。例如查找一个数组中最大值与最小值,一般的做法是通过一个for循环,两个if判断找出最值。但是在找到有用信息后需要通过函数返回的...
  • Java方法的不固定参数

    千次阅读 2016-04-21 01:47:16
    java方法的不固定参数
  • java中一个方法可以有多少个参数

    千次阅读 2017-12-21 12:39:21
    java中一个方法可以有多少个参数 疯子又勇9 | 浏览 289 次 |举报 我有更好的答案 2017-09-29 最佳答案 java方法可以动态传入参数,比如methodA(String... values),它相当于传进入...
  • 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1. 概述泛型在java中有很重要的地位,在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型?为什么要使用泛型? 泛型,即“参数化类型”。一...
  • Java 方法使用final 修饰参数的作用

    万次阅读 2018-03-14 17:29:55
    方法参数前面加final关键字就是为了防止数据在方法体中被修改。 主要分两种情况: 第一,用final修饰基本数据类型; 第二,用final修饰引用类型。 第一种情况,修饰基本类型(非引用类型)。这时参数的值在...
  • java 获取方法参数

    千次阅读 2019-04-30 14:00:57
    方法参数名获取: 使用java提供的反射机制,在1.8以下是不能获取到方法的参数名称,因为源文件在编译时,参数名被转换了; 1, Java8(JDK1.8)以上,获取方式: JDK1.8添加了一个Parameter对象,用于获取参数的相关...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,102,664
精华内容 841,065
关键字:

java方法参数可以是方法吗

java 订阅