01-java-basic

1. final

  • final变量：修饰的成员变量、局部变量，为常量，不能再次赋值。常和static一起用
  • final方法：子类不可重写 @Override
  • final类：类通常是功能完整的，不能被继承。eg：String, Integer
  1. 必须在声明时、构造器中初始化，否则报编译错误
  2. 接口中，所有变量本身是final
  3. 匿名类中，所有变量都必须final
  4. final、abstract这两个关键字是反相关的，final类就不可能是abstract
  5. 声明时未初始化的final变量，称为空白final变量（blank final variable），必须在构造器中初始化，或者调用this()初始化，否则，编译器会报错
  6. Java编码规范，final变量就是常量，而且通常常量名要大写
  7. 引用对象声明为final，指的是引用不能被更改

2. 权限修饰符

  1. private：当前类
  2. default：当前包
  3. protected：当前包，及其他包子类
  4. public：所有包，所有类

1. protected

package a;

public class Father {
    private String a;
    String b;
    protected String c;
    public String d;
}

package a;

public class A extends Father {

    @Test
    public void ooxx() {
        // String a = this.a;
        String b = this.b;
        String c = this.c;
        String d = this.d;
    }
}

class T1 {
    public static void main(String[] args) {
        A a = new A();
        String a_b = a.b;
        String a_c = a.c;
        String a_d = a.d;

        B b = new B();
        String b_c = b.c; // 和Father.c处于一个pkg
        String b_d = b.d;
    }
}

package b;

public class B extends Father {

    @Test
    public void ooxx() {
        // String a = this.a;
        // String b = this.b;
        String c = this.c;
        String d = this.d;
    }
}

class T2 extends Father {

    @Test
    public void ooxx() {
        A a = new A();
        // String a_c = a.c;
        String a_d = a.d;


        B b = new B();
        // String b_c = b.c;
        String b_d = b.d;

        // Father子类
        String T2_c = this.c;
    }
}

3. InnerClass

1. 概念

  1. 外部类：只能public和default
  2. 内部类：public、protected、default、private

2. 成员内部类

  • 仍然是一个独立的类，会被编译成独立的.class文件，前面冠以外部类的类名和$符号
  1. 在外部类的静态方法和外部类以外的其他类中，必须通过new Outer().new Inner()
public class Outer {
    class Inner1 {
    }

    Inner1 i = new Inner1();                    // 不需要创建外部类实例

    public void method1() {
        Inner1 i = new Inner1();                // 不需要创建外部类实例
    }

    public static void method2() {
        Inner1 i = new Outer().new Inner1();    // 需要创建外部类实例
    }

    class Inner2 {
        Inner1 i = new Inner1();                // 不需要创建外部类实例
    }
}

class OtherClass {
    Outer.Inner1 i = new Outer().new Inner1();    // 需要创建外部类实例
}











 








 

  1. Inner可以访问Outer所有成员
  2. Outer要访问成员内部类的成员，必须先创建Inner的对象
public class Outer {
    public int a = 100;
    static int b = 100;
    final int c = 100;
    private int d = 100;

    public String method1() {
        return "实例方法1";
    }

    public static String method2() {
        return "静态方法2";
    }

    class Inner {
        int a2 = a + 1;             // 访问public的a
        int b2 = b + 1;             // 访问static的b
        int c2 = c + 1;             // 访问final的c
        int d2 = d + 1;             // 访问private的d
        String str1 = method1();    // 访问实例方法method1
        String str2 = method2();    // 访问静态方法method2
    }

    public static void main(String[] args) {
        Inner i = new Outer().new Inner();  // 创建内部类实例
        System.out.println(i.a2);           // 输出101
        System.out.println(i.b2);           // 输出101
        System.out.println(i.c2);           // 输出101
        System.out.println(i.d2);           // 输出101
        System.out.println(i.str1);         // 输出实例方法1
        System.out.println(i.str2);         // 输出静态方法2
    }
}
  1. Outer与Inner包含有同名的成员
public class Outer {
    int a = 10;

    class Inner {
        int a = 20;
        int b1 = a;
        int b2 = this.a;
        int b3 = Outer.this.a; // 同名成员
    }

    public static void main(String[] args) {
        Inner i = new Outer().new Inner();
        System.out.println(i.b1); // 输出20
        System.out.println(i.b2); // 输出20
        System.out.println(i.b3); // 输出10
    }
}






 
 









  1. 实例内部类中不能定义static成员，除非同时使用final和static修饰

3. 静态内部类

  1. 在创建静态内部类的实例时，不需要创建外部类的实例
  2. 静态内部类中可以定义静态成员和实例成员
public class Outer {
    static class Inner {
        int a = 0;          // 实例变量a
        static int b = 0;   // 静态变量 b
    }
}
class OtherClass {
    Outer.Inner oi = new Outer.Inner();
    int a2 = oi.a;          // 访问实例成员
    int b2 = Outer.Inner.b; // 访问静态成员
}

public class Outer {
    int a = 0;          // 实例变量
    static int b = 0;   // 静态变量

    static class Inner {
        Outer o = new Outer;
        int a2 = o.a;   // 访问实例变量
        int b2 = b;     // 访问静态变量
    }
}

4. 局部内部类

  1. 局部内部类与局部变量一样，不能使用访问控制修饰符（public、private、protected）和static修饰符修饰
  2. 作用域只在当前方法中有效
  3. 局部内部类中不能定义static成员
  4. 局部内部类中还可以包含内部类，但是这些内部类也不能使用访问控制修饰符（public、private、protected）和static修饰符修饰
  5. 在局部内部类中可以访问外部类的所有成员
  6. 在局部内部类中只可以访问当前方法中final类型的参数与变量
public class Test {
    Inner i = new Inner();                      // 编译出错
    Test.Inner ti = new Test.Inner();           // 编译出错
    Test.Inner ti2 = new Test().new Inner();    // 编译出错
    public void method() {
      	// 局部内部类
        class Inner{
        }
        Inner i = new Inner();
    }
}






 
 
 


4. ArrayList

1. remove

如果ArrayList内装的是Integer对象，则.remove(8)是删掉下标为8的元素，.remove(Integer.valueOf(8))是删掉8这个元素

  • 查看源码，public E remove(int index)是ArrayList父类AbstractList方法
  • public boolean remove(Object o)是AbstractList父类AbstractCollection方法
image-20230912094522711

5. SLF4J