面向对象

稀疏数组

本来是打算偷懒不写这个内容的，但昨天看了一下数据结构的网课，发现里面也讲了稀疏数组，所以还是把它过一遍比较好。

普通数组和稀疏数组的区别

稀疏数组的代码实现

将普通数组转化为稀疏数组

1.先建立普通数组

int[][] array=new int[5][7];
array[0][2]=1;
array[1][3]=2;
array[2][4]=3;
for(int[] row:array){ //打印出二维数组
 ? ?for(int i:row){
 ? ? ? ?System.out.print(i+" ");
 ?  }
 ? ?System.out.println();
}

2.再建立稀疏数组

稀疏数组的第0行的三个数分别是二维数组的行、列和有效值的个数；

稀疏数组的行数是二维数组的有效值的个数加一，列数为3；

则需要遍历二维数组，找出有效值的个数。

int count=0;
for(int i=0;i<5;i++){
 ? ?for(int j=0;j<7;j++){
 ? ? ? ?if(array[i][j]!=0){
 ? ? ? ? ? ?count++;
 ? ? ?  }
 ?  }
}
int[][] sparse=new int[count+1][3];
sparse[0][0]=5;
sparse[0][1]=7;
sparse[0][2]=count;
int sum=0;
for(int i=0;i<array.length;i++){
 ? ?for(int j=0;j<array[i].length;j++){
 ? ? ? ?if(array[i][j]!=0){
 ? ? ? ? ? ?sum++;
 ? ? ? ? ? ?sparse[sum][0]=i;
 ? ? ? ? ? ?sparse[sum][1]=j;
 ? ? ? ? ? ?sparse[sum][2]=array[i][j];
 ? ? ?  }
 ?  }
}

3.打印出稀疏数组

for(int[] num:sparse){
 ? ?for(int a:num){
 ? ? ? ?System.out.println(a+" ");
 ?  }
 ? ?System.out.println();
}

4.将稀疏数组还原成二维数组

int[][] array2=new int[sparse[0][0]][sparse[0][1]];
for(int i=1;i<sparse.length;i++){
 ? ? ? array2[sparse[i][0]][sparse[i][1]]=sparse[i][2];
}
for(int[] nums:array2) {
            for(int b:nums) {
                System.out.print(b+" ");
            }
            System.out.println();
        }

运行结果如下：

封装

高内聚，低耦合

private属性私有，在其他类中不能直接使用
```
private String name;
private int age;
```

在其他类中调用时，要提供一些public的get,set方法

提供get,set方法

public String getName(){ //get获得这个数据
 ? ?return this.name;
}
public void setName(){ //set给这个数据设值
 ? ?this.name=name;
}

在其他类中调用

Student s1=new Student();
s1.setName("喜羊羊");
System.out.println(s1.getName());

封装的作用

提高程序的安全性，保护数据；
隐藏代码的实现细节；
统一接口；
系统的可维护性增加了。

继承

Java中类只有单继承，没有多继承；
super
1. super调用父类的构造方法，必须在构造方法的第一个；
2. super只能出现在子类的方法或者构造方法中；
3. super和this不能同时调用构造方法（与类名相同的方法）。
super VS this
1. 代表的对象不同：this本身调用这个对象
  
  super代表父类对象的应用
2. 前提：this没有继承也可以使用
  
  super只能在继承条件下使用
3. 构造方法：this() 本类的构造
  
  super() 父类的构造
  
  父类
```
public class Person{
 ? ?public void print(){
 ? ? ? ?System.out.println("Person");
 ?  }
}
```
  子类
```
public class Student extends Person{
 ? ?public void print(){
 ? ? ? ?System.out.println("Student");
 ?  }
 ? ?public void test1(){
 ? ? ? ?print(); //Student
 ? ? ? ?this.print(); //Student
 ? ? ? ?super.print(); //Person
 ?  }
}
```
  测试类
```
public class Application{
 ? ?public static void main(String[] args){
 ? ? ? ?Student s1=new Student();
 ? ? ? ?s1.test1();
 ?  }
}
```
方法重写

前提：需要有继承关系，子类重写父类的方法。

静态方法：方法的调用只和左边定义的数据类型有关。

非静态方法：重写
1. 方法名必须相同；
2. 参数列表必须相同；
3. 修饰符：范围可以扩大但不能缩小
4. 抛出异常：范围可以缩小但不能扩大