别再只会new！Java进阶基础3个高频点，新手秒懂

进阶不用死磕复杂概念，这3个基础延伸点，日常开发天天用、面试次次问，附简洁代码，看完就能上手～

一、 值传递vs引用传递：Java到底传啥？

✅核心结论：Java只有值传递！引用类型传的是「引用地址值」

✅关键区分：基本类型传副本，引用类型传地址，改内容≠改地址

public class PassDemo {
    // 1. 基本类型：传副本，原值不变
    public static void changeInt(int a) {a = 100;}
    
    // 2. 引用类型：传地址，能改内容，改不了地址
    public static void changeArr(int[] arr) {
        arr[0] = 999; // 改内容生效
        arr = new int[]{1,2}; // 改地址无效
    }

    public static void main(String[] args) {
        int num = 10;
        changeInt(num);
        System.out.println(num); // 输出10，原值不变
        
        int[] arr = {10,20};
        changeArr(arr);
        System.out.println(arr[0]); // 输出999，内容变了
    }
}

 

二、 单例模式：保证全局只有一个对象

✅核心场景：工具类、配置类，避免重复创建浪费资源

✅极简实现：饿汉式（简单安全，加载就创建）

// 饿汉式单例，新手首选
public class SingleInstance {
    // 1. 私有静态实例，类加载就创建
    private static final SingleInstance INSTANCE = new SingleInstance();
    
    // 2. 私有构造，禁止外部new
    private SingleInstance(){}
    
    // 3. 公共静态方法，获取唯一实例
    public static SingleInstance getInstance(){
        return INSTANCE;
    }

    public void say(){
        System.out.println("全局唯一实例");
    }

    public static void main(String[] args) {
        SingleInstance s1 = SingleInstance.getInstance();
        SingleInstance s2 = SingleInstance.getInstance();
        System.out.println(s1 == s2); // true，同一个对象
    }
}

 

三、 内部类：藏在类里的“专属助手”

✅核心优势：能直接访问外部类私有成员，实现代码封装

✅常用场景：成员内部类（依赖外部对象）

// 外部类
public class OuterClass {
    private String msg = "内部类能直接拿我";

    // 成员内部类
    public class InnerClass {
        public void show(){
            // 直接访问外部类私有属性
            System.out.println(msg); 
        }
    }

    public static void main(String[] args) {
        // 创建内部类：外部对象.new 内部类()
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.show(); // 输出：内部类能直接拿我
    }
}

 

✅总结

1. Java只有值传递，引用传的是地址值

2. 饿汉式单例简单安全，新手优先用

3. 内部类可直接访问外部类私有成员