• 【Java SE】内部类和对象的打印问题

    1、何为内部类：

    在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

    ​

     注意：1、定义在 class 类名{ }花括号 外部的，即使是在一个文件里，都不能称为内部类

    ​

     2、内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

    2、内部类的分类

    根据内部类定义的位置不同，一般可以分为以下几种形式：
    1. 成员内部类(普通内部类：未被static修饰的成员内部类和静态内部类：被static修饰的成员内部类)
    2. 局部内部类(不谈修饰符)、匿名内部类

    ​

    实例内部类

    1. public class OutClass {
    2.     private int a;
    3.     static int b;
    4.     int c;
    5.     public void methodA() {
    6.         a = 10;
    7.         System.out.println("methodA="+a);
    8.     }
    9.     public static void methodB() {
    10.         System.out.println("methodB="+b);
    11.     }
    12.  
    13.     // 实例内部类：未被static修饰
    14.     class InnerClass {
    15.         int c;
    16.         public void methodInner() {
    17.             // 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
    18.             a = 100;
    19.             b = 200;
    20.             methodA();
    21.             methodB();
    22.             // 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
    23.             c = 300;
    24.             System.out.println("c="+c);
    25.             // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
    26.             OutClass.this.c = 400;
    27.             System.out.println("OutClass.c="+OutClass.this.c);
    28.         }
    29.     }
    30.  
    31.  
    32.     public static void main(String[] args) {
    33.         // 外部类：对象创建以及成员访问
    34.         OutClass outClass = new OutClass();
    35.         System.out.println("outClass.a="+outClass.a);
    36.         System.out.println("outClass.b="+OutClass.b);
    37.         System.out.println("outClass.c="+outClass.c);
    38.         outClass.methodA();
    39.         outClass.methodB();
    40.         System.out.println("--------------实例内部类的访问--------------");
    41.         // 要访问实例内部类中成员，必须要创建实例内部类的对象
    42.         // 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类
    43.         OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();// 实例化内部类对象
    44.         OutClass.InnerClass innerClass2 = outClass.new InnerClass();
    45.         // 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象
    46.         innerClass2.methodInner();
    47.     }
    48. }

    ​

      注意:

    1. 外部类中的任何成员都可以在实例内部类方法中直接访问
    2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
    3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员来访问
    4. 实例内部类的非静态方法中包含了一个指向外部类对象的引用
    5. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

     静态内部类

    被static修饰的内部成员类称为静态内部类

    1. public class OutClass {
    2.     private int a;
    3.     static int b;
    4.     public void methodA(){
    5.         a = 10;
    6.         System.out.println(a);
    7.     }
    8.     public static void methodB(){
    9.         System.out.println(b);
    10.     }
    11.     // 静态内部类：被static修饰的成员内部类
    12.     static class InnerClass{
    13.         public void methodInner(){
    14.              b =200;
    15.             methodB();// 在内部类中只能访问外部类的静态成员 
    16.         // a = 100; // 编译失败，因为a不是类成员变量 
    17.         // methodA(); // 编译失败，因为methodB()不是类成员方法 
    18.         }
    19.     }
    20.     public static void main(String[] args) {
    21.         // 静态内部类对象创建 & 成员访问
    22.         OutClass.InnerClass innerClass = new OutClass.InnerClass();
    23.         innerClass.methodInner();
    24.     }
    25. }
    26. //输出：200

    注意：

    1. 局部内部类只能在所定义的方法体内部使用
    2. 静态内部类不能被public、static等修饰符修饰
    3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$内部类名字.class
    4. 几乎不会使用

     对象的打印

    1. public class Person {
    2.     String name;
    3.     String gender;
    4.     int age;
    5.  
    6.     public Person(String name, String gender, int age) {
    7.         this.name = name;
    8.         this.gender = gender;
    9.         this.age = age;
    10.     }
    11.  
    12.     public static void main(String[] args) {
    13.         Person person = new Person("Jim", "男", 18);
    14.         System.out.println(person);//默认打印的经过哈希的地址
    15.     }
    16. }
    17. //输出：
    18. //Person@1b6d3586

    如果想要默认打印对象中的属性该如何处理呢？答案：重写toString方法即可。

    那么如何重写toString呢？ 

    先右键空白处然后按下列步骤进行：

     出现这个就重写成功了

     最后结果：

    1. public class Person {
    2.     String name;
    3.     String gender;
    4.     int age;
    5.     public Person(String name, String gender, int age) {
    6.         this.name = name;
    7.         this.gender = gender;
    8.         this.age = age;
    9.     }
    10.     @Override
    11.     public String toString() {
    12.         return "Person{" +
    13.                 "name='" + name + '\'' +
    14.                 ", gender='" + gender + '\'' +
    15.                 ", age=" + age +
    16.                 '}';
    17.     }
    18.     public static void main(String[] args) {
    19.         Person person = new Person("Jim", "男", 18);
    20.         System.out.println(person);//默认打印的经过哈希的地址
    21.     }
    22. }
    23. //输出：
    24. //Person{name='Jim', gender='男', age=18}
  • 相关阅读:
    GitHub相应太慢
    ELK技术介绍：背景、功能及应用场景全面解析
    MySQL性能分析：性能模式和慢查询日志的使用
    【计算机网络】 基于UDP的简单通讯（客户端）
    Spring Boot + Vue的网上商城之登陆认证
    Apache SCXML2 RCE漏洞
    车载充气泵方案开发——鼎盛合科技
    10-27 maven概念
    java计算机毕业设计-英杰学堂网上教学平台-源程序+mysql+系统+lw文档+远程调试
    剑指offer全集系列Java版本(2)
  • 原文地址：https://blog.csdn.net/m0_65601072/article/details/126923302