稀疏数组、抽象类、接口、封装、内部类

稀疏数组

• 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wQwfCAI5-1593350273503)(C:\Users\Administrator\Desktop\图片\稀疏数组.png)]

//稀疏数组
public class ArrayDemo2 {
    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++) {
            for (int j = 0; j < array2.length; j++) {
                System.out.print(array2[i][j]+"\t");
            }
            System.out.println();
        }


        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++) {
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }

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

抽象类

1. 不能new这个抽象类，只能靠子类去实现它：约束！
2. 抽象类中可以写普通的方法
3. 抽象方法必须在抽象类中~
4. 抽象类只能单继承

思考题

抽象类中存在构造器吗？

可以有构造器，只是不能直接创建抽象类的实例对象

参考原连接

抽象类存在的意义？

抽象出来~ 提高开发效率

接口

• 普通类：只有具体实现
• 抽象类：具有实现和规范（抽象方法）都有！
• 接口只有规范！自己无法写方法~专业的约束！ 约束和实现分离：面向接口编程
• 可以实现多个接口 implement
• 必须重写接口中的方法

//接口中定义的属性都是常量 public static final int AGE=99
int AGE=99;

//接口中所有的定义的方法都是抽象的 public abstract add(String name);
void add(String name);
void delete(String name);
void update(String name);
void query(String name);

封装

高内聚，低耦合

• 高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用（该露的露，该藏的藏）

封装（数据的隐藏）

• 通常，应禁止直接访问一个对象中的实际表示，而应通过操作接口来访问，这称为信息隐藏
• 属性私有，get/set

内部类

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

public class Outer {

    private int id=10;
    public void out(){
        System.out.println("外部类方法");
    }
    public class Inner{

        public void in(){
            System.out.println("内部类方法");
        }
        //获得外部类的私有属性
        public void getID(){
            System.out.println("外部类id："+id);
        }
    }

    //局部内部类
    public void method(){
        class B{

        }
    }
}

//一个类中只有一个public class类可以有很多class A~类
class A{
    public static void main(String[] args) {

    }
}

---

public class Application {
    public static void main(String[] args) {
        //外部类
        Outer outer = new Outer();
        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();

        //匿名内部类
        //没有名字初始化类，不用讲实例保存到变量中
        new Outer().method();
    }
}