• 【迷人的爪哇】——Java的static成员、代码块、内部类

    目录

    一、static成员

    1.1 static修饰的成员变量

    1.2 static修饰成员方法

    二、代码块

    2.1 概念

    2.2 普通代码块（本地代码块）

    2.3 构造块（实例代码块）

    2.4 静态块

    三、内部类

    3.1 实例内部类

    3.2 静态内部类

    3.3 局部内部类

    3.4 匿名内部类

     四、对象的打印

    一、static成员

    1.1 static修饰的成员变量

    当我们定义一个类时，如果其中的某个成员变量不需要改变，我们可以用static来修饰它，称为静态成员变量，静态成员变量最大的特性是：不需要某个具体的对象，是所有对象所共享的。

    例如：

    1. class Student{
    2.     public String name;
    3.     public int age;
    4.     public static String classRoom = "计科211";
    5.  
    6.     public Student(String name, int age) {
    7.         this.name = name;
    8.         this.age = age;
    9.     }
    10. }
    11. public class Test {
    12.     public static void main(String[] args) {
    13.         Student student1 = new Student("zhangsan",10);
    14.         Student student2 = new Student("lisi",15);
    15.         System.out.println(Student.classRoom);
    16.         System.out.println(Student.classRoom);
    17.     }
    18. }

     我们也可以画图理解：

     静态成员变量特性：

    1. 不属于某个具体的对象，是类的属性，所有对象共享。
    2. 可以通过对象访问，也可以通过类名访问，但最好是类名访问。
    3. 它的生命周期伴随类的一生。
    4. final定义的常量不能修改，final定义的静态常量不能修改且必须初始化。

    1.2 static修饰成员方法

    当static修饰成员方法时，就称为静态方法，也叫类方法。

    例：

    1. class Student{
    2.     public String name;
    3.     public int age;
    4.     public static String classRoom = "计科211";
    5.  
    6.     public Student(String name, int age) {
    7.         this.name = name;
    8.         this.age = age;
    9.     }
    10.     public static void Func(){
    11.         System.out.println("静态方法");
    12.     }
    13. }
    14. public class Test {
    15.  
    16.  
    17.     public static void main(String[] args) {
    18.         Student.Func();
    19.     }
    20. }

     注：

    1. 静态方法的调用不需要引用对象，直接使用类名调用，因此静态方法内不能直接访问非静态的变量或方法。
    2. 在静态方法中可以创建对象来间接访问非静态数据。

    二、代码块

    2.1 概念

    使用 {} 定义的一段代码叫做代码块，可以分为一下几种：

    • 普通代码块（本地代码块）
    • 构造块（实例代码块）
    • 静态块
    • 同步代码块

    2.2 普通代码块（本地代码块）

    定义在方法内部的代码块，一般很少用到：

    1.  
    2.     public static void Func(){
    3.         System.out.println("静态方法");
    4.  
    5.        {
    6.         System.out.println("本地代码块");
    7.  
    8.        }
    9.     }
    10.

    2.3 构造块（实例代码块）

    定义在类的内部，方法的外部。用来初始化实例成员变量，只有在创建对象时才会调用。

    1. class Student{
    2.     public String name;
    3.     public int age;
    4.     public static String classRoom = "计科211";
    5.  
    6.     {
    7.         this.name = "hh";
    8.         this.age = 10;
    9.     }
    10.   
    11. }
    12. public class Test {
    13.  
    14.  
    15.     public static void main(String[] args) {
    16.     }
    17. }

    2.4 静态块

    static修饰的代码块，一般用来初始化静态成员变量。

    1. class Student{
    2.     public String name;
    3.     public int age;
    4.     public static String classRoom;
    5.  
    6.    
    7.     static{
    8.         classRoom = "计科211";
    9.     }
    10.  
    11. }
    12. public class Test {
    13.  
    14.  
    15.     public static void main(String[] args) {
    16.         Student.Func();
    17.     }

    当实例代码块、静态代码块、和构造方法同时出现时：

    其先执行静态代码块，然后执行实例代码块，最后执行构造方法。

    1. class Student{
    2.     public String name;
    3.     public int age;
    4.     public static String classRoom = "计科211";
    5.  
    6.     public Student(String name, int age) {
    7.         this.name = name;
    8.         this.age = age;
    9.         System.out.println("带有两个参数的构造方法");
    10.     }
    11.     public static void Func(){
    12.         System.out.println("静态方法！");
    13.     }
    14.  
    15.     {
    16.         this.name = "haha";
    17.         System.out.println("实例代码块！");
    18.     }
    19.  
    20.     static{
    21.         classRoom = "计科212";
    22.         System.out.println("静态代码块！");
    23.     }
    24.  
    25. }
    26. public class Test {
    27.  
    28.     public static void main(String[] args) {
    29.         Student student = new Student("hehe",10);
    30.  
    31.     }
    32. }

     当有两个静态方法时：

    1. class Student{
    2.     public String name;
    3.     public int age;
    4.     public static String classRoom = "计科211";
    5.  
    6.     public Student(String name, int age) {
    7.         this.name = name;
    8.         this.age = age;
    9.         System.out.println("带有两个参数的构造方法");
    10.     }
    11.     public static void Func(){
    12.         System.out.println("静态方法！");
    13.     }
    14.  
    15.     {
    16.         this.name = "haha";
    17.         System.out.println("实例代码块！");
    18.     }
    19.  
    20.     static{
    21.         classRoom = "计科212";
    22.         System.out.println("静态代码块！");
    23.     }
    24.  
    25. }
    26. public class Test {
    27.  
    28.     public static void main(String[] args) {
    29.         System.out.println(Student.classRoom);
    30.     }
    31. }

    总结：

    1.  先执行静态的（加载了类就会被执行），且静态块只会执行一次。
    2. 如果有多个静态的，那么看定义顺序。
    3. 如果没有实例化对象，那么就只会执行静态的。
    4. 再执行实例化块，有多个实例化数据时就要看定义的顺序。
    5. 再执行构造方法。

    三、内部类

    1. 一个类定义在另一个类或者方法的内部，前者称为内部类，后者称为外部类。
    2. 内部类也是封装的一种体现。
    3. 一个文件里面的不是内部类，只有一个类中的才是。
    1. class OuterClass{
    2.  
    3.     class InnerClass{
    4.         
    5.     }
    6. }
    7. public class Test {
    8.  
    9. }

    3.1 实例内部类

    1. class OuterClass{
    2.  
    3.     public int data1 = 1;
    4.     private int data2 = 2;
    5.     public static int data3 = 3;
    6.  
    7.     class InnerClass{
    8.         public int data4 = 4;
    9.         private int data5 = 5;
    10.         public int data1 = 111;
    11.         public InnerClass() {
    12.             System.out.println("实例内部类的构造方法！");
    13.         }
    14.         public void innerFunc(){
    15.             System.out.println("实例内部类的普通方法！");
    16.             System.out.println(data1);
    17.  
    18.             //访问与内部类同名的外部类的成员变量
    19.             System.out.println("外部类:"+ OuterClass.this.data1);
    20.             System.out.println(data2);
    21.             System.out.println(data3);
    22.             System.out.println(data4);
    23.             System.out.println(data5);
    24.         }
    25.     }
    26. }
    27. public class Test {
    28.     public static void main(String[] args) {
    29.         //OuterClass outerClass = new OuterClass();
    30.         //OuterClass.InnerClass innerClass = outerClass.new InnerClass();
    31.  
    32.         //实例化内部类
    33.         OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();
    34.  
    35.         innerClass.innerFunc();
    36.     }
    37. }

     总结：

    1. 实例内部类不能定义静态的成员变量，如果要定义，就要加final修饰。
    2. 实例内部类中不能定义静态的成员方法。
    3. 如果在实例内部类内访问同名的外部类由static修饰的成员变量时，直接外部类类名.成员变量。
    4. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束。
    5. 会生成字节码文件： 外部类$内部类。

    3.2 静态内部类

    1. class OuterClass{
    2.     public int data1 = 1;
    3.     private int data2 = 2;
    4.     public static int data3 = 3;
    5.  
    6.     static class InnerClass{
    7.         public int data4 = 4;
    8.         private int data5 = 5;
    9.         public static int data6 = 6;
    10.         private OuterClass outerClass;
    11.  
    12.         public InnerClass(OuterClass outerClass){
    13.             System.out.println("静态内部类的构造方法！");
    14.             this.outerClass = outerClass;
    15.         }
    16.         public void func(){
    17.             System.out.println("func方法执行了！");
    18.  
    19.             //访问非静态外部类成员变量
    20.             System.out.println(outerClass.data1);
    21.             System.out.println(outerClass.data2);
    22.  
    23.             System.out.println(data3);
    24.             System.out.println(data4);
    25.             System.out.println(data5);
    26.             System.out.println(data6);
    27.  
    28.         }
    29.     }
    30. }
    31. public class Test2 {
    32.  
    33.     public static void main(String[] args) {
    34.  
    35.         //实例化静态内部类
    36.         OuterClass.InnerClass innerClass = new OuterClass.InnerClass(new OuterClass());
    37.         innerClass.func();
    38.     }
    39. }

     注：

    1. 在静态内部类中只能访问外部类中的静态成员，不能在静态内部类中直接访问外部类的非静态的数据成员，可以通过实例化外部类对象来间接访问。
    2. 创建静态内部类对象时，不需要先创建外部类对象。

    3.3 局部内部类

    1. 局部内部类定义在方法体内部，之饿呢过在该方法体内使用，其他位置不能使用。
    2. 不能被public、static等访问限定符修饰。
    3. 也有独立的字节码文件，命名格式：外部类名字$内部类名字。
    1. public class Test2 {
    2.  
    3.     public static void fun(){
    4.         class A{
    5.             public void test(){
    6.                 System.out.println(1);
    7.             }
    8.         }
    9.         A a = new A();
    10.         a.test();
    11.     }
    12.  
    13.     public static void main(String[] args) {
    14.  
    15.         fun();
    16.  
    17.     }
    18. }

    3.4 匿名内部类

    1. class Person{
    2.     public String name;
    3.     public int age;
    4.  
    5.     public void test(){
    6.         System.out.println("lisi");
    7.     }
    8. }
    9. public class Test2 {
    10.  
    11.     public static void main(String[] args) {
    12.         //匿名对象，只能使用一次
    13.         new Person().test();
    14.  
    15.         new Person(){
    16.             @Override
    17.             public void test() {
    18.                 System.out.println("77777");
    19.             }
    20.         }.test();
    21.      }
    22. }

     

     四、对象的打印

    1. class Person{
    2.     public String name;
    3.     public int age;
    4.  
    5.     public Person(String name, int age) {
    6.         this.name = name;
    7.         this.age = age;
    8.     }
    9.  
    10.     @Override
    11.     public String toString() {
    12.         return "Person{" +
    13.                 "name='" + name + '\'' +
    14.                 ", age=" + age +
    15.                 '}';
    16.     }
    17. }
    18. public class Test3 {
    19.     public static void main(String[] args) {
    20.         Person person = new Person("zhangsan",10);
    21.         System.out.println(person);
    22.     }
    23. }

    当我重写ToString函数之后，编译器就会调用我重写的函数，可以实现对对象的打印，

  • 相关阅读:
    MOEAD原理及Python实现、MOEAD实现、基于分解的多目标进化、 切比雪夫方法-（python完整代码）
    递推递归与排列组合
    java多线程基础（上）
    如何用Python搭建监控平台
    5分钟，带你看完24岁60W年薪架构师的简历，上面竟然写着精通JVM
    多个列表参数一一对应使用枚举
    UNet语义分割网络
    sql登录报错18456和233怎么解决
    聚苯乙烯-SiO2/NiFe2O4磁性微球/中空介孔载银二氧化硅聚苯乙烯微球制备过程
    linux部署docker【centos】
  • 原文地址：https://blog.csdn.net/weixin_62678196/article/details/124928309