java学习之路 之 基本语法-方法（函数）及练习题

方法（函数）：方法是类或对象行为特征的抽象，也称为函数。 Java里的方法不能独立存在，所有的方法必须定义在类里。

方法的声明的语法格式：

修饰符 返回值类型 方法名（参数类型 形参1，参数类型 形参2，….）｛

  程序代码  return 返回值;

｝

其中：
形式参数：在方法被调用时用于接收外部传入的数据的变量。
参数类型：就是该形式参数的数据类型。
返回值：方法在执行完毕后返还给调用它的程序的数据。
返回值类型：方法要返回的结果的数据类型。
实参：调用方法时实际传给函数形式参数的数据。

方法的调用：
方法只有被调用才会被执行

方法的调用的注意事项：
没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
定义方法时，方法的结果应该返回给调用者，交由调用者处理。
方法中只能调用方法，不可以在方法内部定义方法。

方法的重载(overload)：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

重载的特点：
与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

例如：
//返回两个整数的和  
int add(int x,int y){return x+y;}
//返回三个整数的和  
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和  
double add(double x,double y){return x+y;}

方法的参数传递：
方法，必须有其所在类或对象调用才有意义。若方法含有参数：
形参：方法声明时的参数
实参：方法调用时实际传给形参的参数值

Java的实参值传入方法
Java里方法的参数传递方式只有一种：值传递。  即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

方法练习题：

/**
方法: 也称为函数, 解决功能封装的问题
声明:
修饰符 返回值类型 方法名(形参类型1 形参1, 形参类型2 形参2, 形参类型3 形参3 .....) {
语句;
return 返回值类型的具体值;
}
*/
public class MethodTest {

// 方法 = 方法签名 + 方法体
public static int add(int a, int b) {
System.out.println("add(int " + a + ", int " + b + ")");
int c = a + b;
return c;
// c = f(a,b)
}

public static void test() { // 既没有返回值, 也没有形参
System.out.println("test()...");
}

public static void main(String[] args) {
System.out.println("main begin...");
// 方法调用的依据只能是方法签名(方法的使用说明书)
// 方法名(实际参数1, 实际参数2);
// 方法的返回值 就是方法调用本身
int x = add(10, 20);
System.out.println("x:" + x);

System.out.println(add(100, 200));

//System.out.println(test()); // 方法的标志是() 方法无返回值时, 不可以打印输出方法调用
test(); // 方法的标志是()

System.out.println("main end...");
}
}

/*
1.编写程序，定义三个重载方法并调用。方法名为mOL。
三个方法分别接收一个int参数、两个int参数、一个字符串参数。第一个方法执行平方运算并输出结果，
第二个方法执行相乘并输出结果，第三个方法执行输出字符串信息。
在主类的main ()方法中分别用参数区别调用三个方法。
*/
public class Method1 {

public static int mOL(int a) {
int result = a * a;
return result;
}
public static int mOL(int a,int b) {
int result = a * b;
return result;
}
public static String mOL(String str) {
String tem = str;
return tem;
}
public static void main(String[] args) {
System.out.println(mOL(5));
System.out.println(mOL(5,6));
System.out.println(mOL("我是第三个方法！"));
}
}

/*
定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方法求两个double值中的最大值，
第三个方法求三个double值中的最大值，并分别调用三个方法。
*/
public class Method2 {

public static int max(int a,int b) {
int max = a > b ? a : b;
return max;
}
public static double max(double a,double b) {
double max = a > b ? a : b;
return max;
}
public static double max(double a,double b,double c) {
double max = a > b ? a : b;
max = max > c ? max : c;
return max;
}
public static void main(String[] args) {
System.out.println(max(5,6));
System.out.println(max(5.5,6.6));
System.out.println(max(5.5,6.6,7.7));
}
}

//编写程序，声明一个method方法，在方法中打印一个10*8的矩形，在main方法中调用该方法。
//再声明一个方法method2, 在方法中打印一个n*m的矩形,在main方法中调用该方法.
//再声明一个方法method3, 在方法中打印一个n*m的矩形,打印完后计算矩形的周长并返回, 在main方法中调用该方法,
//打印矩形的周长
public class MethodExer {

public static void method() {
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 8; j++) {
System.out.print("*");
}
System.out.println();
}
}

public static void method2(int n, int m) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
System.out.print("*");
}
System.out.println();
}
}

public static int method3(int n, int m) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
System.out.print("*");
}
System.out.println();
}
int l = (m + n) * 2;
return l;
}

public static void main(String[] args) {
System.out.println("main begin");
// 方法调用
//method();
//method2(10, 8);
System.out.println(method3(20, 60)); // 先打印矩形, 再打印返回值
}
}

public class StaticClass1{
//方法的“连环调用”以及方法的重载，在Method类中调用实现
public static void method() {
//打印一个10*8的矩形
method2(10,8);
}

public static void method2(int n,int m) {
//打印一个n*m的矩形
for (int i = 0;i < n;i++) {
for (int j = 0;j < m;j++) {
System.out.print("*");
}
System.out.println();
}
}

public static int method3(int n,int m) {
//打印一个n*m的矩形并返回其周长
method2(n,m);
return 2 * (n + m);
}

public static int method3(int n) {
//打印一个n*n的正方形并返回其周长
return method3(n,n);
}
}

public class Method {
//编写程序，声明一个method方法，在方法中打印一个10*8的矩形，在main方法中调用该方法。
//在声明一个method2，在方法中打印一个n*m的矩形，在main方法中调用该方法。
//在声明一个method2，在方法中打印一个n*m的矩形并计算矩形的周长，在main方法中调用该方法。
public static void main(String[] args) {
/*
StaticClass.method();
StaticClass.method2(8,9);
System.out.println(StaticClass.method3(7,8));
System.out.println(StaticClass.method3(7));
*/

StaticClass1.method();
StaticClass1.method2(2,3);
System.out.println(StaticClass1.method3(10,15));
System.out.println(StaticClass1.method3(7));
}
}