Java Day05

1. break 和 continue关键字的使用
   1. break：适用范围：switch-case结构和循环结构
      1. 结束当前循环
   2. continue：适用于循环结构
      1. 结束当次循环
   3. 标签版break和continue

      1. label:for(int i=1;i<=4;i++){
                 for(int j=1;j<=10;j++){
                     if(j%4==0){
                         break label;//结束指定标识的一层循环
                             }
                     System.out.print(j);
         }
             System.out.println();
         }

                 

2. 数组

   1. 定义：是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理

   2. 数组的常见概念

      1. 数组名

      2. 下标

      3. 元素

      4. 数组的长度

   3. 特点：数组是有序的

   4. 数组属于引用数据类型的变量，数组中的元素可以是基本数据类型，也可以是引用数据类型

   5. 创建数组对象会在内存中开辟一整块连续的空间

   6. 数组的长度一旦确定，不能修改

   7. 数组的分类

      1. 按照维数：一维数组、二维数组

      2. 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

   8. 一维数组的使用

      1. 一维数组的声明和初始化

         1. int[] num;
            num=new int[3];
            or 
            num=new int[]{1,2,34};
            
            or
            int[] num=new int[]{123,2,3};

      2. 如何调用数组的指定位置的元素

      3. 如何获取数组的长度

         1. 属性：length

         2. System.out.println(XXX.length);

            1. XXX为数组名

      4. 如何遍历数组

      5. 数组元素的默认初始化值

         1. 数组元素是整型：0

         2. 数组元素是浮点型：0.0

         3. 数组元素是char类型：空字符（0）

         4. 数组元素是boolean型：false

         5. 数组元素是String类型：null

      6. 数组的内存解析

         1. 栈：存放局部变量

         2. 堆：存放new出来的结构：对象、数组

         3. 方法区

            1. 常量池

            2. 静态域

3. 多维数组的使用

   1. 对于二维数组的理解：我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在

   2. 二维数组的声明和初始化

      1. 静态初始化

         1. int[][] arr=new int[][]{{1,2,3},{2,3},{1,2,3}};

      2. 动态初始化1

         1. int[][] arr1;
            arr1=new int[3][2];

      3. 动态初始化2

         1. int[][] arr2;
            arr2=new int[3][];
            

            动态初始化的行数必须写清楚但是列数可以不用写

   3. 调用二维数组指定位置上的元素

   4. 二维数组的长度和遍历

      1. 获取数组的长度

         1. System.out.println(arr4.length);//会输出行数
            System.out.prinln(arr4[0].length);//输出对应行的列数

            1

   5. 二维数组的元素初始化

      1. 规定：二维数组分为外层数组的元素，内层数组的元素

      2. 当数组没有进行初始化值的时候，System.out.println(arr[0]);的话会输出数组的首地址

      3. int[][] arr1=new int[4][];
         System.out.prinln(arr1[0]);
         //这种情况输出值为null，因为arr1只表明了有多少行，没有表明对应行有多少列，属于指针缺失的情况，即arr1[]里面的值是内层数据保存的地址，因为内层数据并没有定义，所以输出null

      4. 外层元素的初始化值：地址值

      5. 内层元素的初始化值：与一维数组初始化情况相同

   6. 二维数组的内存结构

4. 数组中涉及到的常见算法

   1. 数组元素的赋值

   2. 求数值型数组中元素的最大值、最小值、平均数、总和等

   3. 数组的复制、反转、查找（线性查找、二分法查找）

   4. 数组元素的排序算法

5. 面向对象

   1. 面向过程与面向对象
      1. 面向过程：强调的是行为功能，以函数为最小单元，考虑怎么做
      2. 面向对象：将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做
         1. 类（Class)：类是对一类事物的描述，是抽象的、概念上的定义
            1. 面向对象程序设计的重点是类的设计
            2. 类的设计，其实就是类的成员的设计
         2. 对象(Object)：对象是实际存在的该类事物的每个个体，因而也称为实例（instance)
         3. 类和对象的使用
            1. 创建类，设计类的成员（属性）
            2. 创建类的对象（在main方法中）--对象可以创建多个
            3. 通过“对象.属性“或”对象.方法“调用对象的结构
            4. 如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性：如果我们修改一个对象的属性a，则不影响另一个对象的属性a。但是如果指定一个新的对象=一个旧的对象（即将旧对象的地址赋值给新对象，导致两个对象指向了堆空间中的同一个对象实体），则这两个对象完全合成微一个对象，改变新对象的属性a同时也会改变旧对象的属性a
         4. 对象的内存解析
            1. 堆：此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。（横着的、new的都在堆里）
            2. 栈：是指虚拟机栈。用于存储局部变量等。（竖着的）
            3. 方法区：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据
            4. 

             

   2. JAVA类及类的成员

      1. 属性

         1. 对应类中的成员变量

         2. 属性和局部变量的区别

            1. 相同点：

               1. 定义变量的格式：数据类型 变量名=变量值

               2. 先声明，后使用

               3. 变量都有其对应的作用域

            2. 不同点：

               1. 在类中声明的位置的不同

                  1. 属性：直接定义在类的一对{}中

                  2. 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

                  3. public class UserTest{
                     }
                     class User{
                         //下面三种为属性    
                         int num;
                         String name;
                         boolean gender;
                         
                         public void talk(String language){
                         //下面的language为局部变量
                         System.out.prinln("we use "+language);
                         }
                     }

                     1

               2. 关于权限修饰符的不同

                  1. 属性：可以在声明属性时，指明其权限，使用权限修饰符。常用的权限修饰符：private/public/缺省/protected。-->封装性

                  2. 局部变量：不可以使用权限修饰符

               3. 默认初始化值

                  1. 属性：根据其数据类型都有默认初始化值

                  2. 局部变量：没有默认初始化值，一定要事先初始化

               4. 在内存中加载的位置

                  1. 属性：加载到堆空间中

                  2. 局部变量：加载到栈空间

      2. 方法

         1. 对应类中的成员方法（函数）

         2. 用来描述类应该具有的功能

         3. 方法的建立

            1. 方法的声明

               1. 权限修饰符 返回值类型 方法名（形参列表）{方法体}

            2. 说明

               1. 关于权限修饰符：private\public\缺省\protected

               2. 返回值类型：有返回值 vs 无返回值

                  1. 如果方法有返回值，则必须在方法声明时，指定返回值的类型，同时方法中需要使用return关键字来返回指定类型的变量或者常量

                  2. 如果方法没有返回值，则方法声明时，使用void来表示

               3. 方法名：属于标识符，遵循标识符的规则和规范，xxxYyy

               4. 形参列表：方法可以声明一个或者多个形参

                  格式：数据类型1 形参1，数据类型2 形参2，
            3. 注意
               1. 可以调用当前类中的方法和属性
               2. 方法里面不可以定义新的方法

      3. 构造器

      4. 代码块

      5. 内部类

   3. 面向对象的特征

      1. 封装性

      2. 继承性

      3. 多态性

      4. 抽象性

   4. 其他关键字