JAVA SE 杂论

概念:
    1.构造函数    //方法与类名相同，无返回值
        class Demo{
            public Demo(){
            }
        }
        在 new 此类对象时，执行构造函数
    2.构造函数块    //无方法名，返回值，先于构造函数运行
        又称代码块，每次new 运行一次
        class Demo{
            public{
            }
        }
        class Demo{
            {}
        }
    3.重载    //方法与类名相同，无返回值，参数不同的方法
        class Demo{
            public Demo(){
            }
            public Demo(int i){
            }
            public Demo(String str){
            }
        }
    4.递归        //函数自己调用自己
    5.外部类名.内部类名 名字 = new 外部类名().new 内部类名);        //其他类引用内部类名时
    6.哈希值        //内存地址
    7.哈希表
        //存放内存地址的表，以地址的值为顺序，当存放地相同但对象不同时，在此地址下开一空间存放相同地的对象
    8.静态     //会在上一级运行时直接在物理内存中使用一个位置
        8.1.静态代码块，在虚拟机运行时就会加载，而且只会加一次
            class Demo{
                static{
                }
            }
        8.2.静态方法
            在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。
            而实例方法只有"对象名.方法名"。也就是说，调用静态方法可以无需创建对象。
            静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），
            而不允许访问实例成员变量和实例方法；实例方法则无此限制。
            public static void demo{}
    9.没有提供构造方法
        9.1.说明不能 new 对象，能想到该类中方法都是静态的
        9.2.发现该类中还有非静态方法
        9.3.说明该类肯定会提供方法获取本类对象，而且该方法是静态的，并返回类型是本类型
    10字段
        类名.方法         //字段的使用
        字段内的方法都为静态
    11.文件
        无法访问隐藏文件
        删除时直接删除，不经过回收站
    12.反射
        通过一个类名来探察这个类里面的信息，
            比如说类的属性名，属性名的修饰符，方法名，方法返回值，方法修饰符等等，
            反正除了方法体得不到，其他都可以用反射得到；
            反射还可以生成类的实例，通过这个实例定义属性，调用方法，
            特别是能调用私有的属性和私有的方法。

符号
    1.(a==b)?a:b; 等同于 if(a==b){a}else{b}
    2.&&    //与
    3.||    //或
    4.!    //非
    5.>>    //将数字转为二进制右移？位
            不带符号
            int的宽度为32位
            8：
            0000 0000 0000 0000 0000 0000 0000 1000
            8>>1
            0000 0000 0000 0000 0000 0000 0000 0100 十进制为4
            i >> n :     i / (2^n)
        >>>    //将数字转为二进制右移？位
            带符号右移
            -7：
            1111 1111 1111 1111 1111 1111 1111 1001
            -7>>>1：
            0111 1111 1111 1111 1111 1111 1111 1100 十进制为214748364
    6.<<    //将数字转为二进制左移
            i<<n:   i * (2^n)
        <<<    //带符号左移

描述
    abstract      //抽象   //无具体描述
    static         //静态   //函数一运行就存在于内存中
    instanceof     //判断类型      if(i instanceof int) //i类型是否为int
    implements      //实现，连接接口，(某函数实现接口)
    interface    //接口，描述类，里面方法全是抽象，开放。变量全是开放，静态，常量
    protected    //访问范围是子类
    private        //只能是本类
    public        //可以是子类，同一个包中都可以访问。

泛型
        //JDK1.5版本以后出现新特性，用于解决安全问题，是一个安全机制
        在集合中比较常见
        ArryList<String> al = new ArrayList<String>();
    1.<类型>    //指定输入元素类型
        <String>    //指定输入元素String类型
        <?>    //不明确具体类型,占位符与<T>效果类似
    2.好处
        将运行时期出现的问题ClassCastException,转移到编译时期，方便与程序员解决问题
        避免强制转换麻烦
    3.泛型类
        什么时候定义泛型类？
        当类中要操作的引用数据类型不确定的时候,由引用方来定义类型
        早期定义的Object来完成扩展
        现在定义泛型类来完成扩展
        class Utiles<QQ>{        //QQ为自定义泛型
            private QQ q;        
            public void setObject(QQ q){
                this.q = q;
            }
            public QQ getObject(){
                return q;
            }
        }
        Utils<Student> stu = new Utils<Student>();    //自定义学生类型
            但明确类型后下面方法只能是这个类型，否则只能在新建一个类
    4.泛型方法
            自由度比泛型方法高
            class Demo{
                public <T> void show(T t){
                }
                public <Q> void print(Q q){
                }
            }
            Demo d = new Demo();
            d.show("haha");
            d.show(new Integer(4));
            d.print("Heihei");
        静态方法泛型
            静态方法泛型不可以访问类上定义的泛型
            如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上
            class Demo<T>{
                public static <w> void show(T t){
                }
            }
    5.泛型的限定
        ? 通配符，也可以理解为占位符
        ? extends E： 可以接收E类型或者E的子类型，上限
        ? super E： 可以接收E类型或者E的父类型，下限
        
        public static void printColl(ArrayList<? extends E> all){}
        public static void printColl(ArrayList<? super E> all){}

 

异常
    java.lang.Throwable
            java.lang.Object
              java.lang.Throwable
            异常所在类，包
        Exception    //异常
            RuntimeException    //执行异常
                ClassCastExcepion    //类型转换异常
            CheckedException    //检查异常
                除了runtimeException以外的异常，
            IOException         //I/O 异常
                FileNotFoundException
            方法
                printStackTrace        //输出异常信息
                    try{}
                    catch( Exception e ){
                        e.printStackTrace(System.out)}       //在控制台输出错误信息
                        e.printStackTrace(new printStream("demo.txt"));} //将错误信息传入demo.txt文件内  
    将编译时异常转为运行时异常
        throw new RuntimeException(e)
    处理异常
        try{}
            catch( Exception e ){}
    抛出异常
        throw new RuntimeException("***")        //抛异常

 

特殊
    ...      //可变参数
        public void demo(int... arr){       //使用方式，int 可以为任意类型
            System.out.println(arr.length);        //返回数组长度
        }        
        例如：
        demo(1,2,3,4);     demo();
        demo(12345,123,42,13);  //可以传入任意长度的 int 类型值
        不可以:      public void demo(int... arr, String str){}   //error
        可以:        public void demo(String str, int... arr){}

测试
    junit
        @Before 在方法上添加，每次运行@Test 先运行@Before
        @BeforeClass 在方法上添加，每次运行Junit 先运行@BeforeClass
        @Test 在方法上添加，成为测试方法
        @After 在方法上添加，每次运行@Test 后运行@After
        @AfterClass 在方法上添加，每次运行 junit 后运行@AfterClass