java不常用但要知道的操作（持续更新）

生成javadoc

1. 通过命令 cmd 进入到类的路径，然后执行下面的命令 javadoc -encoding  UTF-8  -charset  UTF-8 XXX.java 
2. 或者集成开发环境IDEA 中在工具栏中找到 tool >> Generate JAVADoc…

较大的数字可以通过下划线隔开

int money = 1_0000_0000;
long cash =100_0000_0000L;

方法的可变参数

public static void main(String[] args) {
        int res = max(1,2,3,4,5,6,7,22,11);
        System.out.println("最大值为："+res);
    }
​
    public static int max(int... nums){
        int max=0;
        if(nums.length==0){
            return  0;
        }else{
            max= nums[0];
            for(int i=0;i<nums.length;i++){
                if(nums[i]>max){
                    max=nums[i];
                }
            }
            return max;
        }
    }

注意事项：

1. 只能存在一个可变参数，并且在最后面

2. 格式 参数类型+... +参数名称

3. 可变参数都是同类型的，传参的时候要注意这点

for循环中可以定义多个变量

演示场景：数组反转

public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
​
        int [] array_reverse = new int [array.length];
        for (int i=0, j=array.length-1; i<array.length;i++,j--){
            array_reverse[j]=array[i];
        }
        System.out.println(Arrays.toString(array_reverse));
​
    }

子类继承父类 重写方法

1. 方法如果有异常，范围可以缩小但不能扩大；

2. 方法的修饰符，范围可以扩大但不能缩小；

3. 重新的方法都是非静态的方法

内部类 

就是在一个类的内部再定义一个类，有四种类型：

• 成员内部类

public class Outer {
    private String name="liuyishou";

    public void run(){
        System.out.println("奔跑...");
    }

    public class Inner{
        // 可以获取私有的属性或方法
        public String getInnerName(){
            return name;
        }
        
        public void doRun(){
            run();
        }
    }
}

• 静态内部类

public class Outer {
    private String name="liuyishou";

    public void run(){
        System.out.println("奔跑...");
    }

    public static class Inner{
        // 静态的不能访问非静态的属性和方法
    }
}

• 局部内部类

public class Outer {
    private String name="liuyishou";

    public void run(){
        // 局部内部类
        class Inner {
            
        }
    }
}

• 匿名内部类

public class Outer {
    public static void main(String[] args) {
        // 匿名内部类
        new Inner().run();
    }
}
// 一个class文件里面只能有一个public class
class Inner {
    public void run() {
        System.out.println("跑起来...");
    }
}

Callable实现多线程的好处

• 有返回值
• 可以抛出异常

JUC包下面两种计数器的简单实例（CountDownLatch、CyclicBarrier）

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"-> leave");
                // 每调用一次 数量减1，为0时，await 被唤醒
                countDownLatch.countDown();
            },Integer.toString(i)).start();

        }
        // 等待计数器归0 唤醒线程，执行后面的代码逻辑
        countDownLatch.await();
        System.out.println("都走了");
    }
}

public class CyclicBarrierTest {
	public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
		CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
			System.out.println("召唤神龙~~");
		});

        for (int i = 1; i <= 7; i++) {
            final int temp =i;
            new Thread(()->{
                try {
                    System.out.println("集齐第"+temp+" 颗龙珠");
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }

	}


}