Blog阅读，面向对象基础

package pack;

import java.util.Arrays;

import static java.lang.System.out;

public class Ans {
    public static void main(String[] args) {
        test1();
        test2();
        test5();
        test10();
    }

    static void test1() {
        func1(null);                     //这里直接是一个null
        func1((Integer) null);                   //这里是含有一个null的数组
        func1();                                 //空数组
    }
    static void func1(Integer...arg) {          //对于可变参数的补充
        System.out.println(Arrays.toString(arg));
    }

    static void test2() {                       //instanceof 相关
        class A {}
        class B extends A {void x() {}}
        A a = new A();
        A b = new B();
        B n = null;
        System.out.println(a instanceof B);
        System.out.println(b instanceof B);
        System.out.println(n instanceof B);             //前两个没啥说的，这里说明null instanceof..不论如何都是false

        A b2 = new B();
        if (b2 instanceof B)
            //! b2.x();                                 //这是java SE14的一个新特性，instanceof B为true 后直接将b2转为B，但目前14还没有上线，预计在3月份
            //使用instanceof variable这种判断并转型为指定类型变量的语法时，必须打开编译器开关--source 14和--enable-preview。
            ((B) b2).x();
    }

    static void test3() {
        //这一节没有代码，要注意几个事情：java中final修饰的方法不能被重写，但是可以被继承，final方法要快于非final方法，因为在编译时已经静态绑定
        //第二，java中const和goto一样是预留关键字，以后可能会用上
        //第三，一个个人理解，多态这个东西其实是为其上层提供了一个接口，这样上层使用时可以不管底层实现细节而直接使用接口
    }

    static void test4() {
        //同样没有代码，主要给出面向抽象的定义
        //使用抽象类规定功能，我认为这样做可以使功能与实现完全分离，我们甚至不需要一个具体的类就可以定义所有功能，这与接口非常相似
    }

    public interface A {
        default void a() {System.out.println("aaa");}
        static void b() {System.out.println("bbb");}
    }
    static void test5() {
        //接口比抽象类更为抽象，其持有的属性默认为static public的

        //我们发现不能在方法中定义接口，这一点与class不同
        //在java SE8引入了interface 中的default和static方法，默认为public，不可为private与protected（是不是意味着就是public了，怎么显示的改变为包权限？？）
        //default为可以不重写的方法，当然实现接口的类也可以重写此方法
        class B implements A {}
        A b = new B();
        b.a();
        //! b.b();          //static 方法不能由实例调用，只能由接口名调用
        A.b();
    }

    static void test6() {
        //在使用静态方法或静态属性时最好不要使用[变量名.静态名]，因为变量不持有静态信息，我们能够这样使用是因为在调用时编译器将[变量名.静态名]转换为[类名.静态名]，所以建议直接使用[类名.静态名]
    }

    static void test7() {
        //我们不推荐使用import *这种做法，因为当引入很多这样的包时，会很难辨别一个类属于哪个包
        //java SE5 引入import static 这种做法
        out.println("import static");       //我们在代码的最开头使用了import java.util.Arrays

        //当使用一个class名称时，编译器的动作：
        //如果是完整类名，就直接根据完整类名查找这个class；
        //如果是简单类名，按下面的顺序依次查找：
        //  查找当前package是否存在这个class；
        //  查找import的包是否包含这个class；
        //  查找java.lang包是否包含这个class。

        //编写代码时编译器会帮助我们：
        // 默认自动import当前package的其他class；
        //默认自动import java.lang.*。
    }

    static void test8() {
        //我们认为应当把public方法写在最前面，因为它们是用户使用的接口，用户应当最先了解它们

        //如果不确定是否需要public，就不声明为public，即尽可能少地暴露对外的字段和方法。(保证封装性)
        //把方法定义为package权限有助于测试，因为测试类和被测试类只要位于同一个package，测试代码就可以访问被测试类的package权限方法。
    }

    static void test9() {
        //有关jar：https://www.liaoxuefeng.com/wiki/1252599548343744/1260466914339296
    }

    static void test10() {
        //java SE9 添加了特性module，为了将没有引入相关jar的运行时classCastException提前到编译时，同时增加了代码的封装性
        //如果出现kotlin error可以rebuild解决
        //详情请见：https://www.liaoxuefeng.com/wiki/1252599548343744/1281795926523938
        //关于打包jar请见：https://blog.csdn.net/dominic_z/article/details/82791790
        //相关其他包的代码会贴在底下
        module.Test t = new module.Test();
        t.a();                      //我们在module-info.java中requires了ModuleTest，在ModuleTest的module-info.java exports了module包，所以可以调用
    }
}

blog_test.module-info.java:

module blog.test {
    requires ModuleTest;
}

ModuleTest:

package module;

public class Test {
    public static void main(String[] args) {

    }
    public void a() {System.out.println("Module!!!!!");}
}

ModuleTest.module-info.java

module ModuleTest {
    exports module;
}

总之收获很大！！！！！！