打卡四天：Java内部类&内网穿透（NAT）&Git的基本使用

一，Java内部类

定义：内部类（Inner Class）是定义在另一个类内部的类。它依赖于外部类而存在，能访问外部类的成员（包括私有成员），同时也可以封装一些与外部类密切相关的逻辑，增强代码的内聚性。主要分成员内部类，静态内部类，局部内部类， 匿名内部类（重点）4种。

1. 成员内部类：
   特点：
   –属于外部类的实例成员，需通过外部类实例才能创建内部类对象。
   –可直接访问外部类的所有成员（包括私有成员）。
   –内部类中不能定义静态成员（静态常量除外

   示例代码：
   public class OuterClass {
       private int outerField = 10;
   
       // 成员内部类
       public class InnerClass {
           public void accessOuter() {
               // 直接访问外部类的私有成员
               System.out.println("外部类字段：" + outerField);
           }
       }
   
       // 外部类中创建内部类对象
       public void createInner() {
           InnerClass inner = new InnerClass();
           inner.accessOuter();
       }
   
       public static void main(String[] args) {
           // 外部类外部创建内部类对象：需通过外部类实例
           OuterClass outer = new OuterClass();
           OuterClass.InnerClass inner = outer.new InnerClass();
           inner.accessOuter(); // 输出：外部类字段：10
       }
   }

2. 静态内部类:
   特点：
   –属于外部类的静态成员，不依赖外部类实例，可直接通过外部类名访问。
   –只能访问外部类的静态成员（非静态成员需通过外部类实例访问）。
   –内部类中可以定义静态成员。

示例代码：

public class OuterClass {
    private static int staticOuterField = 20;
    private int nonStaticField = 30;

    // 静态内部类
    public static class StaticInnerClass {
        public void accessOuter() {
            // 只能直接访问外部类的静态成员
            System.out.println("外部类静态字段：" + staticOuterField);

            // 访问非静态成员需通过外部类实例
            OuterClass outer = new OuterClass();
            System.out.println("外部类非静态字段：" + outer.nonStaticField);
        }
    }

    public static void main(String[] args) {
        // 直接通过外部类名创建静态内部类对象
        OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
        inner.accessOuter(); 
        // 输出：
        // 外部类静态字段：20
        // 外部类非静态字段：30
    }
}

3. 局部内部类
   特点：
   –作用域仅限于所在的方法或代码块，外部无法直接访问。
   –可访问外部类的所有成员，以及所在方法中被final或有效 final（Java 8+）修饰的局部变量。
   –不能使用访问修饰符（public/private等）或static修饰。

示例代码：

public class OuterClass {
    private int outerField = 40;

    public void outerMethod() {
        final int localVar = 50; // 局部变量（有效final）

        // 局部内部类（定义在方法内）
        class LocalInnerClass {
            public void print() {
                System.out.println("外部类字段：" + outerField);
                System.out.println("方法局部变量：" + localVar);
            }
        }

        // 只能在方法内创建局部内部类对象并使用
        LocalInnerClass inner = new LocalInnerClass();
        inner.print();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.outerMethod(); 
        // 输出：
        // 外部类字段：40
        // 方法局部变量：50
    }
}

4. 匿名内部类:
   特点：
   –定义时必须立即创建实例，不能单独定义后再使用。
   –隐式继承一个父类或实现一个接口（只能是一个）。
   –作用域与局部内部类相同，且不能有构造方法（因无类名)。
   示例代码：

   // 定义一个接口
   interface Greeting {
       void sayHello();
   }
   
   public class OuterClass {
       public void test() {
           // 匿名内部类：实现Greeting接口
           Greeting greeting = new Greeting() {
               @Override
               public void sayHello() {
                   System.out.println("Hello from Anonymous Inner Class");
               }
           };
           greeting.sayHello(); // 输出：Hello from Anonymous Inner Class
       }
   
       public static void main(String[] args) {
           new OuterClass().test();
       }
   }

内部类的核心作用:
—封装性：内部类可隐藏在外部类中，仅外部类可见，减少对外部的暴露。
—访问便利性：直接访问外部类成员，无需通过 getter/setter。
—逻辑关联性：将与外部类强相关的逻辑封装在一起，增强代码可读性和维护性（如集合框架中的Iterator实现类常作为内部类）。

二，内网穿透（NAT）

1.目的：让外网能访问到本地服务器
NAT（Network Address Translation，网络地址转换）是一种网络设备，用于将一个或多个IP地址映射到另一个IP地址。NAT设备将内网中的多个IP地址映射到一个公共IP地址，从而实现外网访问内网。
实现方式：
–静态转换是指将内部网络的私有IP地址转换为公有IP地址，IP地址对是一对一
–动态转换是指将内部网络的私有IP地址转换为公有IP地址，IP地址对是一对多
–内部网络的所有主机均可共享一个合法外部IP地址实现对Internet的访问，从而可以最大限度地节约IP地址资源。同时又可隐藏网络内部的所有主机，有效避免来自internet的攻击。因此，目前网络中应用最多的就是端口多路复用方式。
–应用程序级网关技术（Application Level Gateway）ALG：传统的NAT技术只对IP层和传输层头部进行转换处理，ALG它能对这些应用程序在通信时所包含的地址信息也进行相应的NAT转换

–实现工具有免费的可用 Ngrok 和NatApp等

2.正向代理和反向代理核心区别总结：
–代理对象：正向代理代理客户端，反向代理代理服务器。
–隐藏对象：正向代理隐藏真实客户端，反向代理隐藏真实服务器。
–使用目的：正向代理侧重 “客户端突破访问限制”，反向代理侧重 “服务器优化性能、保障安全”。

三，Git的理解与使用

1.git是一个分布式版本控制软件，用于管理代码的版本，gitHub是一个开源的代码托管平台，用于托管git仓库。
使用git提供自带的命令git bash,不使用cmd的原因：
–git bash 中，ls、cp、mkdr、vim等命令都有
–自带的命令行很空命令是和Linux命令都是一样的，操作方便

2.git的基础使用
–git初始化(项目初始化成仓库)

git init

–在项目下运行命令

git status

git status文件有三种状态：
–红色：修改、创建、删除都是显示红色
–绿色：git add 添加之后变成绿色
–白色：git commit提交之后变成白色

git add添加要管理的文件，命令：

git add <file>
git add file1  file2 ...   
git add .  //推荐点表示，把当前文件夹下所有的文件他（会递归的把每一个子文件夹下的文件也同样管理起来）都统统管理起来，就是要把它们都变绿

3、git commit 把文件提交到仓库，命令：

git commit -m "第一次提交"

-m后面输入的是本次提交的说明
commit提交之后信息中文件变成白色 此时说明提交成功

提交的时候用以下命令配置用户和邮箱的信息:告诉别人是谁提交的

git config --global user.email "you@example.com"
git config --global user.name "Your Name"

git log 查看提交（commit）的历史记录，命令：

四，Git的进阶与使用

1.版本回滚

git reset --hard  版本号   // 回滚到指定版本
git reflog //查看所有的提交记录方便向前回滚和向后回滚

2.在不提交完整版本的情况下，临时 “冻结” 当前工作区和暂存区的修改，让工作区回到干净状态，以便进行分支切换、拉取代码、重置等操作，之后再恢复修改继续工
–git stash 把没有提交的代码暂存在某个地方，命令
–git stash pop 进行把暂存的代码拿回来

3.分支、

git branch <分支名> //创建分支
git checkout <分支名>  //切换分支
git merge <分支名>      //合并分支,在哪个分支，就是把这个分支名合并到当前分支。
git branch -d <分支名>  //删除分支

一般的bug修复流程

将dev 中现在正在开发的功能提交到dev
git add .
git commit -m “xxxxx”
切换到主分支（master分支）
git checkout master
创建并切换到bug分支
git branch bug
git checkout bug
在bug分支上进行修复
git add .
git commit -m “xxxx”
切换回master分支，合并修复的bug分支，最后删除bug分支
git checkout master
git merge bug
git branch -d bug
查看当前有哪些分支
git branch 或git branch -a 或git branch --all

五，远程仓库,多人协同开发

1.gitee或github上创建版本存储仓库

git remote add origin https://gitee.com/zhr/test_git.git //添加远程仓库其中origin是我给这个仓库链接起的别名

git push origin master   //把本地仓库推到远程存储仓库

2.当使用git clone 把代码从版本存储仓库下载后只有master分支,需要通过以下流程解决

git pull
我们就可以通过以下流程进行切换到dev上进行开发：

git branch dev： 创建一个dev分支
git checkout dev：切换到dev分支
git pull origin dev ：把远程存储仓库中的dev分支更新到现在的dev分支中，此时就是我们正在开发的代码