Java笔记3-方法基本概念，方法覆盖，方法重载

一、方法

1. 方法是可以重复调用的代码块，用来实现各种功能,在c语言称为函数
2. 方法的定义格式：
[方法修饰列表] 返回值类型 方法名 （方法参数列表）{
方法体
}

• 方法修饰列表：
  是可选项，包括public，protected，private，abstract，static，final，synchronized，其中public，protected，private不能同时存在

问：方法的修饰列表中有static关键字的话，怎么调用这个方法？
答：类名.方法名（实际参数列表）;表示调用某个类的某个方法，传递这样的实参。
（没有static无法直接调用，要new）

• 返回值类型：
  如果不存在返回值就用void关键字，如果存在返回值就用基本类型和引用类型。如果存在返回值，使用return语句。return语句后面不能再写执行语句，因为不可能会执行到，编译会发生错误。

注意：返回值类型是void的时候，在方法体中不能编写"return 值;"这样的语句，但可以编写"return;"这样的语句。只要带有return关键字的语句执行，return语句所在的方法结束。

• 方法名：
  任意合法的标识符，最好是动词，见名知意，首字母要求小写，后面每个单词首字母大写，遵循小驼峰命名法。

补充：类名 接口名各个首字母大写，方法名和变量名首字母小写

• 方法参数列表（简称形参，形参是局部变量）：
  参数列表可以多个，如method（int a,int b),采用逗号分隔。
  3. 方法的基础语法：

public class Method
{
       public static void main(String[] args){
           Method.sumInt(10,20);
        }
        //单独定义一个方法，计算两个数的和
        public static void sumInt(int a,int b){
             //方法定义在类体中，在一个类中可以定义多个方法，方法编写位置没有先后顺序，方法体中不能再定义方法
             int c=a+b;
             System.out.println(a+"+"+b+"="+c);
        }
}

补充1：




就是你最开始写代码的时候就把方法写在源文件里了，你编译出的.class文件方法就在里面，但在运行阶段jvm直接把方法放在了一个叫方法区的内存里，什么时候用就从内存的方法区里找这个方法；或者说因为方法是在编写过程就已经写出了，jvm运行的时候第一时间也是把所有你编写方法给放在内存的方法区当中。
因为不使用这个方法的话，就不去内存的方法区里找这个方法也不执行，所以方法只编写不执行的话不占用内存空间。（就是代码存在方法内存中，可以被栈内存反复的使用），方法区内存里存的是方法，如果要执行方法的话就需要栈内存分配给它才能运行。（就像是，把图纸放在了方法区里面，实际按照这份图纸打造产品的时候，需要在栈区给这份纸一个操作空间）。
方法区可以类比成C语言的静态区，程序完全执行完，方法区上的代码才会销毁，把空间还给系统

补充2：递归（递归必须有结束条件，没有结束条件一定会发生栈内存溢出错误）

public class Recursion
{
     //主方法
     public static void main(String[] args){
        System.out.println("main begin");
        //调用dosome方法
        doSome();
         
         System.out.println("main over");

         //以下的代码片段虽然只有一份，但是可以被重复的调用，并且只要调用doSome方法就会在栈内存中新分配一块所属的内存空间。
         public static void doSome(){
            System.out.println("doSome begin");
            doSome();//这行代码不结束，下一行程序是不会执行的
            System.out.println("doSome over");
         }
}

4. 方法的重载机制overload

1. 什么时候考虑方法重载？
   当在一个类中，功能相似的时候，尽可能让方法名相同。
2. 满足方法重载的条件：
   在同一个类当中，方法名相同，参数列表不同（数量不同或顺序不同或类型不同）
3. 方法重载和方法名+参数列表有关系，与返回值类型以及修饰符列表无关

public class overload
{
    public static void main(String[] args){
         m1();
         m1(10);

         m2(1,2.0);
         m2(2.0,1);
         
         m3(10);
         m3(3.0);
    }

    //以下两个方法构成重载
    public static void m1(){}
    public static void m1(int a){}
    //以下两个方法构成重载
    public static void m1(int a,double b){}
    public static void m1(double a,int b){}
    //以下两个方法构成重载
    public static void m1(int x){}
    public static void m1(double x){}
}  

4. 方法重载的具体应用：

public class overload
{
    public static void main(String[] args){
         //比System.out.println简洁
         U.p(10);
         U.p(false);
         U.p("abc");
         U.p(3.0);
    }

}
//自定义类
class U
{
    public static void p(byte b){
         System.out.println(b);
    }
    public static void p(short b){
         System.out.println(b);
    }
    public static void p(int b){
         System.out.println(b);
    }
    public static void p(long b){
         System.out.println(b);
    }
    public static void p(float b){
         System.out.println(b);
    }
    public static void p(double b){
         System.out.println(b);
    }
    public static void p(boolean b){
         System.out.println(b);
    }
    public static void p(char b){
         System.out.println(b);
    }
    public static void p(String b){
         System.out.println(b);
    }
    

}

运行结果：

5.方法覆盖
1）什么时候我们会考虑使用“方法覆盖"呢?
子类继承父类之后，当继承过来的方法无法满足当前子类的业务需求时，子类有权利对这个方法进行重新编写，有必要进行"方法的覆盖"。

2）方法覆盖又叫做:方法重写(重新编写)，英语单词叫做: Override、Overwrite，都可以比较常见的:方法覆盖、方法重写、override

3）重要结论:当子类对父类继承过来的方法进行“方法覆盖”之后，子类对象调用该方法的时候，一定执行覆盖之后的方法。

4）当我们代码怎么编写的时候，在代码级别上构成了方法覆盖呢?

• 条件一：两个类必须要有继承关系。
• 条件二：重写之后的方法和之前的方法具有:相同的返回值类型、相同的方法名、相同的形式参数列表。
• 条件三：访问权限不能更低，可以更高
• 条件四：重写之后的方法不能比之前的方法抛出更多的异常，可以更少。 (这个是后面学的）

5）注意事项(这几个注意事项，当学习了后面的多态语法之后能更加明白)：

• 注意1：方法覆盖只是针对于方法，和属性无关。
• 注意2：私有方法无法覆盖
• 注意3：构造方法不能被继承，所以构造方法也不能被覆盖。
• 注意4：方法覆盖只是针对于实例方法，静态方法覆盖没有意义。

6）Code：

public class OverrideTest01 {
    public static void main(String[] args) {
        Animal animal=new Animal();
        animal.eat();
        Rabbit rabbit=new Rabbit();
        rabbit.eat();
    }
}
class Animal{
    public void eat(){
        System.out.println("动物在觅食");
    }
    public void sleep(){
        System.out.println("动物在休眠");
    }
}
class Rabbit extends Animal{
    // 对eat方法进行方法覆盖，方法重写，override
    // 可以将父类中的方法原封不动的复制过来再修改。(不用手动编写)
    // 方法覆盖，顾名思义，就是将承过来的那个方法给覆盖掉了。同时继承过来的方法没了
    @Override
    public void eat() {
        System.out.println("朏朏在觅食");
    }
    
    //protected表示受保护的。没有public开放;
    //错误:正在尝试分配更低的访问权限;以前为public
//    protected void eat() {
//        System.out.println("朏朏在觅食");
//    }

    @Override
    public void sleep() {
        System.out.println("朏朏在休眠");
    }
}

运行结果：