【无标题】

 * 方法： 解决问题的一种方案，他是有很多条java语句组成的
 *      方法的一些特点：
 *          1 方法执行的时候，可能需要原料。           原料就是  参数
 *          2 方法执行完了以后，可能会给我们一个结果。   结果就是返回值
 *          3 声明方法，其实就是在定义规则
 *
 *      方法的格式：
       修饰符 返回值类型 方法名(参数类型 参数名){
          ...
          方法体
          ...
          return 返回值;
      }

     修饰符：    public
     返回值类型:  本质就是数据类型
     方法名：     方法的名字（命名规范和变量的一样）   小驼峰
     参数类型：   本质就是数据类型
     参数名：    本质就是变量名
     方法体：    就是一些java语句
      return:  关键字，结束方法，一般用在返回值前面
     返回值：    方法执行完以后，得到的结果。

      注意事项：
        1 返回值类型：跟返回值有关系；如果没有返回值，那么返回值类型就是void,然后也不用写return
        2 参数类型：  跟参数有关系
        3 定义方法，其实就是在定义规则。这个在方法调用的时候很关键。

代码示例：

   public String  say(String name){
        System.out.println("hello "+name);
        return name;
    }

    public int add(int a,int b){
        int c = a + b;
        return c;
    }

    public void hello(){
        System.out.println("hello");
    }
}

方法有4种
* 1. 无参无返回值
* 2. 无参有返回值
* 3. 有参无返回值
* 4. 有参有返回值
*
* 方法的调用
* 1 方法想要执行，必须要调用
* 2 方法是谁执行的？方法是对象执行的
* 3 对象是哪里来的？对象是new出来的， new+方法所在的类名（）； new + 构造方法（）
* 4 对象调用方法： 对象.方法名（参数）
* 5 方执行的本质就是： 方法里的代码跑了一边。方法每被调用一次， 方法里的代码就执行一次。
*
*/

// 1. 无参无返回值
public void say(){
    System.out.println("hello");
}

// 2. 无参有返回值，如果方法有返回值，那么这个方法调用的时候，就会有一个结果。这个结果可以赋值给一个变量
public String grilFriend(){
    return "小马哥";
}

// 3. 有参无返回值
public void showFriend(String name){
    System.out.println("老马的对象是："+name);
}

//4 有参有返回值
public int add(int a,int b){
    int c = a + b;
    return c;
}

代码示例：

public Demo02(){

    }

    public static void main(String[] args) {
        Demo02 demo02 = new Demo02();   // demo02就是对象，本质还是一个变量
        demo02.say();
        demo02.say();

        String friend = demo02.grilFriend();
        System.out.println(friend);

        demo02.showFriend("小马哥");

        int add = demo02.add(4, 5);
        System.out.println(add);
    }

}

方法调用的细节
方法调用的时候，到底该怎么使用参数
定义方法，其实就是在定义规则。这个在方法调用的时候很关键。
我们在定义方法的时候，定义好了参数的数据类型，那么调用的时候，必须要和定义的一样。

 public String getFriend(int num,String name){
        System.out.println(name + "有" + num + "个女朋友");
        return "泰库拉";
    }
    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
        String s = demo03.getFriend(3, "小马哥");
        System.out.println(s);
    }
}

*如果基本数据类型作为方法的参数：其实就是将基本数据类型的值，拷贝了一份副本给了方法，方法中对这个副本的修改，不会影响到原来的值
* 如果引用数据类型作为方法的参数：其实就是将引用数据类型的地址，拷贝了一份副本给了方法，方法中对这个副本的修改，会影响到原来的值
*
/
//参数是基本数据类型
public void pl1(int score) {
score += 1;
}
//参数是引用数据类型
public void pl2(Student student) {
student.score += 1;
}

public static void main(String[] args) {
        int scort = 1;
        Demo04 demo04 = new Demo04();
        demo04.pl1(scort);
        System.out.println(scort);

        Student student = new Student();
        student.score = 1;
        demo04.pl2(student);
        System.out.println(student.score);

    }
}

方法重载：
* 1. 同一个类中
* 2. 方法名相同
* 3. 参数列表不同（参数个数不一样，参数的类型不一样）
* 4. 与修饰符和返回值无关
*
* 注意事项： 构造方法也可以重载

// An highlighted block
var foo = 'bar';

public void say(){
     System.out.println("hello");
 }

 public String say(int a){
     return "hello";
 }

 public String say(String name){
     return "hello "+name;
 }
}

*成员变量：不在方法里的变量就是成员变量
* 局部变量：在方法里面的变量就是局部变量（包含参数上的变量）
*
* 成员变量和局部变量的区别：
* 1 成员变量定义在类中，整个类中都可以访问
* 2 局部变量定义在方法中，只能在方法中使用
* 3 成员变量可以不给初始值，因为有默认值，局部变量必须有初始值否则报错（除了参数）
* 4 如果成员变量和局部变量名字一样：成员变量前面可以加this，this代表当前对象
* 5 我们在方法里面使用变量的时候，如果方法里面有，就用自己的，如果没有就用成员变量的，如果成员变量没有，就报错
/

public int a;   // 成员变量

    public int add(int a,int b){    // a,b都是局部变量
        int d =100;   // d是局部变量
        int c = a + b;  // c是局部变量
        return d;
    }
    public void say(){
    }
    public static void main(String[] args) {
        Demo07 demo07 = new Demo07();
        demo07.say();
    }
}

构造方法：
* 1. 创建对象 new + 构造方法
* 2 初始化成员变量(给成员变量赋值)
// 姓名
public String name;
// 分数
public int score;

**//无参构造方法
public Student(){
}
//有参构造方法
public Student(String name, int score) {
    this.name = name;
    this.score = score;
}**

}