Java笔记

记录一些今天学到的觉得比较重要的内容

记录一些东西，以后查笔记的时候也方便一点

Arrays 常用的方法

Arrays 需要导入 java.util.Arrays包，是一个对数组操作的工具类
两个常用方法:

  • public static String toString(数组)将参数数组变成字符串
  • public static void sort(数组)按照默认升序对数组的元素排序

实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int[] intArr = {10,20,30};
        String intStr = Arrays.toString(intArr);
        System.out.println(intStr);

        int[] arr1 = {2,3,5,1,6,1,2,9};
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));

        String[] arr2 = {"ddd","ccc","aaa","bbb"};
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));
    }
}

静态代码块

目前还不理解是什么，先记录下来

  • 首次用到本类时，静态代码块执行唯一一次
  • 静态代码块典型用途：用来一次性对静态成员变量进行赋值
1
2
3
4
5
6
7
8
public class demo {
    static {
        System.out.println("静态代码块执行！");
    }
    public static void person(){
        System.out.println("普通代码执行");
    }
}

数学方法

用起来很简单，直接调用就可以了

  • public static double abs(double num); 获取绝对值
  • public static double ceil(double num); 向上取整
  • public static double floor(double num); 向下取整
  • public static double long round(double num); 四舍五入

实例:

1
2
3
4
5
6
System.out.println(Math.abs(3.14));
System.out.println(Math.ceil(3.9));
System.out.println(Math.floor(3.2));
System.out.println(Math.round(4.4));

System.out.println(Math.PI); // 常数圆周率 π

父类、子类中变量重名

1
2
3
public class Dad { // 父类
    int num = 10;
}
1
2
3
4
5
6
7
8
9
public class Child extends Dad { //子类，继承了父类
    int num = 20;
    public void method(){
        int num = 30;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
}

结果是

1
2
3
30
20
10

不难理解，第一个num是局部变量，第二个num是本类的成员变量，第三个num是用super关键字继承父类的
super关键字就跟Python里的差不多，把父类的东西拿过来给自己用

继承关系中:

  1. 子类构造方法中默认含”super()”调用，所有先调用父类的构造方法，再子类构造方法
  2. 子类构造可以通过super关键字来调用父类的重载构造方法
  3. super的父类构造调用，必须是子类构造方法的第一个语句，不能一个子类构造调用多次super构造

子类必须调用父类构造方法，不写则赠送super(),写了则用指定的super调用，super只能有一个，而且必须是第一个

抽象类

类中有抽象方法，则这个类一定是抽象类，反之不一定
在抽象类中可以定义抽象方法，而这些方法必须在子类中实现
定义方法:

1
2
3
4
5
6
7
8
public abstract class Father {
    public abstract void func1();
    public abstract void func2();

    public void func3(){ //抽象类里既可以定义抽象方法，也可以定义普通方法

    }
}

子类实现:

1
2
3
4
5
6
7
8
9
10
11
public class Child extends Father{
    @Override
    public void func1(){

    }

    @Override
    public void func2(){
        
    }
}

@Override 表示重载方法，写不写都可以，但这是一个标识符，能加上最好

今天又学了新东西，没白忙活，还看了几篇博客，学了点新姿势，下次找机会玩一玩 :D