java多参数
⑴ java类中方法中的参数过多如何处理
把参数封装成实体类啊，如果是同类型的前提下，可以用...这种数量可变的参数
⑵ java中通过键盘输入获取多个参数
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
publicclassTest{
publicstaticvoidmain(String[]args)throwsIOException{
BufferedReaderreader=newBufferedReader(newInputStreamReader(System.in));
Stringarg=reader.readLine();
String[]num=arg.split("");
inta=Integer.valueOf(num[0]);
intb=Integer.valueOf(num[1]);
intc=Integer.valueOf(num[2]);
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("c="+c);
}
}
⑶ java 方法参数过多，怎么处理
方法中的参数是：方法在运行的时候，要用到的值…给你举个简单的例子，求两个整数中的最大值假设有一个方法就做max(inta,intb);这个方法带有两个参数a和b(a,b都为int型)这时，你在用这个方法的时候，你就得给它两个值，用你实际的值，代替两个a,b,这个方法才会把最大的那个值，给你返回。如你这样写max(1,9);这个函数就会给返回最大的值9方法，带有参数的话，你就得给传参数，这样方法才能正常的正确的执行，另外注意，所传递的参数的类型，否则会出错
⑷ java中多线程常见的几个参数
java中多线程常见的几个参数
sleep：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）.
此操作受到系统计时器和调度程序精度和准确性的影响。
该线程不丢失任何监视器的所属权。
调用sleep的时候锁并没有被释放。
休眠
Java SE5引入了更加显示的sleep()作为TimeUnit类的一部分，这个方法允许你指定sleep()延迟的时间单元，因此可以提供更好的可阅读性。
wait：调用wait使线程挂起，直到线程得到了notify或notifyAll消息，线程才会进入就绪状态。
使你可以等待某个条件发生变化，而改变这个条件超出了当前方法的控制能力。
线程的执行被挂起，对象上的锁被释放。意味着另一个任务可以获得这个锁。
因此在该对象中的其他synchronized方法可以在wait期间被调用。
yield：相当于：我的工作已经做的差不多了，可以让给别的线程使用CPU了。
当调用yield时，你也是在建议具有相同优先级的其他线程可以运行。
对于任何重要的控制或在调整应用时，都不能依赖于yield。
yield并不意味着退出和暂停，只是，告诉线程调度如果有人需要，可以先拿去，我过会再执行，没人需要，我继续执行
调用yield的时候锁并没有被释放。
interrupt：中断线程。
Thread类包含interrupt()方法，因此你可以中止被阻塞的任务。
这个方法将设置线程的中断状态。
如果一个线程已经被阻塞，或者试图执行一个阻塞操作，那么设置这个线程的中断状态将抛出InterruptedException。
当抛出该异常或者该任何调用Thread.interrupted()时，中断状态将复位。
你在Executor上调用shutdownNow()，那么它将发送一个interrupt()调用给他启动的所有线程。
⑸ java中，构造函数的参数太多怎么办
将这些参数放到一个数组里，或者一个对象中，比如：
publicclassPeople
{
privateintid;
privateStringname;
privateintage;
//如果参数的类型不一致，就要麻烦点，需要定义一个Object类型的数组
publicPeople(Object[]obj)
{
this.id=Integer.valueOf(obj[0]).inValue();
this.name=String.valueOf(ojb[1]);
this.age=Integer.valueOf(obj[2]).inValue();
}
}
以上只是描述下大致的意思，总结下，方法的参数过多时，通常的方法就是如此。
⑹ Java方法参数太多怎么办
引入参数对象
Person.class
public class Person {
public FullName fullName;
public Address address;
public boolean isFemale;
public boolean isEmployed;
public boolean isHomeOwner;
public Person(FullName fullName, Address address, boolean isFemale, boolean isEmployed, boolean isHomeOwner) {
this.fullName = fullName;
this.address = address;
this.isFemale = isFemale;
this.isEmployed = isEmployed;
this.isHomeOwner = isHomeOwner;
}
}
FullName.class
public class FullName {
public String lastName;
public String firstName;
public String middleName;
public String salutation;
public String suffix;
public FullName(String lastName, String firstName, String middleName, String salutation, String suffix) {
this.lastName = lastName;
this.firstName = firstName;
this.middleName = middleName;
this.salutation = salutation;
this.suffix = suffix;
}
}
Address.class
public class Address {
public String streetAddress;
public String city;
public String state;
public Address(String streetAddress, String city, String state) {
this.streetAddress = streetAddress;
this.city = city;
this.state = state;
}
}
问题：参数对象可能被滥用。如果一个开发者纯粹为了减少参数数量，把联系不紧的几个参数强捆在一个类中这肯定是行不通的，在可读性上甚至适得其反。
参数关系紧密合并到一个对象中
Builder模式：
Address.class
优点：客户端代码的可用性和可读性得到了大大提高，构造函数的参数数量明显减少调用起来非常直观。单个builder构建多个对象时Builder参数可在创建期间进行调整，还可以根据对象不同而进行改变，有效的避免重载构造函数。
缺点：增加代码量，代码变得更加冗长(相比较参数数量的增加，相同类型的参数混在一起，可选参数的增加而言，改善代码可读性更有价值)
Person.class
需求：当一个对象需要不同的参数构造方法？不能写5*5满足所有的需求吧
适用范围：构建对象时，如果碰到类有很多参数——其中很多参数类型相同而且很多参数可以为空时，使用Builder模式来完成。当参数数量不多、类型不同而且都是必须出现时，通过增加代码实现Builder往往无法体现它的优势。在这种情况下，理想的方法是调用传统的构造函数。再者，如果不需要保持不变，那么就使用无参构造函数调用相应的set方法吧。
代码
public class Person {
public FullName fullName;
public Address address;
public boolean isFemale;
public boolean isEmployed;
public boolean isHomeOwner;
public Person(FullName fullName, Address address, boolean isFemale, boolean isEmployed, boolean isHomeOwner) {
this.fullName = fullName;
this.address = address;
this.isFemale = isFemale;
this.isEmployed = isEmployed;
this.isHomeOwner = isHomeOwner;
}
public static class Builder {
private FullName fullName;
private Address address;
private boolean isFemale;
private boolean isEmployed;
private boolean isHomeOwner;
/**
* 如果有必填参数这里可以构造必填构造方法
*/
public Builder() {
}
public Builder setFullName(FullName fullName) {
this.fullName = fullName;
return this;
}
public Builder setAddress(Address address) {
this.address = address;
return this;
}
public Builder setFemale(boolean female) {
isFemale = female;
return this;
}
public Builder setEmployed(boolean employed) {
isEmployed = employed;
return this;
}
public Builder setHomeOwner(boolean homeOwner) {
isHomeOwner = homeOwner;
return this;
}
public Person create() {
return new Person(fullName, address, isFemale, isEmployed, isHomeOwner);
}
}
}
FullName.class
public class FullName {
public String lastName;
public String firstName;
public String middleName;
public String salutation;
public String suffix;
public FullName(String lastName, String firstName, String middleName, String salutation, String suffix) {
this.lastName = lastName;
this.firstName = firstName;
this.middleName = middleName;
this.salutation = salutation;
this.suffix = suffix;
}
public static class Builder {
private String lastName;
private String firstName;
private String middleName;
private String salutation;
private String suffix;
public Builder() {
}
public Builder setLastName(String lastName) {
this.lastName = lastName;
return this;
}
public Builder setFirstName(String firstName) {
this.firstName = firstName;
return this;
}
public Builder setMiddleName(String middleName) {
this.middleName = middleName;
return this;
}
public Builder setSalutation(String salutation) {
this.salutation = salutation;
return this;
}
public Builder setSuffix(String suffix) {
this.suffix = suffix;
return this;
}
public FullName create() {
return new FullName(lastName, firstName, middleName, salutation, suffix);
}
}
}
public class Address {
public String streetAddress;
public String city;
public String state;
public Address(String streetAddress, String city, String state) {
this.streetAddress = streetAddress;
this.city = city;
this.state = state;
}
public static class Builder {
private String streetAddress;
private String city;
private String state;
public Builder() {
}
public Builder setStreetAddress(String streetAddress) {
this.streetAddress = streetAddress;
return this;
}
public Builder setCity(String city) {
this.city = city;
return this;
}
public Builder setState(String state) {
this.state = state;
return this;
}
public Address create() {
return new Address(streetAddress, city, state);
}
}
}
调用的地方
public static void main(String[] args) {
FullName fullName = new FullName.Builder().setFirstName("yes")
.setLastName("no").create();
Address address = new Address.Builder().setCity("china").setState("12")
.create();
Person person = new Person.Builder().setAddress(address)
.setFullName(fullName).create();
}
重载
适用范围：方法中参数可选参数或者参数中指定参数相同
代码
public String name(String name,int year) {
return name+year;
}
/**
* 重载
* @param name
* @return
*/
public String name(String name) {
return name+"null";
}
优点：遇到可选参数或者默认参数时，使用方法重载会十分有效。
⑺ java方法的参数可以是多个吗
不可以，参数需要传递值，接口里只有方法申明，不能有参数属性，所以传递接口类型没有任何意义。
⑻ java实现一个类返回多个参数
//a接口
interface
a{
public
int
geta();
}
//b接口
interface
b{
public
int
getb();
}
//实现了某个接口必须实现其全部的方法
public
class
impab
implements
a,b{
public
int
geta()
{
return
0;
}
public
int
getb()
{
return
0;
}
}
已经很简单的了...
呵呵....
祝楼主早日成功哈!!!
⑼ java参数过多，怎么处理
class TestClass{ private String para=""; //表示一个参数 public void TestMethod(String para) { this.para=para; //some code here } public void OutputPara() { System.out.println("TestMethod中用到的参数是:" + this.para); }}不知道是不是这个意思