数组

         //静态初始化
         int[]a={1,2,3};
         //动态初始化
         int[]b=new int[3];
         //int[]b;       数组的声明   （栈）
         //b=new int [3];数组的创建   （堆）     
         System.out.println(a[0]);
         System.out.println(b[0]);

数组的四个基本特点

1. 其长度市确定的，数组一旦创建，大小无法改变

2. 其元素必须是相同类型，不允许混合类型

3. 数组中的元素可以是任意数据类型，包括基本类型和引用类型

4. 数组变量属于引用类型，数组也可以看做是对象，数组中每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身都在堆中。

数组的使用

foreach

冒泡排序

     public static void main(String[] args) {
     int[]p={1,55,68,20,75,30};
     int[]result=bubble(p);
         for (int i = 0; i <result.length; i++) {
             System.out.println(result[i]);
         }
     }
     public static int [] bubble(int[] a){
         int t=0;
         boolean flag=false ;
         for (int i = 0; i < a.length-1; i++) {
             for(int j=0;j<a.length-i-1;j++){
                 if(a[j]>a[j+1]){
                     t=a[j];
                     a[j]=a[j+1];
                     a[j+1]=t;
                     flag=true;
                 }
             }
             if(flag==false){
                 break; }
         }
 return a;
     }

稀疏矩阵

 import java.sql.SQLOutput;
 public class xishujvzhen {
     public static void main(String[] args) {
         int [][] a=new int[10][10];
         a[1][1]=1;
         a[1][2]=2;
         a[9][9]=99;
         jz(a);
        int [][] m= xs(a);
         re(m);
     }
     //输出正常矩阵
     public static void jz(int[][]a) {
         for (int[] ints : a) {
             for (int i : ints) {
                 System.out.print(i+"\t");
             }
             System.out.println();
         }System.out.println("==============================");
     }
     //将正常矩阵转化为稀疏矩阵
     public static int[][] xs(int[][]a){
         int sum=0;
         for (int i=0;i<a.length;i++) {
             for (int j=0;j<a[i].length;j++) {
                 if (a[i][j]!=0){
                     sum++;
                 }
             }
         }
         int x=0;
         int[][]xs=new int[sum+1][3];
         xs[0][0]=a.length;
         xs[0][1]=a[1].length;
         for (int i=0;i<a.length;i++) {
             for (int j=0;j<a[i].length;j++) {
                 if (a[i][j]!=0){
                    x++;
                     xs[x][0]=i;
                     xs[x][1]=j;
                     xs[x][2]=a[i][j];
                 }
             }
         }
         xs[0][2]=sum;
         for (int[] ints : xs) {
             for (int i : ints) {
                 System.out.print(i + "\t");
             }
             System.out.println();
         }
         System.out.println("==============================");
         return xs;
     }
 //将稀疏矩阵转换为正常矩阵
     public static void re(int[][] a){
         int[][]re=new int[a[0][0]][a[0][1]];
         for (int i = 1; i < a.length; i++) {
                 re[a[i][0]][a[i][1]]=a[i][2];
         }
         for (int[] ints : re) {
             for (int i : ints) {
                 System.out.print(i + "\t");
             }
             System.out.println();
         }
     }
 }

面向对象

其本质就是：以类的方式组织代码，以对象的组织（封装）数据。

三大特性：

1. 封装

2. 继承

3. 多态

抽象