javaSE基础 方法（六）

1. 方法

 解决事件的办法

作用：

  实现功能的办法。

注意：

  方法定义在类中方法外，方法本身不能嵌套
  方法不调用不执行

优点：

		提高了代码的复用性。
		提高了程序的安全性。

语法：

没有返回值类型
	修饰符 void  方法名（参数列表）{
	实现功能的代码块
	[return；]
	}
有返回值类型
	修饰符 返回值类型 方法名（参数列表）{
	实现功能的代码块
	[return返回值;]

}
修饰符 : 访问权限修饰符
目前为 : public static
方法值 :

方法执行完毕之后是否需需要得到一个结果(值)
结果值的数据类型 : 就是有返回值类型方法的返回值类型

void : 没有返回值类型的
方法名 :

标识符->命名规则|规范
调用方法需要跟随方法名调用

参数列表 : 功能定义的时候是否存在未知的数据,有可能会改变的数据,如果存在定义在参数列表中
可以定义参数,可以不定义参数

		参数 :数据类型 参数名,数据类型 参数名..
			相当于局部变量的声明--> 作用域只属于当前的方法 
			数据类型 : 可以为基本数据类型|引用数据类型

{} : 方法体
具体实现功能的代码段

return :
1. 提前结束方法
2. 带出返回值 -> return 返回值;

方法的调用 :

执行方法中的代码
基础调用 : 方法名(参数列表);
赋值调用 : 数据类型 变量名 = 方法名(参数列表);
输出调用 : System.out.println(方法名(参数列表));

赋值调用与输出调用关注返回值,接收使用了返回值,基础调用调用只是执行方法中的代码没有接收返回值

代码：

public class Class033_Method {
	        //成员位置 : 类中方法外
	    public static void main(String[] args) {
	            //有返回值方法调用
	            //基础调用
	            getPI();
	            //赋值调用
	            double pi = getPI();
	            System.out.println(pi);
	            //输出调用
            System.out.println(getPI());

            System.out.println(getSum(3,5));
            System.out.println(getSum(7,5));

            //没有返回值方法调用
            //基础调用
            print();
            print();
            print();
            print();
        }

        //需求 : 返回pi的值
        //参数 : 没有参数
        //返回值 : 返回pi的值  double
        //方法名 : getPI
        public static double getPI(){
            System.out.println("没有参数有返回值类型的方法");
            return 3.1415926;
        }

        //需求 : 计算两个整数的和
        //参数 : int x,int y
        //返回值 : int
        //方法名 : getSum
        public  static  int getSum(int x,int y){
            System.out.println("有参数有返回值类型的方法");
        return x+y;

        }

        //需求 : 输出99乘法表
        //参数 : 没有
        //返回值 : 不需要
        //方法名 : print
        public static void print(){
        for (int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.println(i+"*"+j+"="+i*j+"\t");
            }
            System.out.println();

        }
    }
	}

参数

形式参数（形参） 
定义方法时候（）的参数-->局部变量的声明
实际参数（实参）
调用方法时候（）的参数-->局部变量的赋值

代码：

public class Class035_Method {
				    public static void main(String[] args) {	
			                int area = getArea(5,7);
			                System.out.println(area);
			            }
			            //矩形面积
			            public static int getArea(int w,int h){
			                return w*h;
	  }     
	}

return

有返回值类型的方法中

 必须存在return，同时需要带出返回值 
 1）提前结束方法（）
 2）结束方法同时带出返回值，返回给方法的调用
 没有返回值类型的方法中 
 可以存在return，但是不能带出返回值 
 1）提前结束方法（）

问 : break,continue,return之间的区别

 作用：break 结束终止 ，continue 跳过本次循环执行下一次循环 return 终止返回
 应用场景：break—>switch|循环 continue—>循环，return—>方法

兼容类型
参数兼容类型

	 形参类型>=实参类型

返回值兼容类型

 接收返回值的变量类型>=方法的返回值类型>=return后面结果的类型

代码：

public class Class036_Return{

public static void main(String[] args) {
	byte b = 1;
	byte i = test(b);
}

public static int test(int i){
	return 'a';
}
}

方法的重载

实现重载的三个条件：

一个类中有多个方法
一个类中方法名相同
不同类型的参数列表不同|方法签名不同

方法签名;

方法的唯一标识
方法名+参数列表	=方法签名

重载方法的调用：

 根据实参区分

分析：

方法的重载与参数名无关
方法的重载与方法修饰符无关
方法的重载与方法的返回值无关

总结：

方法的重载只与方法名和参数类型有关
方法就是封装的体现
方法的重载就是多态的一种体现   

代码：

public class Class038_Practice {
	    public static void main(String[] args) {
	        getArea(10,5.6);
	        getArea1(3.14,2.6);
	        getArea2(3,6,5);
	        /*
		方法的重载练习
	*/
	    }
	        /*
	            1.求长方形面积		长*宽
	            2.求圆形面积		π*半径的平方
	            3.求梯形面积		(上边+下边)*高/2
	        */
	        //1.求长方形面积		长*宽
	        public static void getArea(int i,int j){
	            System.out.println("长方形面积是:"+i*j);
	        }
	        public static void getArea(int i,double j){
	            System.out.println("长方形面积是:"+i*j);
	        }
	        public static void getArea(double i,double j){
	            System.out.println("长方形面积是:"+i*j);
	        }
	        public static void getArea(double i,int j){
	            System.out.println("长方形面积是:"+i*j);
	        }
	        //2.求圆形面积		π*半径的平方
	        public  static void getArea1(double pi,int r){
	            if (pi==3.14){
	                System.out.println("圆的面积是:"+pi*r*r);
	            }else {
	                System.out.println("pi输入错误");
	            }
	        }
	        public  static void getArea1(double pi,double r){
	            if (pi==3.14){
	                System.out.println("圆的面积是:"+pi*r*r);
	            }else {
	                System.out.println("pi输入错误");
	            }
	        }
	       // 3.求梯形面积		(上边+下边)*高/2
	        public static void getArea2(int s,int x,int h){
	            System.out.println("梯形面积是:"+(s+x)*h/2);
	        }
	        public static void getArea2(int s,double x,int h){
	            System.out.println("梯形面积是:"+(s+x)*h/2);
	        }
	        public static void getArea2(int s,double x,double h){
	            System.out.println("梯形面积是:"+(s+x)*h/2);
	        }
	        public static void getArea2(double s,double x,double h){
	            System.out.println("梯形面积是:"+(s+x)*h/2);
	        }
	        public static void getArea2(double s,int x,double h){
	            System.out.println("梯形面积是:"+(s+x)*h/2);
	        }
	        public static void getArea2(double s,int x,int h){
	            System.out.println("梯形面积是:"+(s+x)*h/2);
	        }
	        public static void getArea2(double s,double x,int h){
	            System.out.println("梯形面积是:"+(s+x)*h/2);
	        }
	        public static void getArea2(int s,int x,double h){
	            System.out.println("梯形面积是:"+(s+x)*h/2);
	        }
	        
	}

递归

方法的内部自己调用自己
优点：

程序更加的简单，简洁

缺点：

容易造成内存溢出

实现组成：

基线条件|递归头 停止自己调用自己的条件
递归条件|递归体 自己调用自己

执行过程：

递归前进段：自己调用自己
临界条件：停止自己调用自己的条件
递归后退段：从临界条件开始，不停的将结果返回给上一层	

代码：

public class Class039_Recurtion{
public static void main(String[] args) {
	System.out.println(rec(-1));;
}

//求阶乘 : 求某一个数阶乘
public static int rec(int i){
	if(i<=0){
		System.out.println("数据i为负数,不能求阶乘!!!");
		return 0;
	}
	if(i==1){
		return 1;
	}
	return i*rec(i-1);
}
}