菜鸟升级日记8

面向对象

稀疏数组

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

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

稀疏数组的代码实现

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

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. 抛出异常：范围可以缩小但不能扩大

方法实现重现时

方法未实现重写时

_____________________________________________________________________________

又断更了好长时间，今天刚去学校报道完，忙了好久。

刚进寝室，就看见我的床帘塌了，不过幸运的是，没有发现发霉现象。

感觉这个学期会开始忙起来了，自己要改变的地方也很多，而且要在短时间内——坚持健身、不要过于在意别人的眼光和想法、自律等等，努力让自己再次发光吧！