day005_自我总结

一、回顾

1.循环
  for循环
   for(初始化语句 ;循环条件判断 ;循环变量改变 ) {
        循环操作
   }
   while 循环
     初始化语句
     while(循环条件判断) {
          循环操作
          循环变量改变
     }
    do while循环
     初始化语句
      do{
         循环操作
         循环变量改变
      }while(循环条件判断);
2.三种循环使用场景 
    for 循环次数固定的时候使用   先判断 再执行 
    do while 至少执行一次循环操作的时候使用 先执行  再判断
    while  循环次数不固定的时候使用  先判断 再执行
3.结束循环
   continue 结束本次循环 执行下一次循环
   break   结束整个循环
   return 通过结束方法结束循环
4.死循环:一直执行循环操作
5.嵌套for循环
   for(初始化语句;循环条件判断;循环变量改变) {
      for(初始化语句;循环条件判断;循环变量改变) {
           执行循环操作
      }
   }
   外层循环执行一次  内层循环执行一轮

二、方法

1.概念：

​ 对比C语言的函数

2.语法

访问修饰符 返回值类型  方法的名称(参数列表) {
     方法体
     return 返回值
}

3.解释

访问修饰符 public static
返回值类型 在定义方法的时候 就明确其返回值类型 返回值类型可以是基本数据类型 也可以是引用数据类型
方法的名称：取一个名称 规则：小驼峰命名 通俗易懂 顾名思义
参数列表 原料 执行方法体需要到原料 参数列表可有 可无
方法体 执行的具体的逻辑代码
return 返回值 执行据图的逻辑代码 返回的结果

eg01 定义一个没有参数 没有返回值的方法

  //定义一个没有返回值 没有参数的方法
    public  static   void  showInfo(){
        System.out.println("今天今天真好!适合约会");
    }

eg02 定义一个有参数有返回值的方法

   /**
     *
     * @param num1
     * @param num2
     * @return 两个数之和
     */
    public static   int getSum(int num1,int num2) {
        //求两个数之和
        int sum = num1+num2;
        return  sum;
    }

4.方法的调用

​ 直接书写方法名就可以调用 eg：getSum(2,3)

部分名称	说明
getSum	方法的的名字
(2,3)	调用方法传递实际的数据(实实在在的数据)

4.1方法调用方式

调用的方式	说明
直接调用	只需要执行代码的逻辑 不需要返回结果的时候
打印调用	调用方法之后 需要查看方法的返回值结果就可以使用打印调用
赋值调用	调用方法之后 需要将方法的返回值结果 给其它变量使用

4.1.eg01直接调用

public class Test09 {
    public static void main(String[] args) {
        showInfo();
    }

    public static   void  showInfo(){
        for (int i=1;i<=5;i++) {
            for (int j=1;j<=5;j++) {
                System.out.print("*");
            }
            System.out.println("");
        }
    }
}

4.1.eg02打印调用

public class Test10 {
    public static void main(String[] args) {
        System.out.println(getSum(20, 30));
    }

    /**
     *
     * @param num1
     * @param num2
     * @return
     */
    public static  int  getSum(int num1,int num2){
        int sum = num1+num2;
        return  sum;
    }
}

4.1.eg03赋值调用

public class Test11 {
    public static void main(String[] args) {
       int s =  getSum(20,10);
       int s1 =s*100;
        System.out.println(s1);

    }

    /**
     *
     * @param num1
     * @param num2
     * @return
     */
    public static  int  getSum(int num1,int num2){
        int sum = num1+num2;
        return  sum;
    }
}

5.方法的注意事项

1.方法定义的注意事项
 A.所有方法都是平级  没有上下级关系
 B.方法定义在类中 
 C.方法定义的时候 不能进行相互嵌套
 D.方法在调用的时候 是可以进行相互调用  甚至可以自己调用自己(递归)
2.方法调用的注意事项
 A.参数
    形参 形式参数(象征性参数) 在定义方法的时候使用形参 就是声明变量  多个形参需要以逗号来进行分割
    实参 实际参数(具体的数据) 在调用方法的时候使用实参 就是给变量赋值 实参必须是形参顺序以及数据类型一致
 B.返回值
    1. return 可以用于来返回数据  也可以用于来结束方法
        a.如果方法定义的时候 使用void进行修饰的时候 就可以使用 return;来结束方法
        b.如果方法定义的时候  有返回值 那么必须是用return返回具体的数据
    2.方法的返回值 是返回给调用者 谁调用返回给谁
        
       
     

6.方法的重载

1.重载的规则:在同一一个类中  方法名相同 参数不同  与访问修饰符与返回值无关
2.解释:
    在同一一个类中:重载的方法只能在一个类中
    方法名相同:方法名完全相同 包括大小写
    参数不同:
         a.参数的类型不同  b.参数个数不同
         c.参数名字无关
    访问修饰符 public  static 
    返回值无关:可以有返回值  也可以没有返回值

6.1案例，tips:.charAt(0)

public class Test17 {
    public static void main(String[] args) {
        //tips:.charAt(0) 表示获取字符串的第1个字符
        //tips:.charAt(1) 表示获取字符串的第2个字符
        System.out.println(toString(20).charAt(0));
        System.out.println(toString(30.5).charAt(1));
        System.out.println(toString(true).charAt(0));
    }

    public  static   String  toString(int c){
        return  c+"";
    }
    public static  String toString(double d){
        return  d+"";
    }
    public static  String toString(boolean b){
        return  b+"";
    }

}

7.方法的内存图

栈内存：先进后出（进栈/压栈	 出栈/弹栈）

三、数组

3.1特点

​ 长度固定、必须存储同一种数据类型（可以是基本数据类型，也可以是引用数据类型）

3.2数组的动态初始化

1.动态初始化：不给数组赋值
2.语法:
	数组的数据类型 [] 数组名称 = new 数组的数据类型 [长度]
3.解释
	①数组的数据类型：存储数组中元素的数据类型（既可以是基本数据类型，也可以是引用数据类型）
	② [] ：表示是一维数组		[][]：表示是二维数组
	③数组名称：表示栈内存引用（说白了就是数组的地址值）
	④ = ：表示将堆内存的地址值，赋值给栈内存的引用
	⑤ new ：表示在堆内存中开辟空间
	⑥数组的数据类型：前后数组的数据类型必须是一致的
	⑦[长度]；表示数组中存储元素的个数
4.例子：int [] nums = new int [3];
5.注意点:
    直接打印数组的名称 打印的是数组的地址值
    地址值解释:
     ①打印出：[I@1b6d3586
     ② [ ==>表示的是一维数组
     ③ I ==>int类型
     ④ @ ==>没有特殊含义 表示连接的符号
     ⑤ 1b6d3586==>地址值的hashcode值
     总结:就是地址值

3.3数组的操作

1.数组的操作 == 对数组进行赋值和取值  （通过索引<下标>来进行赋值和取值操作）
2.数组的索引从0开始
	数组的索引最大值：数组长度减一
	数组的长度==>* 数组的名称.length *	例如：arrays.length
3.数组的赋值与取值
    赋值的语法: 数组的名称[索引]=数据 例如: nums[0]=10
    取值的语法: 数组的名称[索引] 例如:nums[0]
4.数组存储内容存在默认值
    int   ==> 0
    double   ==> 0.0
    boolean  ==> false
    char ==> '\u0000' ==> 空格
    引用数据类型 ==> null

3.4数组的静态初始化

1.静态初始化：在创建数组的时候 就给数组赋值
2.语法：
	数组的数据类型 [] 数组名称 = new 数组的数据类型[]{元素罗列}
简易方式：
    数组的数据类型 [] 数组的名称 = {元素罗列} //必须写在同一行，不能分开写
3.例子：int [] nums = new int[]{10,20,30}

3.5数组常见的异常

1.生活中异常 :上班堵车  ...  上课异常.....
2.异常:执行代码发生了错误 就是异常
3.数组中常见的异常 数组下标越界异常  空指针异常
4.数组下标越界
  A.ArrayIndexOutOfBoundsException
  B.产生的原因: 对数组进行操作的时候 所 索引值超出了数组的最大范围
  C.解决:  对数组进行操作的时候 对索引进行判断 是否是在这个范围之内
5.空指针异常
  A.NullPointerException
  B.产生的原因:栈内存引用没有指向任何堆内存的地址值 却要从堆内存获取数据 
  C.解决:在使用数组的时候 对数组进行非空验证

3.5.1eg01 数组下标越界

public class Test25 {
    public static void main(String[] args) {
        //动态初始化数组
        int []  nums  = new int[2];
        nums[0]=100;
        nums[1]=200;
        if (2 >=0 && 2<nums.length) {
            System.out.println(nums[2]);
        }

    }
}

3.5.2eg02 空指针异常

public class Test26 {
    public static void main(String[] args) {
        //创建一个数组
        int [] arrays =new int[3];
        arrays=null;
        if (arrays !=null && arrays.length>0) {
            System.out.println(arrays[0]);
        }

    }
}

四、JVM内存划分

1.内存:
   A.编写的java代码是存在硬盘中  硬盘中的数据是永久保存
   B.运行的java程序会在内存中开辟空间  内存中的数据是临时存储
2.jvm将内存划分为五块 房子(厨房 卧室  客厅 ) 方便对数据进行存储   便于统一管理
3.五块
   栈内存(重点)
      特点: 先进后出  进栈 压栈   出栈 弹栈
      A.所有的局部变量都是存在栈内存中
      B.所有的方法在执行的时候都会在栈内存中开辟空间
   堆内存(重点)
      A.只要是new的资源 都会在堆内存中开辟空间  例如  new 对象  new  数组
   方法区(重点)
      A.静态资源都是存在方法区中
      B.类加载信息(Class) 都是在方法区中
   本地方法区
      调用本地方法 就是调用c与c++的方法 
      只要是使用native修饰的都是c与c++的方法
      例如: public native int hashCode();
   程序计数器
     与cpu有关 控制程序代码的执行

4.1 一个数组创建的内存图

4.2 两个数组创建的内存图

4.3 两个引用指向同一个堆内存的内存图