这个问题其实很容易的，
就是你以后要不要使用这个方法执行的结果，如果使用就返回，不使用就void
其次再考虑返回的类型。
java是面向对象的语言，它推荐我们操作的是对象，那么你可以返回对象，但是我们用到的是某个对象的属性，那怎么办呢？容易，我们定义一个Bean，例如我们定义一个Dog类（实体Bean），但是我们要用的是dog的名字，那怎么办，在这个实体类中写好getters和setters，我们拿到具体的某个Dog的实例，也就是对象，调用它的get方法就可以得到dog的名字了。
可是有些小程序中，我们直接返回Object的话，操作很不方便，怎么办呢？
比如，我们的一个方法就是用来计算两个数的和，如果返回对象类型的话，操作很不方便，
我们这个时候就要考虑了，我们如果那这个结果是用来显示的，那么，你返回String类型的也行，double的也行，如果是用来做其他计算的话，那就返回double或者long或者其他表示数的就行，这里只要注意计算后的精度就可以了。
有空自己多看书和想想,路长着呢,给你一些我写的测试,一般举例要靠自己想的,自己去测试或者说去动手实验,不要纸上谈兵了,慢慢思考
package 参数和返回值和Object;
import 深入研究.Calendar;
import 深入研究.Test;
public class ParameterReturn {
static Data[] data = new Data[7]; // 对象数组
static Object [] object = new Object[4];// 未知对象数组
/**
* 函数的测试
* @param args
*/
public static void main(String[] args) {
System.out.println(para(2));
System.out.println("1: " + r_5(1));
System.out.println("2: " + r_5(2));
System.out.println("3: " + r_5(3));
System.out.println("4: " + r_5(4));
System.out.println("5: " + r_5(5));
System.out.println("6: " + r_5(6));
System.out.println("7: " + r_5(7));
System.out.println("8: " + r_5(8));
System.out.println("9: " + r_5(9));
System.out.println("10: " + r_5(10));
System.out.println("11: " + r_5(11));
System.out.println("12: " + r_5(12));
System.out.println("13: " + r_5(13));
}
/**
* 参数的探讨 parameter
* 重载
* @param
*/
/**
* 普通数据类型,
* @param a
* @param b
* @param c
* @param d
*/
public static void para(String a, double b, long c, boolean d) {
}
/**
* 2.数组,1维数组 到 4维数组 到......N维数组
* @param a
* @param b
* @param c
* @param d
*/
public static void para(String[] a, double[][] b, long[][][] c, boolean[][][][] d) {
}
/**
* 3.对象参数,N个对象参数
* @param a
* @param b
* @param c
* @param d
*/
public static void para(Object a, Test b, Calendar c, ParameterReturn d) {
}
/**
* 4.对象数组,1维对象数组 到 4维对象数组 到......N维对象数组
* @param a
* @param b
* @param c
* @param d
*/
public static void para(Object[] a, Test[][] b, Calendar[][][] c,ParameterReturn[][][][] d) {
}
/**
* 5.函数可以用来传参吗???可以啊
* @param no
* @return
*/
public static int para(int no) {
// para(1) 的返回值是整型
if(no == 1)// 不过类似死循环的死递归
return para(para(1)); // 看出来了吗?para(1)的逻辑错误
else
return no;
}
/**
* 返回值的探讨 return
* 返回的必须是一个值,一个地址(引用) 或着说 一个变量,一个函数值,一个数组,一个对象,,...
* @return
*/
/**
* 0.很简单的返回
* @param no
* @return
*/
public static int r_0(int no){
switch (no) {
case 1:
return 1;
case 2:
int i2 = 2;
return i2;
case 3:
return r_0(1); // 返回函数值
default:
return r_0(0); // 返回函数值,r_0(0)死的嵌套函数
}
}
/**
* 1.返回布尔变量// 详情见数组对象和Equals
* @param no
* @return
*/
public static boolean r_1(int no) {
switch (no) {
case 1:
String s1 = new String("123");
boolean f = s1.equals("123"); // true
return f;
case 2:
// String s1 = "123"; // s1变量不能用,声明又重复了
// return s1.equals("123"); // true s1变量不能用
String s2 = "123";
return s2.equals("123"); // true
case 3:
String s3 = "123";
return s3.equals(s3); // true
case 4:
return "123".equals("123"); // true
case 5:
return "123".equals(123); // false
case 6:
String s6 = "123";
return "123".equals(s6); // true
case 7:
return new String("什么").equals("什么"); // true
case 8:
return true;
default: // 详情见 数组对象和字符串bool
return new String[3].equals(null); // false
}
}// @@ r_2()
/**
* 2.返回字符串(引用类型)
* @param no
* @return
*/
public static String r_2(int no) {
switch (no) {
case 1:
String s1 = new String("s1");
return s1;
case 2:
String s2 = "s2";
return s2;
default:
return new String("s3");
}
}
/**
* 3.返回字符串数组(引用类型),注意返回的是地址
* @param no
* @return
*/
public static String[] r_3(int no) {
switch (no) {
case 1:
String[] s1 = new String[3];
s1[0] = "1";
return s1;
case 2:
String[] s2 = { "1", "2", "3" };
return s2;
default:
return new String[3];
}
}
/**
* 4.返回对象Data
* @param no
* @return
*/
public static Data r_4(int no){
switch (no) {
case 1:
Data d1 = new Data();
return d1;
default:
return new Data(); // 返回对象
}
}
/**
* 5.返回object对象 万物接对象,什么都可以返回了
* @param no
* @return
*/
public static Object r_5(int no){
switch (no) {
case 1:
Data d1 = new Data();
return d1;
case 2:
return new Data(); // 返回对象
case 3:
Object o3 = new Object();
return o3;
case 4:
return new Object();
case 5:
Data[] d5 = new Data[3];
return d5;
case 6:
return new Data[3];
case 7:
return data; // 返回对象数组
case 8:
String[] s8 = new String[3];
s8[0] = "1";
return s8;
case 9:
String[] s9 = { "1", "2", "3" };
return s9;
case 10:
return new String[3];
case 11:
Object[] o11 = new Object[3];
return o11;
case 12:
return new Object[4]; // 返回对象数组
default:
return object; // 返回对象数组
}
}
/**
* 6.返回对象Data[]数组
* @param no
* @return
*/
public static Data [] r_6(int no){
switch (no) {
case 1:
Data[] d1 = new Data[3];
return d1;
case 2:
return new Data[3];
default:
return data; // 返回对象数组
}
}
/**
* 7.返回object[]对象数组
* @param no
* @return
*/
public static Object [] r_7(int no){
switch (no) {
case 1:
Data[] d1 = new Data[3];
return d1;
case 2:
return new Data[3];
case 3:
return data; // 返回对象数组
case 4:
String[] s4 = new String[3];
s4[0] = "1";
return s4;
case 5:
String[] s5 = { "1", "2", "3" };
return s5;
case 6:
return new String[3];
case 7:
Object[] o7 = new Object[3];
return o7;
case 8:
return new Object[4]; // 返回对象数组
default:
return object; // 返回对象数组
}
}
};//@
这就看你需要返回什么类型，
public class first {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
first ft=new first();
System.out.println(ft.oper());
System.out.println(ft.oper2());
}
public String oper(){
String ab="返回String类型的";
return ab;
}
public int oper2(){
int b=2;
return b;
}
}
需要什么就返回什么就可以了
内容全部来源于网络收集，如有侵权，请联系网站删除：QQ：24596024