【一步一步了解Java系列】：对这个系列的总结以及对缺漏内部类知识的补充

看到这句话的时候证明：此刻你我都在努力
加油陌生人

br />个人主页：Gu Gu Study
专栏：一步一步了解Java

喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹

喜欢的话可以点个赞谢谢了。
作者：小闭

一路来的文章

第一篇文章：

记得这个系列是我今年4月29日开始写的，写的是我初始Java的总结，第一篇便是写了Java基本类型与C语言的区别，至于为什么我一开始就跟C语言对标呢？原因有两个：

1. 我那时刚学完C语言，对C语言记忆尤为深刻。
2. 我初始Java的基本数据类型时我就发现Java有C语言没有的基本类型如：byte，而且char在Java中占2个字节。

不知不觉已经过去了两个月了，这个系列也差不多结束了，之后会是Java实现的数据结构的系列了，在之后就是更高级的Java系列。现在这个系列差一个图书馆系统的博客没有写，不过应该也快写了。

第二篇文章：

这篇文章没想到就是我这个系列里面阅读量最高的一篇，这是万万没想到的。这篇是对基本数据类型的转换得总结。关于什么int转换成double什么什么得，还有Java中得float的类型还得必须加上一个F或f等等。主要就是自动类型转换，强制类型转换，类型提升，以及字符串得转换成int，double等。

第三篇文章：

这篇文章还是不知不觉与C语言进行了对比，讲的是各式各样的得运算符，像简单的算术运算符，赋值和++，逻辑运算符，位运算符，移位运算符等，
记得那时讲解取模时第一次遇到了异常，这可是与C语言大不相同的一个知识点，那时不懂还没学到异常，就简单说是报错哈哈哈。还有就是Java中的double是支持取模运算的，也是和C语言的一个不同呢。

第四、五篇文章

第四篇的阅读量就比较凄惨了，里面的内容也比较简单，简单的逻辑结构，记得逻辑结构我在C语言得文章里是没有写过得，那时就觉得太简单了，但到Java想想还是写一下吧，然后就有了这第四篇文章。里面讲了简单得顺序结构，选择结构，循环结构以及switch语句等等，都是非常简单的结构了。
最深刻的还是，Java中不能用数字代表真假，if里的括号只能用true来表示真，false代表假，这也是和C语言的一个不同吧。
然后第五篇：
也算是回到正常的播放量了吧，这篇主要也是和C语言进行对比，因为这是真的和C语言的不同了，在C语言中函数就是Java中的方法，叫法完全不一样了，但性质差不多，只不过Java面向对象的语言，多了一些限定修饰符。
这篇文章主要讲了方法的意义和形参实参，方法的递归，然后就是新概念方法重载，其实到后面还有一个方法·重写，但是那时没有学到类与对象，所以就没在这篇文章里讲。

第六篇文章：

这篇文章是第一次接触引用这个概念，引用是个新概念，Java中没有指针的学习，但是有引用。
数组就是一个引用类型，记得那时我以为能直接用System.out.println直接打印出来呢，没想到的是直接打印出来的是一个地址，哈哈哈。
还有在Java中数组中让我真正跟感觉到Java的简便，只需点length就可以得到数组的长度，换到C语言就是还得使用sizeof慢慢求呢。这里还学到了现成包Arrays，使用其toString就可以将数组转含为字符串就可以直接printf直接将里面的数组给打印出来了。

第七、八篇文章

第七篇文章就是真正与C语言不同的部分了，这时我学到了类与对象，说实话那时类给我的感觉就是一个C语言的结构体，他们的用法也是用“.”操作符来进行的。这篇文章主要讲述了类和对象的关系，类经过实例化后就是一个对象。然后就是一系列的有关类的知识如：构造方法，this关键字。
那时知识初始类与对象，对对象的概念还不是很清楚，但在后面的学习中对对象的理解也是会越来越深的。
然后到第八篇文章的话：

既然学的是类的话，那肯定就要讲到继承了，就有了父类和子类了，这时就要牵扯到super关键字了。然后还有代码块的初始化顺序，现在印象还是很深刻呢。父类静态代码块---->子类的静态代码块---->父类的实例代码块---->父类的构造方法---->子类的实例代码块---->子类的构造方法。

第九篇文章

第九篇文章写的是关于多态，但是这时是没有讲接口和抽象类的，所以之讲了子类的多态，这时我们就讲到函数重写了，重写之后是向上转型和向下转型。

第十、十一篇文章

然后在第十篇终于迎来了，抽象类和接口得学习，不得不说抽象类和接口真的很像，两个都是为了简便代码而存在的，这篇里详细讲解了抽象类与接口的相关知识，包括抽象类不能被final，private修饰，以及不能被new直接实例化，然后就是接口，感觉与抽象类最大的不同就是它不能有构造方法，且它里面的数据和方法都是默认有一些限定修饰符修饰的。

然后这是最后一篇异常类，然后异常类就只需要知道都是Exception类的子类或者是RuntimeException的子类都是异常类，我们还可以通过继承异常类类自定义异常类，然后就是里面的相关关键字try-catch之类的。finally，总之异常类啊还是挺简单的。

补充内部类内容

静态内部类

public class Test {

    static class Test1{
        String name;
        int a=10;

        public void setA(int a) {
            this.a = a;
            System.out.println(a);
        }
    }




}

class Test2{
    public static void main(String[] args) {
        Test.Test1 t=new Test.Test1();
        t.setA(100);

    }
}

静态内部类就是在一个类中在定义一个静态类，因为加了static所以他就是属于这个Test类，所以它的初始化就是可以直接用如上 Test.Test1 t=new Test.Test1();直接用Test.来直接实例化，然后这个t对象就是一个内部类的对象了，其就跟普通的类实例化的对象没啥区别了。然后就是静态内部类都是无法使用外部类的实例成员和实例方法的。但可以直接使用静态方法或静态成员

实例内部类

public class Test {

    class Test1{
        String name;
        int a=10;

        public void setA(int a) {
            this.a = a;
            System.out.println(a);
        }
    }




}


class Test2{
    public static void main(String[] args) {
        Test test=new Test();
        Test.Test1 t=test.new Test1();

    }
}

实例内部类里面则就是跟静态内部类的区别就是其实例化的方式不一样，实例内部类是需要先实例化一个外部类，才能实例化实例内部类。

局部内部类

public class Test {
    static String name1="hjhad";


    public void func1(){

        class Test1{

            int a=10;
            public void func2(){
                System.out.println("haha");
            }


        }
        
        Test1 t=new Test1();
        t.func2();

    }

局部内部类，既然是局部，其实例化也是只能在定义的方法里面进行实例化。

匿名内部类

匿名内部类通常用于实现接口或继承抽象类，不需要命名。

复制
public class Main {
    public static void main(String[] args) {
        // 使用匿名内部类实现接口
        MyInterface myObject = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println("Doing something...");
            }
        };
        myObject.doSomething();

        // 使用匿名内部类继承抽象类
        AbstractClass myAbstractObject = new AbstractClass() {
            @Override
            void abstractMethod() {
                System.out.println("Implementing abstract method...");
            }
        };
        myAbstractObject.abstractMethod();
    }
}

interface MyInterface {
    void doSomething();
}

abstract class AbstractClass {
    abstract void abstractMethod();
}

总结

1. 成员内部类（Member Inner Class）：
   • 成员内部类是定义在另一个类中的类。
   • 它可以访问外部类的成员变量和方法，包括私有的。
   • 它是一个静态成员，因此不能直接访问外部类的非静态成员。
2. 局部内部类（Local Inner Class）：
   • 局部内部类是在方法内部定义的类。
   • 它的作用域仅限于定义它的块内。
   • 它不能访问外部类的成员变量，但可以访问外部类的静态成员变量和方法。
3. 匿名内部类（Anonymous Inner Class）：
   • 匿名内部类是没有名称的内部类。
   • 通常用于实现接口或继承抽象类，且只需要一次使用。
   • 它不能有构造器，但可以访问外部类的成员变量和方法，包括私有的。
4. 静态嵌套类（Static Nested Class）：
   • 静态嵌套类是静态成员内部类的一种。
   • 它可以独立于外部类的实例存在，因此不需要外部类的实例就可以创建静态嵌套类的实例。
   • 它不能访问外部类的非静态成员，但可以访问外部类的静态成员。