Java方法是语句的集合，它们在一起执行一个功能

·方法是解决一类问题的步骤的有序组合

·方法包含于类或对象中

·方法在程序中被创建，在其他地方被引用

Java中的类：可以看成是创建Java对象的模板

举例：

public class Dog{
 
String breed;

int age;

String color;

void barking(){

 }

 
void hungry(){
 }

void sleeping(){
 }

}

Dog是类

barking()，hungry()，sleeping() 叫方法

限制条件：在主类中定义，并且由主方法直接调用的方法形式。

方法就是一段可以被重复调用的方法块。在Java中要想进行方法的定义，则可以使用如下的语法完成。

public static 返回类型 方法名称([参数类型 变量, ......]) {

方法体代码;

[return [返回值];]

}

什么是方法

  在刚开始学习Java语言时，还没有从函数的角度脱离出来，会经常不停的将方法说为函数。那方法 和函数 有什么区别呢？通过查找资料和自我理解，有如下的思考，如果有不对的，请大家回复改正。
  函数： 是一段可以重复调用的代码，通过名字来进行调用。它能将数据传递进去进行一些处理，然后返回数据（或者没有返回值），函数和对象无关。
  方法： 也是一段可以重复调用的代码，也通过名字来进行调用的，但是它跟一个对象相关联。方法可以操作类内部由private封装的数据。
  根据以上解释我们可以将方法看作时函数也无妨，它决定了一个对象能够接收什么样的消息。

方法的定义

修饰符 返回值类型 方法名([参数类型 参数名1, 参数类型 参数名2, ...]){
 执行语句 ...
 [return 返回值;]}// []中的数据可以没有123456

我们可以看到方法的基本组成包括：名称、参数、返回值和方法体。

• 修饰符：方法的修饰符较多，有对访问权限进行限定的，有静态修饰符static，还有最终修饰符final等。

• 返回值类型：用于限定方法返回值的数据类型。

• 参数类型：用于限定调用方法时参数参数的类型。

• 参数名：是一个变量，用于接收调用方法时传入的数据。

• return关键字：用于结束方法以及返回方法指定类型的值。
  当方法以void关键字声明，那么此方法没有返回值；但可以使用return来结束调用。
  举例： 定义一个在主方法调用的方法

public static 方法返回值 方法名称([参数类型 参数名, ...]){
 方法体代码;
 ...
 [return 返回值;]}12345

举例： 测试void关键字声明的方法，可以使用return结束方法调用

public class Test {
    public static void main(String[] args){
    // 屏幕上只打印出15和0
        print_age(15);
        print_age(30);
        print_age(0);
    }
    public static void print_age(int age){
        if(age > 18){
            return; //弱质性此鱼具，则此语句后面的代码不再执行，方法调用结束
        } else{
            System.out.println(age);
        }
    }}12345678910111213141

我们可以看到方法的基本组成包括：名称、参数、返回值和方法体。

• 修饰符：方法的修饰符较多，有对访问权限进行限定的，有静态修饰符static，还有最终修饰符final等。

• 返回值类型：用于限定方法返回值的数据类型。

• 参数类型：用于限定调用方法时参数参数的类型。

• 参数名：是一个变量，用于接收调用方法时传入的数据。

• return关键字：用于结束方法以及返回方法指定类型的值。

方法的最大好处是可以进行重复调用，但是至于说那些操作要形成方法，这些都要根据你的实际项目经验而自我总结的。
##方法的基本定义
限制条件：在主类中定义，并且由主方法直接调用的方法形式。
方法就是一段可以被重复调用的方法块。在Java中要想进行方法的定义，则可以使用如下的语法完成。

public static 返回类型 方法名称([参数类型 变量, ......]) {
 方法体代码;
 [return [返回值];]
}1234

在定义方法的时候对于方法的返回值有一下的两类：

• void：没有返回值；

• 数据类型（基本类型，引用类型）。

范例： 定义一个没有返回值，没有参数的方法

public class TestDemo {
 public static void main(String[] args) {
  print(); //主方法里面直接调用方法
 }
 public static void print() {
  System.out.println("Hello World!"); //定义方法
 }}12345678

范例： 定义一个有参数无返回值的方法

public class TestDemo {
 public static void main(String[] args) {
  print("Hello"); //主方法里面直接调用方法
  print(" world");
  print("!");
 }
 public static void print(String msg) { //定义方法
  System.out.print(msg); 
 }}12345678910

范例： 有参数有返回值的方法

public class TestDemo {
 public static void main(String[] args) {
  int result = add(10, 20);
  System.out.println(result);
  //既然方法有返回值，那么这些返回值也可以直接输出
  System.out.println(add(100, 200));
 }
 public static int add(int x, int y) { //定义方法
  return x + y;
 }}1234567891011

但是在定义方法的时候有一点特别要注意，如果某一个方法上使用了void定义，那么该方法可以直接用return来结束调用。一般而言，这种return的处理往往需要结合if判断来实现。

public class TestDemo {
 public static void main(String[] args) {
  print(10);
  print(20);
 }
 public static void print(int x) { //定义方法
  if(x == 20)  //表示的是方法结束的判断
   return;  //此语句之后的代码不再执行
  System.out.println("x = " + x);
 }}1234567891011

对于第一次接触方法的人来讲，先将语法记住，至于怎么用，需要时间来消化。
##方法重载（重点）
方法重载指的是：方法名称相同，参数的类型和个数不同。

范例： 实现方法重载

public class TestDemo {
 public static void main(String[] args) {
  //此时将根据参数的类型和个数的不同执行不同的方法体
  System.out.println(add(10, 20));
  System.out.println(add(30, 40, 50));
  System.out.println(add(1.1, 2.1));
 }
 public static int add(int x, int y) {
  return x + y;
 }
 //此时方法名称相同，参数的个数不同
 public static int add(int x, int y, int z) {
  return x + y + z;
 }
 public static double add(double x, double y) {
  return x + y;
 }}123456789101112131415161718

在进行方法重载的时候有一个重要的原则：要求方法的返回值类型一定要相同。

范例： 观察如下程序

public class TestDemo {
 public static void main(String[] args) {
  //此时将根据参数的类型和个数的不同执行不同的方法体
  System.out.println("hello");   //输出字符串
  System.out.println(1);   //输出整形
  System.out.println(1.1);  //输出浮点型
  System.out.println('A');  //输出字符
  System.out.println(true);  //输出布尔
 }}12345678910

证明：System.out.println()是一个被重载的方法

方法递归调用

方法的递归调用指的是一个方法自己调用自己的形式。一般如果要进行方法的递归操作往往都具备有以下的特点：

• 方法必须有一个递归的结束条件；

• 方法在每次递归处理的时候一定要做出一些变更；

范例： 实现1 ~ 100的累加操作

public class TestDemo {
 public static void main(String[] args) {
  System.out.println(sum(100));
 }
 public static int sum(int num) {
  if(num == 1)
   return  1;
  return num + sum(--num);
 }}12345678910

1. [main()调用] 第1次执行sum()方法 return 100 + sum(99)；

2. [sum()递归] 第2次执行sum()方法 return 99 + sum(98)；

3. [sum()递归] 第3次执行sum()方法 return 98 + sum(97)；

4. …

5. [sum()递归] 倒数第2次执行sum()方法 return 2 + sum(1)；

6. [sum()递归] 倒数第1次执行sum()方法 return 1；

范例： 实现60!，这个结果太大，应该使用double。

public class TestDemo {
 public static void main(String[] args) {
  System.out.println(mul(60));
 }
 public static double mul(int num) {
  if(num == 1)
   return  1;
  return num * mul(--num);
 }}12345678910

通过代码可以发现使用while循环的操作其实大部分都可以更换为递归，之所以使用递归主要是一个方法可以执行的操作很多，而且结构要好。

在类（class）中定义：

eg: class test

{

public int a;

public int test(int b)

{

a=b;

}

public int get_a() //方法1

{

return a;

}

public void print() //方法2

{

System.out.println(this.get_a());

}

public static void main(String [] args) //主函数

{

test aa=new test(3); //初始化 aa

aa.print(); //调用 print方法

}

}

现实中的方法是可以解决某种问题,

java中的方法是具有特定功能的代码段,也就是说,把一些常用的代码起个名字用大括号包起来,用的时候直接用这个名字来代替这段代码,变得简单外,还提高了代码的复用性