9,25日每周总结

1.重写

子类中一个方法名与父类中的一个方法名相同，形参也相同。
权限修饰符，返回值类型，抛出的异常全部复制父类的就可以了，方法体不同。
权限修饰符是子类的范围要大于父类的，
返回值类型就要分为几种情况，基本数据类型就写一样的，引用数据类型可以写一样的，也可以写他的子类。
抛出的异常可以写1一样的也可以写异常的子类。
！private修饰的方法不能被子类重写

2，多态

多态就是父类对象的引用指向子类对象。
Person p = new Student();
p可以调用父类的方法或者子类重写的方法，不能调子类特有的，但是可以向下转型。

3，运算的底层逻辑

十进制-》原码-》反码-》补码-》进行运算-》反码-》原码-》十进制
一些规则：正数的原码，反码，补码都是一样的
负数的原码-》反码是符号位不变，其他相反。
负数的反码-》补码是对反码加一就可以了

4，八大基本类型,

byte，short，int，long，float，double，char，boolean
byte：-128-127
char：0-65535

5，常见的运算

^:异或，相同的时候返回false，不同的时候返回true。
交换两数的值：
a=a^b;
b=a^b;
a=a^b;
&：与，同为true取true。
|：或，同false为false。
~：按位取反，连符号位都会取反
z>>:右移
<<:左移
a>>>:无符号右移：与与右移的区别：与符号位无关，右移后都是补0；

6，三元运算符

条件表达式？（表达式一）：（表达式二）；
为true：执行表达式一，为假执行表达式二。

7·代码块

局部代码块：定义在方法中的代码块，作用：减少内存浪费，因为定义一个变量i，会在}时被回收
构造代码块：定义在类中方法外的代码块，创建对象时会执行代码块，作用：可以将一些构造方法共性抽象出来放到构造代码块中，节省代码的编写，因为构造方法有时会有很多个
静态代码块：被static修饰的构造代码块，作用：做一些配置，只需要初始化数据一次，然后就可以一直使用的东西

8，#{}与${}

#{}：相当于占位符？，可以避免sql注入
?{}:字符串拼接，可能会发生sql注入

9，成员变量与局部变量

成员变量：定义在类中的变量，有初始值，在堆里，随对象消失而消失，在类中有效
局部变量：定义在方法内的变量，无初始值，在栈里，随方法消失而消失，在方法中有效

10，构造方法,

构造方法：无返回值，方法名与类名一样，有有参，有无参，系统开始默认送了你一个，写了有参，不送了

11，static

被static修饰的成员是随字节码文件对象的加载而加载，到方法区中中去，优先于对象的加载
被static修饰的成员被类下所有成员所共享
被static修饰的成员可以用过类名.直接调用
和静态有关的，三大特征都不能用了

12，final

成量分为字面值常量和自定义常量，自定义常量就是用final修饰的，不可以更改，所以一定要显示赋值或者用构造方法进行赋值，不然代码没意义了，所以在语法上不允许这么写，

13，抽象方法

有抽象方法的类一定是抽象类，
顾名思义：抽象方法就是很抽象的意思，就是方法中没有方法体，然后前面加个abstract就是抽象方法，不能创建对象，能继承他的类不是抽象类就是重写了他的所有抽象方法，
abstract不与paivate，static，final共存，语法上不允许

14，接口

什么是接口，就是比抽象方法还抽象的，interface，implements，
成员变量默认public static final

15.稀疏数组

需求，五子棋棋盘记录了很多没意义的数
稀疏数组的作用，把数组规模变小，起到优化的目的

开始是1111的变成33的，起到了代码的优化
思路：1，遍历二维数组，得到有效的sum值，
2，根据sum值就可以创建一个数组int[][] sparseArr=new sparseArr()[num+1][3]
3,将二维数组的有效数据存入稀疏数组
稀疏数组恢复为二维数组
1·先读稀疏数组的第一行，创建原始的二维数组，Arr2
2·在读后面几行的数据，并赋值给原始的二维数组
代码实现：

package xishushuzu;

public class SparseArray {
    public static void main(String[] args) {
        //第一步先建一个二维数组arr
        int[][] arr = new int[11][11];
        arr[1][2] = 1;
        arr[2][3] = 2;
        arr[3][4] = 3;
        int sum = 0;//遍历二维数组得到有效的数据个数sum
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j]!=0){
                    sum++;
                }
            }
        }
        //根据sum创建稀疏数组并将二维数组的数据存入稀疏数组
        int [][] sparseArray = new int[++sum][3];
        sparseArray[0][0] = 11;
        sparseArray[0][1] = 11;
        sparseArray[0][2] = sum;
        int num = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j]!=0){
                    num++;
                    sparseArray[num][0]=i;
                    sparseArray[num][1]=j;
                    sparseArray[num][2]=arr[i][j];
                }
            }
        }
        for (int i = 0; i < sparseArray.length; i++) {
            for (int j = 0; j < sparseArray[i].length; j++) {
                System.out.print(sparseArray[i][j]+"\t");
            }
            System.out.println();
        }
        //将稀疏数组转换为二维数组,稀疏数组第一行来构建数组结构
        //剩余行都是有值的行，直接遍历赋值
        int[][] arr2 = new int[sparseArray[0][0]][sparseArray[0][1]];
        for (int i = 1; i < sparseArray.length; i++) {
           arr2[sparseArray[i][0]][sparseArray[i][1]]=sparseArray[i][2];
        }
        for (int i = 0; i < arr2.length; i++) {
            for (int j = 0; j < arr2[i].length; j++) {
                System.out.print(arr2[i][j]+"\t");
            }
            System.out.println();
        }
    }
}