首页 编程相关 正文
我要发布

Java内部类：修仙界的"法宝内藏玄机"

编程相关
2025-12-12 0 795

Java内部类：修仙界的\”法宝内藏玄机\”

什么是内部类？体内的\”第二元神\”

想象一下，修仙者体内藏着一个\”本命飞剑\”——它属于你，但又相对独立。这就是内部类：定义在另一个类内部的类，就像体内修炼出的第二元神。

// 修仙者本体 - 外部类
public class Cultivator {
    private String name;
    private int cultivationLevel;
    
    // 本命法宝 - 内部类
    class InnerSword {
        private String swordName;
        private boolean isActivated;
        
        public InnerSword(String name) {
            this.swordName = name;
            this.isActivated = false;
        }
        
        public void activate() {
            if (cultivationLevel >= 3) { // 直接访问外部类的私有成员！
                isActivated = true;
                System.out.println(name + \"的本命飞剑\" + swordName + \"激活！\");
            }
        }
        
        public void displayStatus() {
            System.out.println(\"飞剑\" + swordName + \"状态：\" + 
                (isActivated ? \"已激活\" : \"未激活\"));
        }
    }
    
    public Cultivator(String name) {
        this.name = name;
        this.cultivationLevel = 1;
    }
    
    public void cultivate() {
        cultivationLevel++;
        System.out.println(name + \"修炼，境界提升至\" + cultivationLevel);
    }
    
    // 创建本命法宝的方法
    public InnerSword createInnerSword(String swordName) {
        return new InnerSword(swordName);
    }
}

内部类的四大类型：不同的\”修炼方式\”

1. 成员内部类：标准的\”本命法宝\”

// 外部类 - 修仙洞府
public class ImmortalCave {
    private String caveName;
    private int spiritualEnergy;
    
    // 成员内部类 - 洞府守护灵
    class GuardianSpirit {
        private String spiritName;
        private int powerLevel;
        
        public GuardianSpirit(String name) {
            this.spiritName = name;
            this.powerLevel = spiritualEnergy / 10; // 依赖外部类状态
        }
        
        public void protect() {
            System.out.println(spiritName + \"守护\" + caveName + \"洞府\");
            System.out.println(\"守护力量：\" + powerLevel);
        }
        
        // 内部类可以访问外部类的所有成员
        public void absorbEnergy() {
            powerLevel += spiritualEnergy / 5;
            spiritualEnergy -= 10;
            System.out.println(spiritName + \"吸收灵气，力量增强\");
        }
    }
    
    public ImmortalCave(String name, int energy) {
        this.caveName = name;
        this.spiritualEnergy = energy;
    }
    
    public GuardianSpirit summonGuardian(String name) {
        return new GuardianSpirit(name);
    }
    
    public void displayCaveInfo() {
        System.out.println(\"洞府：\" + caveName + \"，灵气：\" + spiritualEnergy);
    }
}

// 使用示例
public class CaveTest {
    public static void main(String[] args) {
        ImmortalCave cave = new ImmortalCave(\"紫霄洞\", 100);
        cave.displayCaveInfo();
        
        // 创建内部类对象
        ImmortalCave.GuardianSpirit spirit = cave.summonGuardian(\"青龙\");
        spirit.protect();
        spirit.absorbEnergy();
        
        cave.displayCaveInfo(); // 灵气减少了！
    }
}

2. 静态内部类：独立的\”护山法阵\”

// 修仙门派
public class Sect {
    private String sectName;
    private static String daoScripture = \"道德经\"; // 静态经典
    
    // 静态内部类 - 护山法阵（不依赖具体门派实例）
    static class ProtectionFormation {
        private String formationName;
        private static int formationCount = 0;
        
        public ProtectionFormation(String name) {
            this.formationName = name;
            formationCount++;
        }
        
        public void activate() {
            System.out.println(\"启动\" + formationName + \"法阵\");
            System.out.println(\"依据：\" + daoScripture); // 只能访问外部类的静态成员
            System.out.println(\"当前法阵数量：\" + formationCount);
        }
        
        // 静态方法
        public static int getTotalFormations() {
            return formationCount;
        }
    }
    
    public Sect(String name) {
        this.sectName = name;
    }
}

// 使用静态内部类（不需要外部类实例）
public class FormationTest {
    public static void main(String[] args) {
        // 直接创建静态内部类
        Sect.ProtectionFormation formation = new Sect.ProtectionFormation(\"九宫八卦阵\");
        formation.activate();
        
        // 访问静态内部类的静态方法
        System.out.println(\"总法阵数：\" + Sect.ProtectionFormation.getTotalFormations());
    }
}

3. 方法内部类：临时的\”符咒术\”

// 符咒大师
public class TalismanMaster {
    private String masterName;
    
    public TalismanMaster(String name) {
        this.masterName = name;
    }
    
    // 方法内部类 - 只能在方法内使用
    public void createTalisman(String target, String effect) {
        final int powerLevel = 5; // 必须是final或等效final
        
        // 方法内部类
        class Talisman {
            private String talismanName;
            private boolean isActivated;
            
            public Talisman(String name) {
                this.talismanName = name;
                this.isActivated = false;
            }
            
            public void activate() {
                if (powerLevel >= 3) { // 访问方法的final变量
                    isActivated = true;
                    System.out.println(masterName + \"激活\" + talismanName);
                    System.out.println(\"目标：\" + target + \"，效果：\" + effect);
                }
            }
        }
        
        // 在方法内创建和使用
        Talisman talisman = new Talisman(target + \"符\");
        talisman.activate();
    }
    
    public void batchCreateTalismans() {
        String[] targets = {\"驱邪\", \"招财\", \"护身\"};
        
        for (String target : targets) {
            // 每次循环都创建不同的内部类（概念上）
            createTalisman(target, \"灵验\");
        }
    }
}

4. 匿名内部类：一次性的\”召唤术\”

// 召唤术接口
interface Summoning {
    void summon();
    String getCreatureType();
}

// 召唤师
public class Summoner {
    private String summonerName;
    
    public Summoner(String name) {
        this.summonerName = name;
    }
    
    public void performSummoning(final String creatureName) {
        // 匿名内部类 - 一次性实现接口
        Summoning summoning = new Summoning() {
            private int manaCost = 10;
            
            @Override
            public void summon() {
                System.out.println(summonerName + \"召唤\" + creatureName + \"！\");
                System.out.println(\"消耗法力：\" + manaCost);
            }
            
            @Override
            public String getCreatureType() {
                return creatureName.contains(\"龙\") ? \"神兽\" : \"灵兽\";
            }
        };
        
        summoning.summon();
        System.out.println(\"生物类型：\" + summoning.getCreatureType());
    }
    
    // 更简洁的写法
    public void quickSummon() {
        new Summoning() {
            @Override
            public void summon() {
                System.out.println(\"快速召唤：天兵天将！\");
            }
            
            @Override
            public String getCreatureType() {
                return \"天界生物\";
            }
        }.summon(); // 直接调用
    }
}

// Java 8+ Lambda简化（适合只有一个方法的接口）
interface SimpleSummon {
    void invoke();
}

public class LambdaSummoner {
    public void modernSummoning() {
        SimpleSummon dragonSummon = () -> System.out.println(\"召唤神龙！\");
        dragonSummon.invoke();
        
        // 更简洁的写法
        ((SimpleSummon)() -> System.out.println(\"瞬间召唤！\")).invoke();
    }
}

内部类的特殊能力：修仙者的\”神通\”

1. 访问外部类私有成员

public class OuterClass {
    private String secret = \"修仙秘法\";
    private static String staticSecret = \"天道法则\";
    
    class InnerClass {
        public void revealSecret() {
            System.out.println(\"内部类知道秘密：\" + secret); // 直接访问
        }
    }
    
    static class StaticInnerClass {
        public void revealStaticSecret() {
            System.out.println(\"静态内部类知道：\" + staticSecret); // 只能访问静态的
            // System.out.println(secret); // 错误！不能访问非静态的
        }
    }
}

2. .this 和 .new 的妙用

public class MagicCircle {
    private String circleName = \"五行阵\";
    
    class ArrayInner {
        public void printOuterReference() {
            // 获取外部类的引用
            MagicCircle outer = MagicCircle.this;
            System.out.println(\"我属于：\" + outer.circleName);
        }
    }
    
    public void test() {
        ArrayInner inner = this.new ArrayInner(); // 显式创建
        inner.printOuterReference();
    }
}

// 外部创建内部类
public class ExternalTest {
    public static void main(String[] args) {
        MagicCircle circle = new MagicCircle();
        MagicCircle.ArrayInner inner = circle.new ArrayInner(); // 必须通过外部实例
        inner.printOuterReference();
    }
}

实战：完整的修仙系统

// 修仙系统完整示例
public class CultivationSystem {
    private String systemName;
    private List cultivators = new ArrayList();
    
    // 成员内部类 - 系统管理员
    class SystemAdmin {
        private String adminName;
        
        public SystemAdmin(String name) {
            this.adminName = name;
        }
        
        public void manageSystem() {
            System.out.println(adminName + \"管理\" + systemName);
            System.out.println(\"当前修仙者数量：\" + cultivators.size());
            
            // 可以操作外部类的私有集合
            for (Cultivator c : cultivators) {
                System.out.println(\"修仙者：\" + c.getName());
            }
        }
        
        public void addCultivator(String name) {
            cultivators.add(new Cultivator(name));
            System.out.println(\"新增修仙者：\" + name);
        }
    }
    
    // 静态内部类 - 系统统计
    static class SystemStats {
        private static int totalSystems = 0;
        private String statsType;
        
        public SystemStats(String type) {
            this.statsType = type;
            totalSystems++;
        }
        
        public void displayStats() {
            System.out.println(\"统计类型：\" + statsType);
            System.out.println(\"总系统数：\" + totalSystems);
        }
        
        public static void resetCount() {
            totalSystems = 0;
        }
    }
    
    public CultivationSystem(String name) {
        this.systemName = name;
    }
    
    // 方法中使用内部类
    public void initialize(final String adminName) {
        final int initPower = 100; // final变量
        
        class Initializer {
            public void setup() {
                System.out.println(\"初始化系统：\" + systemName);
                System.out.println(\"初始能量：\" + initPower);
                System.out.println(\"管理员：\" + adminName);
                
                // 创建管理员
                SystemAdmin admin = new SystemAdmin(adminName);
                admin.manageSystem();
            }
        }
        
        new Initializer().setup();
    }
    
    // 使用匿名内部类实现事件处理
    public void setupEventSystem() {
        // 事件处理器接口
        interface EventHandler {
            void handleEvent(String event);
        }
        
        // 匿名内部类实现
        EventHandler battleHandler = new EventHandler() {
            private int battleCount = 0;
            
            @Override
            public void handleEvent(String event) {
                battleCount++;
                System.out.println(\"处理事件：\" + event);
                System.out.println(\"累计战斗次数：\" + battleCount);
            }
        };
        
        battleHandler.handleEvent(\"宗门大战\");
        battleHandler.handleEvent(\"秘境探险\");
    }
    
    public static void main(String[] args) {
        CultivationSystem system = new CultivationSystem(\"仙界联盟\");
        
        // 测试各种内部类
        system.initialize(\"太上老君\");
        
        // 创建成员内部类
        CultivationSystem.SystemAdmin admin = system.new SystemAdmin(\"元始天尊\");
        admin.addCultivator(\"张三丰\");
        admin.addCultivator(\"吕洞宾\");
        admin.manageSystem();
        
        // 创建静态内部类
        CultivationSystem.SystemStats stats = new CultivationSystem.SystemStats(\"修仙统计\");
        stats.displayStats();
        
        // 测试事件系统
        system.setupEventSystem();
    }
}

// 修仙者类
class Cultivator {
    private String name;
    
    public Cultivator(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
}

吕洞宾的内部类心法

记住这几条修仙要诀：

  1. \”内外合一\”：内部类天然拥有访问外部类的能力
  2. \”静动有别\”：静态内部类独立，非静态的依赖实例
  3. \”临机应变\”：方法内部类和匿名内部类适合临时需求
  4. \”隐显自如\”：合理使用访问控制，保护内部实现

内部类就像修仙者的\”第二元神\”，藏在体内却威力无穷。用好了内部类，你的代码就能像修炼出元婴的仙人一样，内外兼修，神通广大！

收藏 (0) 打赏

感谢您的支持，我会继续努力的!

打开微信/支付宝扫一扫，即可进行扫码打赏哦，分享从这里开始，精彩与您同在
点赞 (0)

申明：本文由第三方发布，内容仅代表作者观点，与本网站无关。对本文以及其中全部或者部分内容的真实性、完整性、及时性本站不作任何保证或承诺，请读者仅作参考，并请自行核实相关内容。本网发布或转载文章出于传递更多信息之目的，并不意味着赞同其观点或证实其描述，也不代表本网对其真实性负责。

左子网 编程相关 Java内部类：修仙界的"法宝内藏玄机" https://www.zuozi.net/36049.html

Java线程池详解
上一篇： Java线程池详解
Apache Doris AI 能力揭秘（三）：AI_AGG 与 EMBED 函数深度解析
下一篇： Apache Doris AI 能力揭秘（三）：AI_AGG 与 EMBED 函数深度解析
常见问题

发货方式是什么？

  • 1、自动：拍下后，点击（下载）链接即可下载；2、手动：拍下后，联系卖家发放即可或者联系官方找开发者发货。
查看详情

交易周期是多久呢？

  • 1、源码默认交易周期：手动发货商品为1-3天，并且用户付款金额将会进入平台担保直到交易完成或者3-7天即可发放，如遇纠纷无限期延长收款金额直至纠纷解决或者退款！；
查看详情

能退款么？

  • 1、描述：源码描述(含标题)与实际源码不一致的（例：货不对板）； 2、演示：有演示站时，与实际源码小于95%一致的（但描述中有”不保证完全一样、有变化的可能性”类似显著声明的除外）； 3、发货：不发货可无理由退款； 4、安装：免费提供安装服务的源码但卖家不履行的； 5、收费：价格虚标，额外收取其他费用的（但描述中有显著声明或双方交易前有商定的除外）； 6、其他：如质量方面的硬性常规问题BUG等。 注：经核实符合上述任一，均支持退款，但卖家予以积极解决问题则除外。
查看详情

注意事项

  • 1、左子会对双方交易的过程及交易商品的快照进行永久存档，以确保交易的真实、有效、安全！ 2、左子无法对如“永久包更新”、“永久技术支持”等类似交易之后的商家承诺做担保，请买家自行鉴别； 3、在源码同时有网站演示与图片演示，且站演与图演不一致时，默认按图演作为纠纷评判依据（特别声明或有商定除外）； 4、在没有”无任何正当退款依据”的前提下，商品写有”一旦售出，概不支持退款”等类似的声明，视为无效声明； 5、在未拍下前，双方在QQ上所商定的交易内容，亦可成为纠纷评判依据（商定与描述冲突时，商定为准）； 6、因聊天记录可作为纠纷评判依据，故双方联系时，只与对方在左子上所留的QQ、手机号沟通，以防对方不承认自我承诺。 7、虽然交易产生纠纷的几率很小，但一定要保留如聊天记录、手机短信等这样的重要信息，以防产生纠纷时便于左子介入快速处理。
查看详情

相关文章

猜你喜欢
发表评论
暂无评论
官方客服团队

为您解决烦忧 - 24小时在线 专业服务

联系官方团队 在线提交工单
TA的动态
左子网

分享最新WordPress教程共同学习，共同进步，共同成长！

QQ交流群
左子网

QQ交流群

您的支持，是我们最大的动力！ https://qm.qq.com/q/iR7Nj0TrOg
热门文章
热门标签
随机推荐
热门评论
终身VIP会员限时钜惠
首页 源码 菜单 案例 我的