卷起来🐎🐲💪 -- Java基础

Posted on:March 23, 2023 at 07:56 PM
Share on

工作十年也许都不知道的 Java 基础。

Table of contents

Open Table of contents

访问修饰符 public,private,protected,以及不写（默认）时的 区别

Java 中，可以使用访问修饰符来保护对类、变量、方法和构造方法的访 问。Java 支持 4 种不同的访问权限。

访问修饰符：

修饰符当前类同包之类其他包
private✅❌❌❌
default✅✅❌❌
protected✅✅✅❌
public✅✅✅✅

final finally finalize 区别

static 存在的主要意义

static 应用场景

因为 static 是被类的实例对象所共享，因此如果某个成员变量是被所有对象所共享的，那么这个成员变量 就应该定义为静态变量。 因此比较常见的 static 应用场景有：

  1. 修饰成员变量
  2. 修饰成员方法
  3. 静态代码块
  4. 修饰类【只能修饰内部类也就是静态内部类】
  5. 静态导包

static 注意事项

  1. 静态只能访问静态。
  2. 非静态既可以访问非静态的，也可以访问静态的。

多态的实现

Java 实现多态有三个必要条件：继承、重写、向上转型。

只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现 代码处理不同的对象， 从而达到执行不同的行为。

抽象类和接口的对比

抽象类是用来捕捉子类的通用特性的。接口是抽象方法的集合。 从设计层面来说，抽象类是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。

接口的字段默认都是 static 和 final 的。

抽象类能使用 final 修饰吗？

不能，定义抽象类就是让其他类继承的，如果定义为 final 该类就不能被继承， 这样彼此就会产生矛 盾，所以 final 不能修饰抽象类

Java8 中接口中引入默认方法和静态方法，以此来减少抽象类和接口之间 的差异。 现在，我们可以为接口提供默认实现的方法了，并且不用强制子类来实现它。 接口和抽象类各有优缺 点，在接口和抽象类的选择上，必须遵守这样一个原则：

成员变量与局部变量的区别有哪些

在 Java 中定义一个不做事且没有参数的构造方法的作用

Java 程序在执行子类的构造方法之前，如果没有用 super()来调用父类特定的构 造方法，则会调用父类中 “没有参数的构造方法”。因此，如果父类中只定义了 有参数的构造方法，而在子类的构造方法中又没有 用 super()来调用父类中特定 的构造方法，则编译时将发生错误，因为 Java 程序在父类中找不到没有参数 的构 造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。

在调用子类构造方法之前会先调用父类没有参数的构造方法，其目的是？

帮助子类做初始化工作。

内部类

内部类可以分为四种：成员内部类、局部内部类、匿名内部类和静态内部类。

静态内部类

定义在类内部的静态类，就是静态内部类。

public class Outer{
        private static int radius = 1;
        static class StaticInner {
                public void visit(){
                        System.out.println('visit outer static variable:' + radius);
                }
        }
}

静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量； 静态内部类的创建方 式，new 外部类.静态内部类()，如下：

Outer.StaticInner inner = new Outer.StaticInner();
inner.visit();

成员内部类

定义在类内部，成员位置上的非静态类，就是成员内部类。

public class Outer {
    private static int radius = 1;
    private int count = 2;

    class Inner {
        public void visit(){
            System.out.println("visit outer static variable:" + radius);
            System.out.println("visit outer variable:" + count);
        }
    }
}

成员内部类可以访问外部类所有的变量和方法，包括静态和非静态，私有和公 有。成员内部类依赖于外 部类的实例，它的创建方式外部类实例.new 内部类()，如 下：

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.visit();

局部内部类

定义在方法中的内部类，就是局部内部类


public class Outer {
    private static int static_a = 1;
    private int out_a = 2;

    public void testFunctionClass() {
        int inner_a = 3;
        class Inner {
            private void fun() {
                System.out.println(out_a);
                System.out.println(static_a);
                System.out.println(inner_a);
            }
        }
        Inner inner = new Inner();
        inner.fun();
    }

    public static void testStaticFunctionClass() {
        int inner_b = 4;
        class Inner {
            private void fun() {
                //System.out.println(out_a); 编译错误，定义在静态方法中的局部类不可以访问外部类的实例变量
                System.out.println(static_a);
                System.out.println(inner_b);
            }
        }
        Inner inner = new Inner();
        inner.fun();
    }

}

定义在实例方法中的局部类可以访问外部类的所有变量和方法，定义在静态方法 中的局部类只能访问外 部类的静态变量和方法。局部内部类的创建方式，在对应 方法内，new 内部类()，如下：

public void testFunctionClass() {
    int inner_a = 3;
    class Inner {
        private void fun() {
            System.out.println(out_a);
            System.out.println(static_a);
            System.out.println(inner_a);
        }
    }
    Inner inner = new Inner();
    inner.fun();
}

匿名内部类

匿名内部类就是没有名字的内部类，日常开发中使用的比较多。


public class Outer {

    public void test(final int i) {
        new Service() {
            public void method() {
                for (int j = 0; j < i; j++) {
                    System.out.println("匿名内部类");
                }
            }
        }.method();
    }

    // 匿名内部类必须继承或实现一个已有的接口
    interface Service {
        void method();
    }
}

除了没有名字，匿名内部类还有以下特点：

内部类的优点

我们为什么要使用内部类呢？因为它有以下优点：

局部内部类和匿名内部类访问局部变量的时候，为什么变量必须要加上 final？

是因为生命周期不一致， 局部变量直接存储在栈中，当方法执行结束后，非 final 的局部变量就被销毁。而局部内部类对局部变量的引用依然存在，如果局部内部类要调用局部变量时，就会出错。加了 final， 可以确保局部内部类使用的变量与外层的局部变量区分开，解决了这个问题。 反编译后可以看到，外部类以及被访问的局部变量会通过构造函数传进去，对于局部变量，内部类使用的引用和外部类使用的并不是同一个，而如果局部变量不是 final 的话，当其中一方对其重新赋值就会导致内部类和外部类的数据不同步。

public class Outer {
    private Integer b = 3;
    void outMethod(int h) {
        int a = 10;

        class Inner {
            void innerMethod() {
                System.out.println(h);
                System.out.println(b);
                System.out.println(a);
            }
        }
        //a = 100; 不修改编译运行都正常
        //h = 100; 不修改编译运行都正常
        Inner i = new Inner();
        i.innerMethod();
    }
}
Share on