「持续100 天更新 Java 相关面试题」—

本文链接：https://blog.csdn.net/qq_53655497/article/details/128314284

文章目录

前言
正文

前言

今天是更新第 4 天，今天的主要内容还是 Java基础

正文

1. String、StringBuffer、StringBuilder 区别

String：不可变字符序列，效率低，复用率高。

// 底层
private final char value[];

StringBuffer：可变字符序列，可以对字符串内容进行增删，线程安全，效率较高。

// 底层
private transient char[] toStringCache;

StringBuilder：可变字符序列，方法和 StringBuffer 类似，线程不安全，效率最高。

// 底层 extends AbstractStringBuilder
char[] value;

2. public、protected、default、private的区别

修饰类（两个）

default：默认，什么都不写
public：公开的

修饰类的成员方法和属性（四个）

public：公开的
protected：受保护的
default：默认，即什么都不写
private：私有的

访问修饰符的访问范围

访问修饰符	对于同一个类	对于同一个包	对于子类	对于不同包
public	可见	可见	可见	可见
protected	可见	可见	可见	不可见
default	可见	可见	不可见	不可见
private	可见	不可见	不可见	不可见

3. 内部类

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class),嵌套其他类的类称为外部类(outer class)。

// 外部类
class Outer {
    // 内部类
	class Inner {
    }
}

// 外部其他类
class Other {

}

定义在外部类局部位置上(比如方法内):

局部内部类（有类名)
匿名内部类(没有类名)

定义在外部类的成员位置上:

成员内部类（没用static修饰)
静态内部类（使用static修饰)

局部内部类：

定义在方法中的类，就是局部内部类。如果一个类只在某个方法中使用，则可以考虑使用局部内部类。

public class Main {

    private int a;
    private int b;

    public void test(int c) {

        class Inner {
            public void print() {
                System.out.println(c);
            }
        }

    }
    
}

可以直接访问外部类的所有成员。
不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用 final 修饰。
作用域：仅仅在定义它的方法或代码块中。
外部类访问内部类的成员：需要创建对象才能访问。

匿名内部类：

匿名内部类直接使用 new 来生成一个对象的引用。

class Bird {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int fly() {
        return 0;
    }
}
public class Main {
    public static void test(Bird bird){
        System.out.println(bird.getName() + "能够飞 " + bird.fly() + " 米");
    }
    public static void main(String[] args) {

        test(new Bird() {
            @Override
            public int fly() {
                return 10000;
            }
            @Override
            public String getName() {
                return "鸽子";
            }
        }); // 鸽子能够飞 10000 米
    }
}

成员内部类：

定义在类内部的非静态类，就是成员内部类。成员内部类不能定义静态方法和变量。这是因为成员内部类是非静态的，类初始化的时候先初始化静态成员，如果允许成员内部类定义静态变量，那么成员内部类的静态变量初始化顺序是有歧义的。

public class Out {
    private int a;
    private int b;
    
    public class Inner {
        public void print() {
            System.out.println(a);
            System.out.println(b);
        }
    }
}

可以直接访问外部类的所有成员。
可以添加访问修饰符。
作用域：外部类内部（整个类体）。
可以直接访问外部类成员。
外部类访问内部类的成员：需要创建对象才能访问。

静态内部类：

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

public class Out {
    private static int a;
    private int b;
    
    public static class Inner {
        public void print() {
            System.out.println(a);
        }
    }
}