稀疏数组

package com.zzl.arry;

public class Demo8 {
    public static void main(String[] args) {
        //1.创建一个二维数组11*11 0：没有棋子  1：黑棋 2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        System.out.println("输出原始数组：");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
            System.out.println("==========================");
        }
        //转换为稀疏矩阵
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println(sum);
        //创建一个稀疏数组
        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.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];

                }

            }

        }
        //输出稀疏数组
        System.out.println("输出稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
                    +array2[i][1]+"\t"
                    +array2[i][2]+"\t");
        }
        System.out.println("========================");
        System.out.println("还原");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) { //注意o行不能取
            array3[array2[i][0]][array2[i][1]] = array2[i][2];

        }
        //打印原数组
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}

面向对象

以类的方式组织代码，以对象的组织（封装）数据

类和对象的构造

package com.zzl.oop2.Demo1;
//学生类
public class Student {
    //属性：字段
    String name;
    int age;
    public void study(){
        System.out.println(this.name+"在学习");
    }

}
/*
        //类是抽象的，实列化
        //类实例化后会返回一个自己的对象；
        //student对象就是一个Student类的具体实例！
   Student xiaoming = new Student();
        Student xiaohong = new Student();
        xiaoming.name = "小明";
        xiaoming.age = 3;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
        xiaohong.name = "小红";
        xiaohong.age = 3;
        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);
 */

构造器

package com.zzl.oop2.Demo1;

public class Person {
//一个类即使什么都不写，也会产生一个构造方法
    //1.必须和类的名字相同，也不能写void
    //显示的定义构造器
    String name;
    //实例化初始值
    //1.使用new关键字，必须要有构造器，本质是在调用构造器
    public Person(){

    }
    //有参构造,一旦定义了有参构造，无参构造必须显示定义
    //y用来初始化值
    //alt+insert 自动生成构造器
    public Person(String name){
        this.name = name;
    }

}
    //类是抽象的，实列化
    //类实例化后会返回一个自己的对象；

   /* Person person = new Person("zzl");
        System.out.println(person.name);
        构造器
        1.和类名相同
        2.没有返回值
        作用：
        1.new的本质在调用构造方法
        2.初始化对象的值
        注意点：
        1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参构造



        */

创建对象内存分析

面向对象总结

1. 类与对象

   类是一个模板是抽象的，对象是一个具体的实例

2. 方法

   定义，调用

3. 对应的引用

   引用类型： 基本类型（8）；

   对象是通过引用来操作的：栈---》堆

4. 属性：字段Field 成员变量

   默认初始化

   数字：0 0.0

   char ：u0000

   boolea： false

   引用： null

   修饰符 属性类型 属性名 = 属性值；

5. 类：

   静态的属性 属性

   动态的行为 方法

6. 对象的创建和使用

   -必须使用new 关键字创造对象，构造器 Person zzl =new Person();

   -对象的属性 zzl,name

   -对象的方法 zzl.sleep()