java学习笔记（6）方法、内存、重载

方法：

/*
    以下程序不使用"方法"，分析程序存在哪些缺点？
        *以下代码都是计算两个int类型数据的和，相同的代码写了两遍（只不过每次参与求和的数据不同）。
        代码没有得到重复使用。
        *java语言当中应该有这样的一种机制：
            -某个功能代码只需要写一遍。
            -要使用这个功能，只需要给这个功能传递具体的数据。
            -这个功能完成之后返回一个最终结果。
            这样代码就可以重复利用了，提高代码复用性。【这就是"方法"】
        *使用这个方法，我们称为：调用/invoke

 */
 public class Method01{
     public static void main(String[] args){
        // 需求1：请编写程序计算10和20的和，并将结果输出【功能是 计算两个int类型数据的和】
        int a = 10;
        int b = 20;
        int c = a + b;
        System.out.println(a + " + " + b +" = " + c);

        // 需求2：请编写程序计算666和888的和，并将结果输出【功能是 计算两个int类型数据的和】
        int x = 666;
        int y = 888;
        int z = a + b;
        System.out.println(x + " + " + y +" = " + z);
        // 以上的两个需求其实就是一个需求，需求是：计算两个int类型的和，功能相同
        // 只不过每次参与计算的具体数据不同。

     }
 }

/*
    以下直接使用方法这种机制【这个例子不讲方法的语法】，分析程序的优点？
        *代码得到了重复使用
    *方法的本质是什么？
        -方法就是一段代码片段，并且这段代码片段可以完成某个特定的功能，并且可以被重复的使用。
        -方法对应的英语单词是：Method
        -方法在c语言中叫作函数/Function，在java语言中叫方法

    *方法定义在类体当中，方法体之外。
    *在一个类体重可以定义多个方法，方法编写的位置没有先后顺序，可以随意。
    *方法体当中不能再定义方法
    *方法体有java语句构成，方法体当中的代码遵守自上而下的顺序执行。


 */
 public class Method01{
    //  类体
     public static void main(String[] args){
        //  方法体
        

        // 下面是调用方法计算int的和
        sumint(30,40);//30 + 40 = 70
        Method01.sumint(50,60);//50 + 60 = 110
     }
    //  方法
    // 单独定义一个方法
    // 该方法完成计算两个int类型的和，并且将结果输出
    public static void sumint(int a,int b){
        // 方法体
        int c = a + b;
        System.out.println(a + " + " + b + " = " + c);
    }
 }

 方法定义规则：

/*
    关于java语言中的方法：
        1、方法怎么定义？语法结构：
            [修饰符列表] 返回值类型 方法名(形式参数列表){
                方法体;
            }
        2、对以上的语法结构进行解释说明：
            2.1、关于修饰符列表
                *可选项，不是必须的
                *目前可统一写成：public static 【以后再说】
                *方法的修饰符列表当中有static关键字的话，怎么调用这个方法？
                    -类名.方法名(实际参数列表);
            2.2、返回值类型
                *什么是返回值？
                    -一个方法是可以完成某个特定功能的，这个功能结束之后大多数都是需要
                        返回最终的执行结果，执行结果可能是一个具体存在的数据。只要是数据一定
                        会有类型，而这个存在的数据就是返回值。

                *返回值类型是什么？
                    -返回值是一个具体存在的数据，数据都是由类型的，此处需要指定的是
                    返回值的具体类型
                
                *返回值类型都可以指定哪些类型呢？
                    -java中任意一种类型都可以，包括基本数据类型和所有的引用数据类型。
                
                *也可能这个方法执行之后不返回任何数据，java中规定，当一个方法执行结束之后
                不返回任何数据，返回值类型位置必须编写：void关键字
                
                *返回值类型可以是什么？
                    byte、short、int、long、float、double、boolean、char、String、void......
                
                *返回值类型若不是void，表示这个方法执行结束之后必须返回一个具体的数值。
                当方法执行结束的时候没有返回任意数据的话编译器报错。
                
                *怎么返回值呢？
                    return 值; 并且要求"值"的数据类型，必须和"方法的返回值类型一致"。不然编译器报错。
                
                *当返回值类型是void的时候，在方法体当中不能编写"return 值;"这样的语句
                但是可以编写"return;"这样的语句
                
                *只要带有return关键字的语句执行，return语句所在的方法结束。【不是jvm结束，是所在的方法结束】
            2.3、方法名
                *只要是合法的标志符就行
                *方法名最好见名知意
                *方法名最好是动词
                *方法名要求首字母小写，后面的单子首字母大写，驼峰命名方式
            2.4、形式参数列表：简称 形参
                *形参是局部变量
                *形参的个数可以是：0-N个
                *多个形参之间用"逗号"隔开
                *实参和形参列表必须满足:
                    -数量相同
                    -类型对应相同
                *形参中起决定性作用的是 形参的类型，形参的名字只是一个标识符，形参的名字
                    就是局部变量的名字。
                    例如：
                        方法定义
                        public static int sum(int a,int b){//(int a,int b)是形参列表

                        }
                        方法调用：
                        sum("abc","def");//编译器会报错，
                        sum(10,20);//编译通过  (10,20)是实参列表
            2.5、方法体
                方法体必须有大括号括起来，方法体当中的代码有顺序，由上而下执行。
                并且方法体由java语句构成，java语句有";"结尾。
        3、方法怎么调用？
            方法只定义时不会执行的，只有调用的时候才执行
            语法规则：【这里只说方法的修饰符当中有static关键字的方法】
                类名.方法名(是参列表);这是一条java语句，表示调用某个类的某个方法，传递这样的参数





 */
 public class Method01{//类相当于汽车工厂
    //  类体
     public static void main(String[] args){
        //  方法体
     }
    //  定义一个方法
    // 一个车间

    public static int sumint(int a,int b){
        // 方法体
        int c = a + b;
        System.out.println(a + " + " + b + " = " + c);
    }
 }

/*
*/
// public表示公开的
// class表示定义类的关键字
// Method01是一个类名
 public class Method01{//表示定义一个公开的类，起名Method01，由于是公开的类，所以源文件名必须是Method01
    //  类体
    // 类体中不能直接编写java代码，除声明变量之外
    // 方法出现在类体当中

    // 方法
    // public表示公开的
    // static表示静态的
    // void表示方法执行结束之后不返回任何数据
    // main是方法名：主方法
    // (String[] args)：形式参数列表，其中String是一种引用数据类型，args是一个局部变量的变量名
    // 所以以下只有args这个局部变量的变量名是可以随意写的
    // 主方法就需要这样固定编写，这是程序的入口。【sun规定的，必须这样写才行】
     public static void main(String[] args){
        //  方法体
        // 这里的程序是一定会执行的
        // main方法是JVM负责调用的，是一个入口的位置
        // 从这里来时起点开始执行程序
        // 既然是这样，我们就可以在这里编写java语句来调用其它方法
        // 调用Method01的sum方法  （只有static修饰符的方法可以这样调用，类名也可以省略
        Method01.sum(10,20);
        // 也可以这样
        sum(20,40);//只有static修饰符的方法才可以这样调用

     }
    //  自定义方法 ，不是程序入口
    // 方法作用：计算两个int类型数据的和，不要求返回结果，但是要求将结果直接输出到控制台
    // 修饰符列表：public static
    // 返回值类型：void
    // 方法名：sum
    // 形式参数列表：(int x,int y)
    // 方法体：主要任务是，求和之后，输出计算结果
    public static void sum(int i,int j){
        System.out.println(i + " + " + j + " = " + (i + j));
    }


 }

/*
方法的难点：
   public static ???(返回值)  方法名(返回什么参数合适){
      //如何编写代码
   }
   方法的调用不一定在main方法当中，
   只要程序可以执行到的位置，都可以执行其他方法。
 */
public class Method01{
   public static void sum(int a,int b){
      System.out.println(a +" + " + b + " = " + (a + b));
      // 调用dosome方法
      Method01.doSome();
   }
   public static void doSome(){
      System.out.println("do some");
   }
   // 主方法
   public static void main(String[] args){
      // 调用 sum方法
      Method01.sum(1,2);
      System.out.println("hello world");
   }
}
   

执行javac -encoding UTF-8 Method01.java(编译)

java Method01(执行)

/*
方法调用
   1、方法的修饰符列表当中有static关键字，完整的调用方法是：类名.方法(是参列表);
   2、但是有的时候"类名."可以省略。什么情况下可以省略呢？
      m1(){
         m2();
      }
      //上述调用省略"类名."，只有在m1和m2方法在同一个类体当中时，可以省略
   3、一个java源文件中建议只定义一个class，比较清晰，这里只是举例方便才在java源文件当中写多个class

*/
public class Method01{
   public static void main(String[] args){
      // 调用方法
      Method01.m();
      // 对于方法的修饰符列表当中有static关键字的，"类名."可以省略不写吗？
      m();//执行成功  "类名."可以省略不写
      
      // 调用其它类，【不是本类中】的方法
      A.doOther();//调用成功
      // 省略"类名.",试试 （此时，是在当前类中找doOther方法，在当前类中不存在。
      // 编译错误： 找不到符号
      // doOther();

   }
   public static void m(){
      System.out.println("m Method execute!");
      // 调用当前类中的方法，可以省略"类名."
      m2();
      // 完整的方式调用m2方法，在其它类中也可以这样调用
      Method01.m2();
      // 不想调用本类中的m2方法，想调用其它类中的m2方法
      // 类名.方法();
      // 以后只要调用方法，都不省略"类名."，规范上比较好，如果知道这个语法，可以少写几句代码
      A.m2();
   }
   public static void m2(){
      System.out.println("m2 execute!");
   }
}

class A{
   public static void doOther(){
      System.out.println("'A's doOther method invoke");
   }
   public static void m2(){
      System.out.println("'A's m2 execute!");
   }
}

/*
分析程序的输出结果:
main begin!
m1 begin!
m2 begin!
m2 over!
m1 over!
main over!

对于当前的程序来说，main方法最先调用，也是最后一个结束。
最后调用的方法是m2，该方法最先结束
   方法中的代码是自上而下执行的即可，上一行代码未执行结束，下一行代码不会执行
*/
public class Method01{
   public static void main(String[] args){
      System.out.println("main begin!");
      m1();
      System.out.println("main over!");

   }
   public static void m1(){
      System.out.println("m1 begin!");
      m2();
      System.out.println("m1 over!");
   }
   public static void m2(){
      System.out.println("m2 begin!");
      
      System.out.println("m2 over!");
   }
}

/*
方法的返回值类型不是void的时候
   1、返回值类型不是void的时候，要求方法必须保证百分百的执行"return 值;"这样的语句来完成值的返回。
      没有这个语句，编译器会报错。
   2、一个方法有返回值的时候，当我们调用这个方法的时候，方法返回一个值，
      对于调用者来说，这个返回值可以选择接受，也可以选择不接受。
      但是大部分情况下，我们是选择接收的。
*/
public class Method01{
   public static void main(String[] args){
      // 方法调用
      divide(10,3);//这里没有接收这个方法的返回数据
      // 这里接收一下方法的返回值
      // 采用变量接收
      // 变量的数据类型需要和方法的返回值类型相同，或者可以自动类转换
      // boolean b = divide(10,3);//编译报错  不兼容的类型: int无法转换为boolean
      // 赋值运算符的右边线执行，将执行结果赋值给左边的变量
      int i = divide(10,3);
      System.out.println(i);//3

      long x = divide(10,3);//小类型想大类型存在自动类型转换
      System.out.println(x);//3
   }
   /*
   需求：
      请定义并实现一个方法，该方法可以计算两个int类型的商；
      要就将最终的调用结果返回给调用者。
   */
   // 编译报错：缺少返回语句
   // public static int divide(int a,int b){

   // }
   // 编译错误：缺少返回值
   // public static int divide(int a,int b){
   //    return;
   // }
   // 不兼容的类型: boolean无法转换为int
   // public static int divide(int a,int b){
   //    return true;
   // }
   public static int divide(int a,int b){
      return a / b;
   }
}

/*
深入return语句
   *带有return关键字的java语句只要执行，所在的方法执行结束。

   *在"同一个作用域"当中，return语句下面不能编写任何代码，因为这些代码永远都执行不到。
      所以编译报错。
   
*/
public class Method01{
   public static void main(String[] args){
      int returnValue = m();
      System.out.println(returnValue);//1
      System.out.println(m());//1
   }
   // public static int m(){
   //    int a = 10;
   //    if(a>3){//截止到这，m方法无法保证，这个方法百分之百的有返回语句，所以会编译报错
   //       return 1;
   //    }else{//这样 加上else语句后，就能够百分百保证这个方法有返回语句，殡仪就会通过
   //       return 0;
   //    }
   // }
   // 将m方法改进一下，去掉else语句
   // public static int m(){
   //    int a = 10;
   //    if(a>3){
   //       return 1;
   //       // return 语句后面加上语句后 无法执行，因为return后的语句执行不到，会编译报错
   //       // System.out.println("hello");
   //    }
   //    return 0;
   //    // 在同一作用域下，return后面不能有语句，因为执行不到，会导致编译错误
   //    // System.out.println("hello");
   // }

   // 将m方法再次改进
   public static int m(){
      int a = 10;
      return a > 3 ? 1 : 0;
   }
   
}

/*
在返回值类型为void的方法中使用return语句。
"return;"可以出现在返回值为void方法当中，主要用来终止方法的执行。


   
*/
public class Method01{
   public static void main(String[] args){
      m();
      s();
   }
   public static void m(){
      // return 0;//不兼容的类型: 意外的返回值
      return;
   }
   public static void s(){
      for(int i =0;i<10;i++){
         if(i==5){
            // return;//return不是终止的for循环，而是终止整个方法
            break;//终止for循环
         }
         System.out.println("i--->"+i);
      }
   }
   
}

 内存：

栈的介绍：

 队列是先进先出

 

/*
方法在执行过程当中，在JVM中的内存是如何分配的？内存是如何变化的？
   1、方法只定义，不调用，是不会执行的，并且也不会给该方法分配运行所属的内存空间。
      只有在调用这个方法的时候，才会动态的给这个方法分配所属的内存空间。

   2、在jvm内存划分上有这样三块主要的内存空间（当然，除了这三块之外还有其它的内存空间）
      *方法区内存
      *堆内存
      *栈内存
   3、关于栈的数据结构：
      *栈 stack ，是一种数据结构
      *数据结构反应的是数据的存储形态。
      *数据结构是独立的学科，不属于任何编程语言的范畴，只不过在大多数编程语言当中要使用数据结构。
      *作为程序员需要提前精通：数据结构  + 算法【计算机专业必修的一门课程】
      *java程序员在不精通数据结构和算法的前提下，也可能进行java开发，因为java有一套庞大的类库支撑。
         说白了就是别人写好了，拿过来直接用，【javase当中集合章节使用了大量的数据结构】
      *常见的数据结构：
         - 数组
         - 队列
         - 栈
         - 链表
         - 二叉树
         - 哈希表/散列表
         ......
   4、方法执行的时候代码片段存在哪里？方法执行的时候执行过程的内存在哪里分配？
      *方法代码片段属于.class字节码文件的一部分，字节码文件在类加载的时候，
      将其放到了方法区当中，所以JVM中的三块只要内存空间中，方法区内存最先有。
      存放了代码片段。
      *代码片段虽然再内存区当中只有一份，但是可以被重复调用。
         没一次调用这个方法的时候，需要给该方法分配独立的活动场所，
         在栈内存中分配。
   5、方法调用的时候，会给该方法分配独立的内存空间，在栈中分配，此时发生压栈动作，
      方法执行结束后，给该方法分配的内存空间全部释放，此时发生图弹栈动作。
         *压栈：给方法分配内存空间push
         *弹栈：释放该方法的内存空间pop
   6、局部变量在栈中存储，局部变量运行阶段内存在栈中分配。
      


*/
public class Method01{
   public static void main(String[] args){

   }
}

 继续说内存：

 上面是下面代码执行时，方法分配内存空间的情况

/*
重点：方法调用的时候，在参数传递的时候，实际上传递的是变量汇总保存的那个"值"传过去了。

*/
public class Method01{
   public static void main(String[] args){
      int a = 10;
      int b = 20;
      int retValue = sumInt(a,b);
      System.out.println(retValue);//10
   }
   public static int sumInt(int i,int j){
      int result = i + j;
      int num = 3;
      int retValue = divide(result,num);
      return retValue;
   }
   public static int divide(int x,int y){
      int z = x / y;
      return z;
   }
}

 下面再次根据代码，画一下方法执行时内存的分配情况：

/*

*/
public class Method01{
   public static void main(String[] args){
      int i = 10;
      method(i);
      System.out.println("method--->"+i);//10
   }
   public static void method(int i){
      i++;
      System.out.println("method--->"+i);//11
   }
}

 下面开始说方法重载，先不说方法重载，先看看下面的代码有什么缺点：

/*
以下代码不使用方法重载机制，不使用overload，分析程序存在缺点。
*/
public class Method01{
   public static void main(String[] args){
      // 调用方法
      int result1 = sumInt(1,2);
      System.out.println(result1);//3
      double result2 = sumDouble(1.0,2.0);
      System.out.println(result2);//3.0
      long result3 = sumLong(1L,2L);
      System.out.println(result3);//3
   }
   // 定义一个方法，可以计算两个int类型的和
   public static int sumInt(int a,int b){
      return a + b;
   }
   // 定义一个方法，可以计算两个double类型的和
   public static double sumDouble(double a,double b){
      return a + b;
   }
   // 定义一个方法，可以计算两个long类型数据的和
   public static long sumLong(long a,long b){
      return a + b;
   }
}

缺点：以上方法，都是计算数据的和，但是我们写了3个不同的方法，方法名称也不想同，程序员调用需要记好多方法名称，那么有没有办法，让这些方法名称相同，

当传入long类型数据时就是计算long类型数据的和，当传入int或double数据时，计算的就是对应数据类型的和。java语言中有这种机制，叫方法重载机制。

 下面体验一下方法重载的优点：

/*
一下代码体验一下方法重载的优点：
1、调用时只需要记住一个方法名即可，调用比较方便，代码美观。
   前提：功能相似的时候，方法名可以相同
   但是，功能不同的时候尽可能让这两个方法的名字不同。

*/
public class Method01{
   public static void main(String[] args){
      // 调用方法的时候就想调用一个方法一样
      // 参数的类型不同，对应调用的方法不同
      // 此时区分方法，不再依靠方法名了，依靠的是参数的数据类型
      System.out.println(sum(1,2));//3
      System.out.println(sum(1.0,2.0));//3.0
      System.out.println(sum(1L,2L));//3
   }
   public static int sum(int a,int b){
      System.out.println("sum(int,int)");
      return a + b;
   }
   public static double sum(double a,double b){
      System.out.println("sum(double,double)");
      return a + b;
   }
   public static long sum(long a,long b){
      System.out.println("sum(long,long)");
      return a + b;
   }
}

 详细介绍方法重载：

/*
1、方法重载，又被称为overload

2、什么时候考虑使用方法重载？
   *功能相似的时候，尽可能让方法名相同
   但是，功能不同/不相似的时候尽量让方法名不同

3、什么条件满足之后构成了方法重载？
   *在同一个类当中
   *方法名相同
   *参数列表不同
      -数量不同
      -顺序不同
      -类型不同

4、方法重载和什么有关系和什么没有关系？
   *方法重载和方法名字和参数列表有关
   *方法重载和返回值类型无关
   *方法重载和修饰符列表无关


*/
public class Method01{
   public static void main(String[] args){
     m1();
     m1(10);

     m2(1,2.0);
     m2(2.0,1);

     m3(1);
     m3(2.0);
   }
   // 以下两个方法构成重载
   public static void m1(){}
   public static void m1(int a){}
   // 以下两个方法构成重载
   public static void m2(int a,double b){}
   public static void m2(double b,int a){}
   // 以下两个方法构成重载
   public static void m3(int a){}
   public static void m3(double a){}
   // 以下不是方法重载，是发生了方法重复了
   // public static void m4(int a,int b){};
   // public static void m4(int b,int a){};
   // 方法重载和返回值类型无关，以下方法重复，编译报错
   // public static void x(){}
   // public static int x(){return 1;}
   // 方法重载和修饰符列表无关，以下方法重复，编译报错
   // void y(){}
   // public static void y(){}

   
}

 方法重载的使用

/*
方法重载的具体应用


*/
public class Method01{
   public static void main(String[] args){
      U.p("哈哈");
      U.p(1);
   }
   

   
}
// 自定义类
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(boolean 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(char b){
      System.out.println(b);
   }
   public static void p(String b){
      System.out.println(b);
   }
}

我们可以将这个U类前面加上public，单独写个java源文件，编译，之后就可以在其它的java源文件调用了，！！

U.java

public class U{
    public static void main(String[] args){
        
    }
    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(boolean 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(char b){
        System.out.println(b);
    }
    public static void p(String b){
        System.out.println(b);
    }
}

Method01.java

/*
方法重载的具体应用


*/
public class Method01{
   public static void main(String[] args){
      U.p("哈哈");
   } 
}

。