方法详解

方法

1.java方法是语句的集合,它们搭配在一起执行一个功能;
2.方法是解决一类问题的步骤的有序组合;
3.方法包含于类或对象中;
4.方法在程序中被创建,在其他地方被引用;
代码示例:
//类	对象	方法()
System.out.println()//调用系统类(System),标准输出对象(out)的方法(println);
 //权限修饰符 返回值类型 方法名称([类型参数]),类型参数看是否需要,可不写;
    public int add(int num1,int num2){
    //方法体
}
5.设计方法的原则:方法的本意是功能块,就是实现某个功能的语句块的集合.
6.设计方法的时候,最好保持/*方法的原子性*/;/*就是一个方法只完成1个功能,这样利于我们后期的扩展*/
7.方法的命名格式是:小驼峰模式;//第一个单词首字母小写,之后的单词,首字母大写;
5.main方法尽量保持整洁,干净,将需要使用的语句块集成为方法,进行调用使用;

方法的定义

1.java的方法类似其他语言的函数,是一段用来完成特定功能的代码片段,一般情况下,定义一个方法包含以下语法:
2./*方法包含一个方法头和一个方法体.*/
3.下面是一个方法的所有部分:
	3.1:/*修饰符*/:修饰符,这是可选的,告诉编译器如何调用该方法,定义了该方法的访问类型;
	3.2:/*返回值类型*/:方法可能会返回值,returnValueType是方法返回值得数据类型,
	有些方法执行所需的操作,但没有返回值.在这种情况下,returnValueType是关键字void;
	3.3:/*方法名*/:是方法的实际名称,方法名和参数表共同构成方法签名;
	3.4:/*参数类型*/:参数像是一个占位符.当方法被调用时,传递值给参数;
	这个值被称为实参或变量,参数列表是指方法的参数类型,顺序和参数的个数,参数是可选的,方法可以不包含任何参数;
		3.4.1:形式参数:在方法被调用时,用于接受外界输入的数据;
		3.4.2:实参:调用方法时,实际传给方法的数据;
	3.5:/*方法体*/:方法体包含具体的语句,定义该方法的功能;	
	代码示例:
	修饰符 返回值类型 方法名(参数类型 参数名){
        ...
            方法体
       return 返回值;
    }

方法调用

1.调用方法:对象名.方法名(实参列表)
2.java支持两种调用方法的方式,根据方法是否返回值来选择;
3.当方法返回一个值的时候,方法调用通常被当做一个值;
例如:	int larger = max(30,40);
4.如果方法返回值是void,方法调用一定是一条语句;
例如:System.out.println("Hello,kuangshen!");
课后扩展了解: 
面试题:什么是 值传递(java) 和 引用传递;
1.java都是值传递;
2.值传递有一个拷贝的概念;

.即使再小的帆,也能扬帆远航;
.心急吃不了热豆腐;

方法的重载

1.重载就是在一个类中,有相同的方法(函数)名称,但形参不同的方法(函数);
2.方法重载的规则:
	2.1:方法名称/*必须相同*/;
	2.2:参数列表/*必须不同*/(个数不同,或类型不同,参数排列顺序不同等);
	2.3:方法的返回类型可以相同也可以不相同;
	2.4:仅仅返回类型不同不足以成为方法的重载;
3.实现理论:
	3.1:方法名称相同时,编译器会根据调用方法的参数个数,参数类型等去逐个匹配,以选择对应的方法,如果匹配失败,则编译器报错;
4.方法重载代码示例:
public static int add(int num1,int num2,int num3){
    return num1+num2+num3;
}
public static int add(int num1,int num2){
    return num1+num2;
}
.以上三数相加方法,与两数相加方法实现重载;

命令行传参

1.有时候你希望运行一个程序时候,再传递给它消息.这要靠传递命令行参数给main()方法(函数)实现;
2.代码示例:
public class CommandLine{
    public static void main(String[] args){
        for(int i=0;i<args.length;i++){
            System.out.println("args["+i+"]:"+args[i]);
        }
    }
}
3.使用命令行javac命令编译,使用java命令运行;
4.执行的时候,需要将包名,类名称写完整,才可以运行;
5.在类名之后,可以对main()方法传参;
6.代码示例:
java cn.itcast.day01.Demo01 this is a Demo
[this is a Demo]即是传进main()方法的四个字符串参数;

可变参数

1.JDK1.5开始,java支持传递同类型的可变参数给一个方法;
2.在方法声明中,在指定参数类型后加一个省略号(...);
3.一个方法中/*只能指定一个可变参数*/,它必须是方法的/*最后一个参数*/.
4.任何普通的参数必须在它之前声明;
5.代码示例:
public static void printMax(double... numbers){
    //判断数组长度
    if(numbers.length == 0){
        System.out.println("No argument passed");
        return;
    }
    //将返回值初始化,为数组第一个;
    double result = numbers[0];
    //排序
    for(int i =1;i< numbers.length;i++){
        //将第二个和之后其他数组数值与初始化数组(数组第一个数)相比较
        if(numbers[i]> result){
            //若其他数大于则覆盖写入;
            result=numbers[i];
        }
    }
    System.out.println("The max value is"+result);
}
6.方法越多,参数越多,越繁琐;
7.不定项参数,参数数组类似;
代码示例:
public class Demo01{
public static void main(String[] args){
    //通过创建类对象,来调用那个类里面的方法;
	Demo01 demo01 = new Demo01();
    //调用类里面的方法;
    //如果使用了可变参数,不传参也是可以的;但不传参,不可按数组进行调用;
    //传递了参数的话,那么方法中的可变参数,就有了最初的数组参数.由0开始;
    demo01.text(1);
	//加上static,不需要创建对象也可以使用,不加上,就需要创建对象来进行使用;
    public  void text(int... i){
        System.out.println(i[0]);
    }
}
}

递归

0./*面试高频问点*/;
1.A方法调用B方法,我们很容易理解;
2.递归就是:A方法调用A方法!就是自己调用自己;
3.利用递归可以用简单的程序来解决一些复杂的问题.
4.它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解.
5.递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算,大大的减少了程序的代码.
6.递归的能力在于用有限的语句来定义对象的无限集合;
7.递归结构包括两个部分:
	7.1:/*递归头*/:什么时候不调用自身方法.如果没有头,将陷入死循环;
	7.2:/*递归体*/:什么时候需要调用自身方法.
        
8.阶乘: 2!=2*1
        3!=3*2*1
        4!=4*3*2*1
        5!=5*4*3*2*1
9.代码示例:
public static int f(int n){
    int (n == 1){
        //最底层;
        return 1;
    }else{
        //如果传进来的值,不是等于1,那么就会一直进行再次调用,直到调用到最底层;
        //如果方法没执行到最底层,那么就会持续执行到最底层;
        //假设传值为3,那么将会为3*f(3-1)得到3*2,
        //由于f(2)还不是最底层.那么将会得到再次调用;
        //得到3*f(2-1) 为3*1,为最底层,结束调用;
        //之后由最底层返回结果到上层,一直到最上层,得出结果再返回其调用方法处;
        //3*2(6)->[6]*1(6)->调用处;例:4*3(12)->12*2(24)->24*1(24)-调用处;
        return n*f(n-1);
    }
}
	9.1:假设传值为3, =3*f(3-1)=3*f(2)=3*2
	9.2:=3*f(2-1)=3*f(1)=3*1;
	9.1:由最高层一直调用至最低层,没到最低层,将会持续执行;
	9.2:如果没有设置最底层出口,那么程序将会发生内存溢出错误(自身调用太多)
        无限循环报错;
10.边界条件:边界(最底层,程序离开循环方法;);
11.前阶段:当方法不处于最底层时,依次向下层调用;
12.返回阶段:当方法处于最底层时,得出最底层结果,然后传递给上一层,依次上传,直到最上层;
再传回给调用处(n*n-1);
13.递归会造成大量调用,对于某些嵌套层次比较深的代码,递归就显得力不从心;造成占用大量内存;
14.递归的深度越大,程序的时空性就越不好;
15.能不用递归,就不用递归;
16.有些事物,使用递归是可以快速解决的,但前提是/*递归的基数小的情况下*/;
17.(递归思想)递归,说白了,其实是一种思想的学习;

栈机制

1.java都是使用栈机制的;

章节作业;写一个计算器,要求实现加减乘除功能,并且能够循环接收新的数据,通过用户交互实现;
18.1.思路推荐:
18.2.写四个方法:加减乘除;
18.3.利用循环+Switch进行用户交互;
18.4.传递需要操作的两个数;
18.5.输出结果;

//勉强完成,不够精简代码.下次使用数组加提示方法尽量精简;