JavaSE部分干货总结

进制：

二进制0b，八进制0，十六进制0x

int i = 10 -------10进制 -------------------=10

int i1 = 010 --------8进制 ----------------=8

int i2 = 0x10------16进制 ----------------=16

浮点数：

float f = 0.1f; double d = 1.0/10;

虽然控制台输出打印f和d的值都为0.1，但是打印（f==d）为false；

float d1 = 231313123123312313f；

flloat d2 = d1+1；

控制台输出打印（d1==d2）为true

**以上原因================浮点数，有限且离散，所表示的值为大约值，（不能精确表示数值）所以避免浮点数进行比较，用BigDecmal类**

类型转换：

低-------------------------------------------------------------------高

byte，short，char–>int–>long–>float–>double

int i = 128;

byte b = (byte) i;

控制台打印 b 的值 为 -128 ，原因 128大于byte类型的大小（内存溢出）

JDK7 新特性，数字之间可以用下划线分隔

int i = 10_0000_0000;

幂运算

double pow = Math.pow(2, 3); //2的3次幂

位运算

System.out.println(2<<3);//2*8的快速算法 << *2   >> /2

加号（字符串拼接）

System.out.println(10+20+"");//这个值为30，先计算后拼接
System.out.println(""+10+20);//这个值为1020，先拼接，拼接后为字符串，接下来的加号为字符串拼接

可变参数

JDK1.5开始，在指定参数类型后加一个省略号（…）

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

int add(int...a);

稀疏数组

public abstract class Demo {
    public static void main(String[] args) {
        //创建一个数组11*11 原始数组
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效个数的值是："+sum);
        int[][] array2 = new int[sum+1][3];//创建稀疏数组
        array2[0][0] = array1.length;
        array2[0][1] = array1.length;
        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];
                }
            }
        }
        //输出稀疏数组
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
                    +array2[i][1]+"\t"
                    +array2[i][2]+"\t");
        }
        /************还原数组***************/
        //读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //还原值
        for (int i = 1; i < array2.length; i++) {
            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();
        }
    }
}

重写与重载

重载发生在本类，重写是发生在有继承关系的子类里，重写了父类的方法。

重载中方法名一样，参数不一样（类型，数量，顺序）与返回值无关；重写中方法名一样，参数一样，返回值必须一样或者是派生类，修饰符范围要大于等于父类，抛出的异常范围不能大于父类，方法体不同

静态导入包

import static java.lang.Math.random;
public abstract class Demo {
    public static void main(String[] args) {
        System.out.println(random());
    }
}

内部类

成员内部类

public class Out {
    private int id = 10;
    public class Inner{
        public void in(){
            System.out.println("内部类方法");
        }
        public void getId(){
            System.out.println(id);//内部类可获得外部类私有属性
        }
    }
}
class main{//调用内部类方式
    public static void main(String[] args) {
        Out out = new Out();
        Out.Inner inner = out.new Inner();
        inner.in();
    }
}

静态内部类

public class Out {
    private static int id = 10;
    public static class Inner{
        public void in(){
            System.out.println("内部类方法");
        }
        public void getId(){
            System.out.println(id);//内部类可获得外部类私有属性
        }
    }
}

局部内部类

public class Out {
    public void method(){
        class inner{

        }
    }
}

自定义异常类

public  class MyException extends Exception{
    private int detail;

    public MyException(int a) {
        this.detail=a;
    }

    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}

-----参考b站up主：遇见狂神说