java方法参数
㈠ java 带参数的方法
public class zh {
public void qk(double money,String kh)
{
System.out.print(kh+"账户，取款金额："+money);
}
public void cx(String kh)
{
System.out.print("取款金额："+money);
}
public void cq(double money,String kh)
{
System.out.print(kh+"账户，存款金额："+money);
}
public void tc()
{
System.out.print("退出");
}
}
㈡ java中方法参数问题
方法中不是类创建了对象，而是生命了一个对象，这个对象属于accp###Teacher类的。
创建对象是在main 方法里面hq.judge()中创建的对象，创建的对象直接传到上面的方法中接收的
㈢ Java中函数参数的传递是怎样进行的
Java中函数参数的传递是按值传递。
下面证明Java中参数传递是完完全全是传值而不是传址。
一：
package com.sitinspring;
public class ChangeClass{
public void changeInt(int i){
i=5;
}
public void changeLong(long i){
i=555;
}
public void changeString(String str){
str="5555";
}
public void changeMember(Member member){
member=new Member("Cindy",35);
}
public void changeMemberField(Member member){
member.setAge(20);
member.setName("Andy");
}
public static void main(String[] args){
ChangeClass changeClass=new ChangeClass();
int intValue=10;
changeClass.changeInt(intValue);
System.out.println(intValue);
long longValue=10;
changeClass.changeLong(longValue);
System.out.println(longValue);
String stringValue="1234";
changeClass.changeString(stringValue);
System.out.println(stringValue);
Member member2=new Member("Douglas",45);
changeClass.changeMember(member2);
System.out.println(member2);
Member member=new Member("Bill",25);
changeClass.changeMemberField(member);
System.out.println(member);
}
}
二：
package com.sitinspring;
public class Member{
private String name;
private int age;
public Member(String name,int age){
this.age=age;
this.name=name;
}
public String toString(){
return "Member name="+name+" age="+age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
输出：
10
10
1234
Member name=Douglas age=45
Member name=Andy age=20
解释：
第一个输出10是因为int是基本类型,传递的参数是intValue的拷贝,对拷贝的修改对原值intValue没有影响.
第一个输出10和上面是一个道理.
第三个输出1234.由于String是类类型, str是stringValue的地址拷贝,参数str指向的地址和stringValue的一致,但在函数changeString 中,由于String的特殊性, str=“5555”和str=new String(“5555”)是等价的, str指向了新的”5555”所在的地址,此句后str就与原来的stringValue彻底脱离了联系.
第四个输出Member?name=Douglas?age=45的道理和上面相同.
第五个输出Member?name=Andy?age=20是因为changeMemberField函数中修改了参数member 的值,也就是修改member指向实例的值,而这个实例正是member指向的值,因此member就变成了name=Andy 且age=20.
结论：
Java中参数传递的都是值,对应基本类型,传递的是原值的拷贝;对于类类型,传递的是引用即地址的拷贝.
对于函数对参数的改变是否会影响原值的问题:值类型自然不会影响到原值.而对于类类型要看改变的是参数的地址还是值,如果是前者,参数和原引用指向了不同的地址,它们自然脱离了关系;如果是后者,修改的实例就是原引用指向的实例,这当然对原值进行了修改.
㈣ JAVA中 方法后参数列表
//Personperson就跟inta是一样的，只不过一个是Person类型，一个是int类型。int是基本数据类型，Person这种引用数据类型。参数列表不能放方法
㈤ Java如何获取方法参数的参数名称
packagecom.mikan;
importjava.lang.annotation.*;
/**
*@authorMikan
*@date2015-08-0423:39
*/
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public@interfaceParam{
Stringvalue();
}
获取注解中的参数名的工具类：
packagecom.mikan;
importjava.lang.annotation.Annotation;
importjava.lang.reflect.Method;
/**
*@authorMikan
*@date2015-08-0500:26
*/
publicclassParameterNameUtils{
/**
*获取指定方法的参数名
*
*@parammethod要获取参数名的方法
*@return按参数顺序排列的参数名列表
*/
publicstaticString[](Methodmethod){
Annotation[][]parameterAnnotations=method.getParameterAnnotations();
if(parameterAnnotations==null||parameterAnnotations.length==0){
returnnull;
}
String[]parameterNames=newString[parameterAnnotations.length];
inti=0;
for(Annotation[]parameterAnnotation:parameterAnnotations){
for(Annotationannotation:parameterAnnotation){
if(annotationinstanceofParam){
Paramparam=(Param)annotation;
parameterNames[i++]=param.value();
}
}
}
returnparameterNames;
}
}
测试类：
packagecom.mikan;
importjava.lang.reflect.Method;
importjava.util.Arrays;
/**
*@authorMikan
*@date2015-08-0423:40
*/
publicclassParameterNameTest{
publicvoidmethod1(@Param("parameter1")Stringparam1,@Param("parameter2")Stringparam2){
System.out.println(param1+param2);
}
publicstaticvoidmain(String[]args)throwsException{
Class<ParameterNameTest>clazz=ParameterNameTest.class;
Methodmethod=clazz.getDeclaredMethod("method1",String.class,String.class);
String[]parameterNames=ParameterNameUtils.(method);
System.out.println(Arrays.toString(parameterNames));
}
}
㈥ Java方法的参数传递
对象型类型是引用传递，传递的是对象的地址。值被修改后原来的变量也会被修改。
㈦ java 方法作为参数
难道是用传递Method对象的方式，很不理解这样做的意图，直接在这个方法里掉你要传的方法不行吗？
㈧ JAVA中带参数方法的概念
定义方法的时候,带参数的方法,就是说，你以后调用这个方法的时候，想往里面传一些内容，然后方法内部的执行运算会用到你传进去的这个内容，比如在Test类中有一个方法：
public int num(int i, int j) {
int k = i+j;
return k;
}
定义了num方法，num是方法名，后面的(int i, int j)叫做参数列表，参数列表里面的这些个变量被叫做形式参数，简称形参，方法的形参属于局部变量。
很明显方法内部要使用到这两个参数，叫他们相加，然后把结果使用return语句返回。
调用此方法：
int i = new Test().num(1, 1);
此时在调用的时候，传进去的两个值都是1，这两个1叫做实际参数，简称实参，然后方法开始执行，将1加1的和使用return语句返回，就把这个2返回给调用环境了，然后赋值给i了。
所以在这里总结一下：
形参: 用来接收调用方法的时候传进来的实参
实参：调用方法的时候，传进去的实际的值
还有什么不明白的？
㈨ java 方法参数的问题
通俗点说:小括号内的参数是在调用这个方法时,需要给这个方法传入的参数,用于给此方调用.比如说,有些方法是需要调用者传参,方法才能对参数进行操作!
㈩ java 方法可以传入多少个参数
java的方法可以动态传入参数，比如methodA(String... values)，它相当于传进入一个values的数组，因此在你的内存支持的情况下，参数个数可以是无限个的。