Java的内存分析：

     在Java程序中，主要就是有 栈 ，堆，以及方法区，

              而一个Java程序的运行，也是先由 栈到堆的一个进行过程；

#   数组

   数组的定义： 就是同一个类型的数组集合，

   数组一旦被创建，他的长度就是唯一的了，不能被改变，

  数组中的类型可以是任意类型，但是必须是同一种类型，不可混合，

 数组是属于引用类型：数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量

 数组的本身就是对象：Java的对象是在堆中的，所以数组无论是保存原始类型，还是其他类型，数组对象本身还是在堆中的。

  数组被创建的方式：代码如下：

package com.oop;

public class a {
    public static void main(String[] args) {
//        一位数组的创建
        int[]  array={1,21,31,2121,12,12};
        int[]  array1=new int[10];
        
//        二维数组的创建
        
        int[][] array2={{1,21},{1,122},{3123,213},{213,89}};
        int[][] array3=new int[2][5];
    }
}

# 冒泡排序法：

  思想：在Java程序中，排序的方法有很多种，但是里面最经典的就是冒泡排序法了，

        冒泡排序法的一个思想，就是从第一二位到最后一二位，之间相互进行比较，如果前面一位比后面一位小，那么数组中的这两位数就要进行交换：且每次循环都会找到最小的那一个，或者最大的那一个：

       代码如下：

package com.oop;

import java.util.Arrays;

public class a {
    public static void main(String[] args) {
// 冒泡排序法：
        int[] array={1,34,12123,234,126,3414,452,645,3797,73534,2342,345,642};
        System.out.println("冒泡排序之前的数组是："+Arrays.toString(array));
        System.out.println("------------------");
        int temp;
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j <array.length-1-i ; j++) {
                if(array[j+1]<array[j]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        System.out.println("经过冒泡排序以后的数组是："+Arrays.toString(array));//使用Arrays方法对数组进行直接打印

    }
}

#  洗漱数组

   就是记录表里面的有效值，并将他们的坐标位置记录下来，代码如下：

package com.oop;

import java.util.Arrays;

public class a {
    public static void main(String[] args) {
//稀疏数组
        int[][] array=new int[11][11];
         array[3][4]=1;
         array[5][7]=2;
        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("----------------------------");
//        上面的操作就是创建这个数组表，并将里面的特定位置进行赋值：
        int sum=0;//用来收集里面的值的个数
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j <array.length ; j++) {
                if(array[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("-----------------------------");
//        上面这步就是用来收集里面不等于0的数有多少个；
        int count=0;
        int[][] array2=new int[sum+1][3];//
        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;
        for (int i = 1; i <array.length ; i++) {
            for (int j = 0; j <array.length-1 ; j++) {
                if(array[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array[i][j];

                }
            }
        }
//        上面的操作就是将里面不等于0的数的位置找到，并将他们的坐标的行以及列记下来：以及将他们的记录在表中
        System.out.println("----------------------");
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }


    }
}

运行得到的结果：

 下面输出的值： 11，11，2 前面的两个就是表示 行以及例 ，2表示的是有两个不等于0的值：

         3  ，4 ，1  表示的是：第三行，第四例里面所存放的值是 1 下面的都是一样的。

#   面向对象

  面向对象以及面向过程，

 在前面的基础部分阶段，我们重在的就是面向过程的代码;

 简单来说:面向过程就是，一步一步的完成一件事情。也是做一些基础的代码

 面向对象，就相当于是类，而面向对象就是用来处理比较复杂的问题。

   属性+方法==类

  面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织（封装）代码；

   抽象：

三大特性：

 继承

封装

多态

形参以及实参：

英语单词总结：

sort排序