零基础坚持学Java【记录record】

5/20

稀疏数组*

• 是一种数据结构，“压缩算法”
• 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
• 稀疏数组的处理方式是：
  • 记录数组一共有几行几列，有多少个不同值
  • 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

public class Demo{
    psvm{
        //创建一个二维数组 11*11    0：没有棋子   1：黑棋  2：白棋
        int[][] array1= new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 1;
        //输出原始的数组
        for(int[] ints:array1){
            for(int anInt : ints){
                sout(anInt+"\t");
            }
            sout();
        }
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        fot(int i = 0;i < 11；i++){
            for(int j = 0;j < 11;j++){
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        sout("有效值的个数："+sum);
        //2.创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        
        //遍历二维数组，将非零的值，存放稀疏数组中
        int count = 0;
        for(int i = 0;i <array1[i].length ; i++){
            for(int j = 0;j <array1[i].length;j++){
            if(array1[i][j]!=0){
                cout++;
                array2[cout][0] = i;
                array2[cout][1] = j;
                array2[cout][2] = array1[i][j];
               }
            } 
        }
        //输出稀疏数组
        sout("稀疏数组")；
            for(int i = 0;i < array2.length;i++){
                sout(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
            }
        sout("还原");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        
        //2.给其中的元素还原它的值
        for(int i = 1;i < array2.length;i++){
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //输出还原的数组
        for(int[] ints:array1){
            for(int anInt : ints){
                sout(anInt+"\t");
            }
            sout();
        }
    }
}

面向对象编程

• 面向对象思想
  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
• 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
• 面向对象编程（Object-Oriented Programming，OOP）
• 本质：以类的方式组织代码，以对象的组织（封装）数据。
• 三大特性：
  • 封装
  • 继承
  • 多态

回顾方法及加深

• 方法的调用：递归
  • 静态方法
  • 非静态方法
  • 形参和实参
  • 值传递和引用传递
  • this关键字

//静态方法  static  可直接调用
public static class Student{
    public void say()
    System.out.println("学生说话了")
}
//非静态方法  需要实例化
Student student= new Student();
student.say();
//简写
new Student().say();

类的调用，特殊情况：

public class Demo02{
    //静态方法 和类一起加载的
    public static void a(){
        b();//报错！！！
    }
    //非静态方法 在类实例化 之后才存在
    public void b(){
        
    }
}

形参和实参：

public class Demo03{
    psvm{
      Demo03.add(1,2);//实参
        sout(add)
    }
    public static int add(int a,int b){//形参
        return a+b;
    }
}

值传递和引用传递：

//值传递
psvm{
    int a = 1;
    sout(a);//1
    
    Demo04.change(a);
    
    sout(a);//1
}
//返回值为空
public static void change(int a){
    a = 10;
}

//引用传递：对象，本质还是值传递

//听懵了：因为没明白 对象，内存*
public class Demo05{
    psvm{
        Person preson = new Person();
        sout(person.name);//null
        
        Demo05.change(person);
        
        sout(person.name);//秦疆
    }
    public static void change(Person person){
        //person是一个对象；这是一个具体的人，可以改变属性！
        person.name = "秦疆";
    }
}
    //定义一个Person类，有一个属性：name
    class Person{
        String name;//null
    }