概念
概念：也叫函数，其实就是具有一定特殊功能的一段代码，将需要在多个位置重复使用的一组代码，定义在方法内部。
意义：1.避免了重复的代码。2.增强了程序的扩展性。
定义方法
用法：
step1：方法的定义(声明)
public static void main(String[] args) {}语法格式：
[修饰符1,修饰符2...] 返回值/void 方法名(参数列表){
.....
return
}示例：
//求1-10的和
public static void getSum(){
//方法体
int sum =0;
for(int i=1;i<=10;i++){
sum +=i;
}
System.out.println("sum:"+sum);
}修饰符：public，static
返回值：一个方法执行之后，返回给调用处的结果。可能有，也可能没有。
有：在方法定义的时候，写清楚方法要返回的数据的类型。
没有：void，表示这个方法执行结束之后，没有返回值给调用处。
方法名：也是一种标识符。首字母小写，驼峰式命名。
()：方法的标志。括号里：参数列表
{}：方法体
参数列表：方法在运算过程中的未知数据，调用者调用方法时传递
return ：将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束
调用方法
step2：方法的调用(如果一个方法只有定义，那么方法中代码并没有被执行，只有被调用了才会执行方法中的代码)
通过方法的名字进行调用。
static的方法：静态方法
类名.方法名()，本类中类名可以省略。
非static的方法：非静态方法
创建该类的对象，通过对象调用方法。
类名 对象名 = new 类名();
对象.方法名();示例：
//调用一个方法,如果是类的方法，可以用类名直接调用
//倘若是在本类中，那么类名可以省略
//1,static方法的调用
getSum();//方法的调用
//2，非static方法的调用
/*
创建该类的对象，通过对象调用方法。
类名 对象名 = new 类名();
对象.方法名();
*/
Demo1 demo1 = new Demo1();
demo1.test();//非static方法的调用方法返回值
如果一个方法调用之后，需要返回给调用处结果，那么表示这个方法有返回值，在方法中需要使用return语句把结果返回给调用处。
//方法定义
public static 返回值类型 方法名(){
//.....
return 结果;
}
//方法的调用处
变量 = 方法名(); //变量 = 结果如果一个方法，没有返回值，那么写void即可。
return语句：
A：把方法中的返回值，返回给方法的调用处。
B：同时结束了这个方法的执行。
//求1-10的和，并且把方法中计算的结果，返回给调用处，放大10倍再打印
public static void getSum(){
int sum = 0;
for (int i = 1; i <=10; i++) {
sum += i;
}
System.out.println("1-10之间的和：" + sum);
//System.out.println("sum:"+sum);
//方法调用处拿到的值和return相关，和方法体无关，
return sum;
}注意点：
1.如果一个方法声明了有返回值(非void)，那么方法中一定要使用return语句返回结果。
2.定义方法的时候，声明的返回值类型，一定得和return后实际上返回的数值类型一致。
3.如果一个方法声明了有返回值，如果方法中有分支语句或者循环语句，那么要保证无论执行哪个分支，都要有return可以被执行到。
4.如果一个方法声明没有返回值(void)，那么方法中也可以使用return语句，用于强制结束方法的执行。
/**
* return要注意的点
*/
public class Demo2_return_2 {
public static int test1(){
// return "hehe";
byte i = 20;
double d = 2.3;
return (int)d;//byte----->int，发生了隐式类型转换
}
public static int test2(){
int age =10;
if(age>10){
return 0;
}else{
}
return age;
}
public static int test3(){
for(int i=1;i<=10;i++){
// if(i==1){
// return 0;//强制结束方法，，就是说方法后面的代码都不再执行了
// }
System.out.println(i);
}
System.out.println("hello,world");
return 0;
}
public static void test4(){
int age = 12;
if(age>0){
return;//用于结束方法的执行，即使在没有返回值的时候，也可以用return
}
System.out.println("wowowo,hello,");
}
public static void main(String[] args) {
test3();
}
}方法相互调用
public class Demo2_2 {
public static void test1(){
System.out.println("test1.......");
}
public static void test2(){
test1();
System.out.println("test2......");
}
public static void test3(){
test2();
System.out.println("test3.....");
// Demo2_2 demo22 = new Demo2_2();
// demo22.test4();
}
public void test4(){
Demo2_2.test3();//本类中就直接调用，如果是其他类就，用上类名
System.out.println("test4()......");
}
public static void main(String[] args) {
test3();
}
}方法参数
一个方法中，有些数据的数值不确定，我们定义为参数，由调用处调用方法的时候，传入具体的数据。
形式参数：形参
定义方式，声明的参数，用于接收调用处传来的数据。
实际参数：实参
调用方法的收，实际赋值给形参的数据。
/**
* 方法的参数
*/
public class Demo {
public static int getSum(int n){
int sum = 0;
for(int i=1;i<=n;i++){
sum +=i;
}
return sum;
}
public static int getSum2(int a,int b){
return a+b;
}
// public static int getSum2(){
// int sum = 0;
// for(int i=1;i<=20;i++){
//
// sum +=i;
//
// }
//
// return sum;
// }
public static void main(String[] args) {
//求1-10的和；
int result1 = getSum(10);
//求1-20的和；
//int result2 = getSum2();
int result2 = getSum(20);
//求1-100的和；
//求两个数的和
int result3 = getSum2(1,2);
}
}实参一定严格匹配形参：一一对应，包括顺序，个数，类型。
方法分类
有返回值：
有参数有返回值：public static 返回值类型 方法名(形参列表){}
无参数有返回值：public static 返回值类型 方法名(){}
无返回值：
有参数无返回值：public static void 方法名(形参列表){}
无参数无返回值：public static void 方法名(){}
方法重载
概念：一个方法的多种形式。
同一个类中
方法名相同
参数列表必须不同(顺序，个数，类型)
与static，返回值，其他的修饰符。。。这些无关
示例：
public class Demo_overload {
public static void test1(){}
public static void test2(){}
public void test3(){}
public static int getSum(int a,int b){
return a+b;
}
public static double getSum(double a,double b){
return a+b;
}
public void getSum(int c){
}
public static void main(String[] args) {
int result = getSum(1,2);
double result2 = getSum(2.3,4);
}
}递归
方法中调用方法本身，就叫做递归方法。
递归方法一定有出口的，逐层的向出口靠近。
示例：
public class Demo_recursion {
// 无返回值的递归方法
public static void test1(int n){
System.out.println("test1()......");
if(n==1){
return;//方法的出口
}
test1(n-1);//递归，自己调用自己,递归一定要有出口
//test1(4)
//test1(3)
//test1(2)
//test1(1)
}
//有返回值的递归方法
public static int getSum(int n){
// int sum = 0;
// for (int i = 0; i <= 5; i++) {
// sum +=i;
// }
// return sum;
if(n==1){
return 1;
}
return getSum(n-1)+n;
}
public static void main(String[] args) {
test1(5);
//用递归的方式来求1-5之间的和
// getSum(5)---->getSum(4)+5;
// getSum(4)---->getSum(3)+4;
//
// getSum(3)---->getSum(2)+3;
// getSum(2)---->getSum(1)+2;
// getSum(1)----->return 1;
System.out.println("------------------------");
int sum = getSum(5);
System.out.println("sum:"+sum);
}
}