java实际参数什么意思 Java中实际参数和形式参数的区别
大家好，如果您还对java实际参数什么意思不太了解，没有关系，今天就由本站为大家分享java实际参数什么意思的知识，包括Java中实际参数和形式参数的区别的问题都会给大家分析到，还望可以解决大家的问题，下面我们就开始吧！
java 参数中含有… 是什么意思啊
main方法的签名其实可以这样写:
public static void main(String... args)//方法1
它也可以运行.
并且,如果同时还存在
public static void main(String[] args)//方法2
会报已经存在重复的方法的错误.
由此可见,String... args跟String[] args对于虚拟机来说其实是一回事.
而且,在方法内,通过...传进来的参数的使用方法也跟一个数组完全无二,可以for循环,甚至可以直接转换:
public static void main(String... args)
{
String[] ss=args;
}
但对于程序员来说却还是有差别的.
1.调用
我们只能这样调用方法2:
main(new String[]{});
即,方法2只能接受String数组做参数.
而我们陌生的方法1可强了,用以下参数调用,照单全收:
main();
main(null);
main(null,null);
main(null,null,null);
......
main("a");
main("a","b");
main("a","b","c");
......
main(new String[]{});
(String...匹配String*,而null也可以是一个特殊的String)
2.参数位置
使用...的参数只能是最后一个参数.不然谁知道你调用的时候,点点点匹配到哪个实参?
public static void main(String[] args,int index)//可以
public static void main(String... args,int index)//不行!
3.重载
假设有以下两个方法:
public static void main(String... args)//方法1
public static void main(String a,String... args)//方法3
从语法上来看,这个重载完全没有错误,eclipse也没有报错.但是当调用时使用的参数个数大于这些方法中点点点参数前面的参数个数时,eclipse就会发现这个错误了.很拗口是不是?嘿嘿~还是举例来说吧.以上这两个方法,如果调用时
main();
编译器会认出这个调用的是方法1.但是如果调用时
main("");
编译器就疯了...因为一个String参数,既符合方法1的点点点,也符合方法3的String+点点点,编译器就不知道调用的是哪个方法了.
String[]参数不会有这种问题.
所以重载时要注意,如果点点点参数前面有跟它类型相同的参数...最好的方法,似乎就是换回数组形式了,要么就给方法改个名字吧.
4.遇上泛型加外包
用个实例来说
java.util.Arrays是个工具类,所有方法都是静态的,对数组的操作.里面有个方法asList(T... args),用来把类型T的数组转化成List<T>.
这是个很有用的方法,在绝大多数情况下都能如你所愿.
但是,你可以试试下面的写法
int[] is=...//自定义的数组,或者从什么地方获取来的数组
List<Integer> list=Arrays.asList(is);
很不幸,不要说执行,编译都通不过.错误的意思大概是:
不能将List<int[]>转化成List<Integer>
明白了吧?
你的设想是,把int[]中的每一个元素对应T...中的每一个点,
可编译器不这么想.因为int是原始类型,不是Object的子类.而泛型T隐含的条件是T extends Object.所以编译器不会把每一个int看做T,不会把int[]看做T点点点.虽然java已经支持自动将原始类型封包成外包类,但那是单个的情况.
而数组(不管什么类型)则是一种特殊的类型,是Object的子类,所以编译器觉得整个int[]对应一个T,你调用的方法是asList<int[]>(int[]... args)而不是你想象中的asList<Integer>(Integer...)
java编译报错:实际参数列表和形式参数列表长度不同
以下是我给你修改的代码，有注释的行是你需要改的。纯手写，求财富值！（下种子用...T_T）
import java.util.*;
import java.util.Calendar;
public class Student{
int id, Byear;
double eng,math,com;
public Student(int id, int Byear, double eng,double math,double com){//参数列表要这么改
this.id= id;
this.Byear= Byear;
this.eng= eng;
this.math= math;
this.com= com;
};
public int getId(){
return id;
}
public int getBYear(){
return Byear;
}
public double getEng(){
return eng;
}
public double getMath(){
return math;
}
public double getCom(){
return com;
}
public double getSum(){
return this.eng+ this.math+ this.com;
}
public int getAge(int Byear) throws Exception{//Byear参数类型改为int
Calendar cal= Calendar.getInstance();
if( cal.get(Calendar.YEAR)< Byear){//把当前年份和输入年份比较
throw new IllegalArgumentException(
"The birthYear is before Now.It's unbelievable!");
}
int yearNow= cal.get(Calendar.YEAR);//得到当前年份
// cal.setTime(Byear);不要了
// int yearBirth= cal.get(Calendar.YEAR);不要了
int age= yearNow- Byear;//相减得到年龄
return age;
}
public static void main(String[] args){
Date NowYear= new Date();//输出当前时间
System.out.println(NowYear);
Student stu= new Student(1054,1993,78,84,90);//这时按照你的构造函数实例化Student类
System.out.println("总成绩:"+stu.getSum());
System.out.println("年龄:"+stu.getAge());
//System.out.println(stu.toString());你没有@Override toString()函数，别这么写
}
}
Java中实际参数和形式参数的区别
形参和实参有以下显著的区别:
1、形参不能离开方法。形参只有在方法内才会发生作用，也只有在方法中使用，不会在方法外可见。而实参可以再程序的任何地方都使用。
2、形参代表一个合集，具有不确定性，而形参代表一个独立事物，具有确定性（即使是为null）。也就是说，形参不能代表具体的对象，只能代表这些对象共同的属性（比如超类、各种其他自定义属性等等），而实参则是具体的对象（比如超类的实例）。
3、形参的值在调用时根据调用者更改，实参则用自身的值更改形参的值（指针、引用皆在此列）、
Java中的 static{ …… } 是什么意思
是静态修饰符，什么叫静态修饰符呢？大家都知道，在程序中任何变量或者代码都是在编译时由系统自动分配内存来存储的，而所谓静态就是指在编译后所分配的内存会一直存在，直到程序退出内存才会释放这个空间，也就是只要程序在运行，那么这块内存就会一直存在。这样做有什么意义呢？
在Java程序里面，所有的东西都是对象，而对象的抽象就是类，对于一个类而言，如果要使用他的成员，那么普通情况下必须先实例化对象后，通过对象的引用才能够访问这些成员，但是有种情况例外，就是该成员是用static声明的（在这里所讲排除了类的访问控制），例如：
未声明为static
class ClassA{
int b;
public void ex1(){
…
}
}
class ClassB{
void ex2{
int i;
ClassA a= new ClassA();
i= a.b;//这里通过对象引用访问成员变量b
a.ex1;//这里通过对象引用访问成员函数ex1
}
}
声明为static
class ClassA{
static int b;
static void ex1(){
…
}
}
class ClassB{
void ex2{
int i;
i= ClassA.b;//这里通过类名访问成员变量b
ClassA.ex1;//这里通过类名访问成员函数ex1
}
}
通过以上两种比较，就可以知道static用来修饰类成员的主要作用了，在java类库当中有很多类成员都声明为static，可以让用户不需要实例化对象就可以引用成员，最基本的有Integer.parseInt()，Float.parseFloat()等等用来把对象转换为所需要的基本数据类型。这样的变量和方法我们又叫做类变量和类方法。
接下来讲一下被static修饰后的变量的值的问题，刚才在前面讲过，被static修饰后的成员，在编译时由内存分配一块内存空间，直到程序停止运行才会释放，那么就是说该类的所有对象都会共享这块内存空间，看一下下面这个例子：
class TStatic{
static int i;
public TStatic(){
i= 4;
}
public TStatic(int j){
i= j;
}
public static void main(String args[]){
TStatic t= new TStatic(5);//声明对象引用，并实例化
TStatic tt= new TStatic();//同上
System.out.println(t.i);
System.out.println(tt.i);
System.out.println(t.i);
}
}
这段代码里面Tstatic类有一个static的int变量I，有两个构造函数，第一个用于初始化I为4，第二个用于初始化i为传进函数的值，在main中所传的值是5，程序首先声明对象的引用t，然后调用带参数的构造函数实例化对象，此时对象t的成员变量I的值为5，接着声明对象tt，调用无参数的构造函数，那么就把对象tt的成员变量i的值初始化为4了，注意了，在这里i是static，那就是说该类的所有对象都共享该内存，那也就是说在实例化对象tt的时候改变了i的值，那么实际上对象t的i值也变了，因为实际上他们引用的是同一个成员变量。最后打印的结果是三个4。呵呵，写到这里大家是否明白了呢？不明白就再看看书或者多写几个例子印证一下，呵呵。
好了，文章到这里就结束啦，如果本次分享的java实际参数什么意思和Java中实际参数和形式参数的区别问题对您有所帮助，还望关注下本站哦！