Java方法使用详解

(内容参考了《疯狂Java讲义》)

（一）方法调用

（1）方法类似于函数，但是与函数不同：方法必须定义在类里面
（2）定义在类中的方法，从逻辑上来看，
——如果有static修饰，该方法属于类本身，应该用类调用
——如果无static修饰，该方法属于对象本身，

方法不能独立执行，方法一定要有调用者
【规则】如果调用同一个类中的方法，可以省略调用者，系统会添加默认调用者
1）如果该方法是无static修饰的，则会添加this作为默认调用者
2）如果该方法是有static修饰的，则会添加类作为调用者

public class Item 
{
	public void info()//无static的方法
	{
		System.out.println("这是一个商品");
	}

	public static int add(int a, int b)//有static的方法
	{
		return a+b;
	}
//测试方法
	public void test()
	{
		info();//正确：
		this.info();//和info()效果一样

		//下面两行完全一样，因为是同一个类
		System.out.println(add(22,44));
		System.out.println(Item.add(22,44));//因为会添加类为调用者
//猪八戒吃西瓜，啃馒头（省略了同一句话中的主语）——java的优点
	}
}

（二）形参个数可变的方法：

类型… 形参名
本质是数组，等同于：类型[] 形参名
类型… 写法的好处是——调用方法的时候更加地方便，即可直接传入多个元素，系统会自动将他么封装成数组

缺点是：类型… 这种写法，只能作为形参列表的最后一个形参，即：一个方法中只能由一个个数可变的形参

public class VarArgs 
{
	//个数可变的参数
	public void test(int a, String... names)//等同于：类型[] 形参名
	{
		System.out.println("a参数为： " + a);
		System.out.println("name数组长度为： " + names.length);
		for(int i = 0;i < names.length; i++)//遍历
		{
			System.out.println(names[i]);
		}
	}

	public static void main(String... args) 
	{
		VarArgs va = new VarArgs();//va变量，可调用VarArgs类的构造器

		va.test(12, "abs", "sdf","dfghhgfd");//个数可变参数
		va.test(5, new String[]{"波多野结衣","泷泽萝拉"});//采用个数固定参数
	}
}

（三）递归方法

//方法里调用自身————递归带来了隐式循环。
//递归要避免无限递归（无限循环）——要在可能出现的某些情况下，不再调用方法自身
**1）调用递归**
public class 递归入门
{
	public int i = 0;
	public void test()
	{
		i++;
		System.out.println("test方法");
		if(i<20)
		{
			test();//省略this
		}
	}

	public static void main(String[] args) 
	{
		递归入门 dg = new 递归入门();
		dg.test();
	}
}

2）使用递归

要保证递归一定能出现递归结束的条件！！

//解数列题：f(1)=2;f(2)=5;...f(n)=f(n+2)-2*f(n+1),计算f(10)
public class Recusive
{
	public static int fn(int n)
	{
		if(n == 1)
		{
			return 2;
		}
        else if(n == 2)
		{
			return 5;
		}
		else
		{
			//递归
			//return fn(n+2) - 2 * fn(n+1);//不正确，找不到结束的条件
			return 2*fn(n-1) + fn(n-2);//这两个公式完全相同，但是后者正确
			//要保证递归一定能出现递归结束的条件！！
		}
	}
	public static void main(String[] args) 
	{
		System.out.println(Recusive.fn(10));
	}
}