3.字符串 方法

引用数据类型：String 字符串、数组、类

​​​​​​1.字符串的创建

语法1：使用new关键字创建字符串
       String 变量 = new String("字符串值");
  语法2：使用字面量（常量）赋值的方式创建
       String 变量 = "字符串";
  注意：这两种方式创建出来的字符串是不一样的
           语法1使用new关键字创建的数据，是在内存中的堆区
           语法2使用字面量方式创建的数据，是在内存中的栈区

package com.day3.stringtest;

public class StringDemo01 {
    public static void main(String[] args) {
        //创建String类型
        String s1 = new String("java");
        System.out.println(s1);

        String s2 = "java";
        System.out.println(s2);

        String s3 = "java";
        System.out.println(s1==s2);//false
        System.out.println(s2==s3);//true



    }
}

 java中内存的划分（初步了解）：
   jvm中，执行程序的时候，内存一共分为5个区域
   堆、栈、方法区、本地方法区、程序计数器
   暂时先认识堆和栈的使用
   栈:
      1.栈空间自动分配，不需要程序员去申请
      2.栈空间有固定的数据结构，按先进后出方式管理
      3.存储空间较小，不能存放太多的数据
      4.jvm将基本类型，存放在栈空间
      5.栈的存取效率较高
   堆：
      1.堆空间创建，需要程序员去申请
      2.存放位置是随机的，分配一个地址值，交给变量引用
      3.存储空间较大，可以存放大量数据
      4.引用类型，存放在堆空间
      5.相较而言，堆空间的存放效率较低

Java中的方法（函数）
   将需要执行的代码，分装在方法中，然后通过方法名，调用方法，就可以获得他封装的功能
   语法：
       修饰符 返回值类型 方法名(参数列表){
            代码块;
            return 返回值;
       }

       public static int/void addNumber(int a,int b){
               int sum = a + b;
               return sum;
       }
       修饰符：目前固定是 public static
       返回值类型：如果定义的方法将来需要返回一个结果，那么就需要返回值类型
                 返回值类型就是数据类型，可以是基本类型，也可以是引用类型
                 如果定义的方法，只是为了完成某些功能，并不需要返回一个结果，
                 可以将返回值类型设为空void
       方法名：自己取的名字，遵循标识符命名规范即可，声明后将来给使用者调用
       参数列表：指的是，将来调用方法的时候，是否需要传入值去使用方法
               可以没有参数，也可以有一个、两个、多个参数
               多个参数之间用逗号隔开
               参数的写法：跟声明变量的方式基本一样（不要赋值）
               int a，int b
       代码块：方法实现功能需要的代码
       return：如果方法体上，定义了返回值类型，那么必须要有return，并且要返回对应返回值一样类型的值
               如果方法体上，返回值类型是void，则不需要使用return
   方法的分类：
       1.没有返回值，没有参数
       2.没有返回值，有参数
       3.有返回值，没有参数
       4.有返回值，有参数

package com.day3.methodtest;

public class DemoMethod01 {
    public static void main(String[] args) {
        /*
        方法的分类：
       1.没有返回值，没有参数
       2.没有返回值，有参数
       3.有返回值，没有参数
       4.有返回值，有参数
         */
        say();
        show("jack");
        //将来调用有返回值的方法，可以怎么做？
        //1.可以将返回值直接输出，或者带入到其他的运算中进行运算
        System.out.println(getSum());
        System.out.println(getSum() + 100);
        //2.可以将返回值赋值给一个变量，变量再代入到其他的变量中
        //有返回值的方法，可以先写方法名调用，利用快捷键 alt+enter 快速生成变量
        //int i = getSum();
        //String s = getSum();--错误！
        int sum = getSum();
        System.out.println(sum);
        System.out.println(sum + 1000);
        //3.调用有返回值、有参数的方法
        int add = add(2,3);
        System.out.println(sum);

        double v = add1(11.2, 2.73);
        System.out.println("m+n=" +v);

        info("lucy","19","女");

    }

    //没有返回值，没有参数，将来一般用来完成某些功能
    public static void say(){
        int sum=0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        System.out.println("1-100的和是："+sum);
    }

    //没有返回值，有参数，一般根据参数，实现某些功能
    //这里方法体上声明的参数，name是一个形参
    public static void show(String name){
        System.out.println("我的名字是："+name);
    }

    //有返回值，没有参数，一般用来定义执行某些固定的功能，返回固定的返回值
    public static int getSum(){
        int sum=0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        return sum;//返回的值，跟返回值类型一样
    }

    //有返回值，有参数
    public static int add(int a,int b){
       // int sum = a+b;
       // return sum;
        return a+b;
    }

//写一个方法，可以传入两个小数，并计算返回他们的和
      public static double add1(double m,double n){

        return m+n;
      }

//写一个方法，可以传入姓名、年龄、性别，调用后会输出自我介绍
       public static void info(String name,String age,String sex){
           System.out.println("我的名字是"+name+",今年"+ age +"岁," +"性别"+sex);
       }

}

   方法的递归：表示在方法中调用自身
          递归中，需要有一个能结束递归的操作，不然递归操作会无限执行
          将来会报一个 栈溢出错误Stack0verflowError

package com.day3.methodtest;

public class DemoMethod02 {
    public static void main(String[] args) {
        //调用其它类中写好的方法
       // int sum = DemoMethod01.add(7, 9);
       //  System.out.println(sum);

        System.out.println(method02(100));

        System.out.println(method03(100));

        System.out.println(frog(10));
    }

    //无限递归
    /*
    public static void method01(){
        System.out.println("hello!");
        method01();
    }*/

   //使用递归，写一个方法，求1-n的和，n是方法的参数

    //for循环写法
    public static int method02(int n){
        int sum = 0;
        for (int i = 0; i <= n; i++) {
            sum += i;
        }
        return sum;
    }

    //递归的写法
    public static int method03(int n){
        //1 + 2 +...+ n
        if (n == 1){
            return 1;
        }else {
            return n+method03(n-1);
        }
        //1 -> 1
        //2 -> 2 + method03(1) ->2+1

    }

    //青蛙跳台阶
    //一个青蛙，一次可以跳一级或者两级台阶，求青蛙跳10级台阶，有多少种跳法？
    //1     1
    //2  11 2    2
    //3  111 12 21     3
    //4  1111 121 112 211 22   5
    //5  11111 1211  122  1121 1112  2111 212 221     8
    //6  11111 12111   13
    //10

    public static int frog(int n){
        if(n==1){
            return  1;
            }else if(n==2){
                return 2;
            }else{
            return  frog(n-1)+frog(n-2);
        }

    }



}