Java面向对象之static关键字与内部类

一、static关键字

Java中被static修饰的成员称作静态成员或类成员，属于整个类所有，可以直接使用类名或对象名进行访问。

1.1 静态变量与静态方法

用static修饰的变量叫静态变量，用static修饰的方法叫静态方法（如main方法）。

1、静态方法可以直接调用同类中的静态成员，不能调用非静态成员
2、静态方法可以直接调用同类中的静态方法，不能调用非静态方法
3、普通方法则都可以进行调用

public class StaticDemo {
    static String s = "Hello";
    String s2 = " World!";
    public static void main(String[] args) {
        StaticDemo sd = new StaticDemo();
        System.out.println(StaticDemo.s+sd.s2);//前者为静态变量，可以直接调用，后者实例化后通过对象调用
        sd.print1();
        print2();//静态方法可以被直接调用
    }
    public void print1(){
        System.out.println(s+s2);//普通方法可以直接调用各种成员
    }
    public static void print2(){
        StaticDemo sd = new StaticDemo();
        System.out.println(s+sd.s2);
    }
}

1.2 静态代码块

用static修饰的初始化块，称为静态代码块，它只能给静态变量赋值。

类加载时的执行顺序：
1、首先执行静态初始化块；
2、然后执行普通初始化块；
3、最后执行构造方法。

public class StaticDemo {
    int num1;
    int num2;
    static int num3;
    public StaticDemo(){ //构造方法
        num1 = 90;
        System.out.println("通过构造方法为num1赋值："+num1);
    }
    { //普通初始化块
        num2 = 80;
        System.out.println("通过普通初始化块为num2赋值："+num2);
    }
    static{ //静态初始化块
        num3 = 100;
        System.out.println("通过静态初始化块为num3赋值："+num3);
    }
    public static void main(String[] args) {
        StaticDemo sd1 = new StaticDemo();
        StaticDemo sd2 = new StaticDemo();
    }
}

程序执行后的运行结果如下：

从结果中可以看出类加载时的执行顺序，且静态代码块只执行一次。

二、内部类

内部类就是定义在一个类里面的类，它提供了更好的封装，不允许同一个包中的其他类访问该类，内部类的方法可以访问外部类的所有数据，包括private类型的数据。

2.1 成员内部类

成员内部类就是普通内部类，编译含有内部类的程序会产生2个.class文件，一个是“外部类.class”，另一个则是“外部类$内部类.class”。创建成员内部类对象如下格式：

内部类 对象名 = 外部类.new 内部类();

如果内部类和外部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的同名成员变量或方法，则需要使用this关键字。

public class Outer {
    int a = 80;
    public class Inner{
        int a = 90;
        public void print(){
            System.out.println("内部类中的a:"+a);
            System.out.println("外部类中的a:"+Outer.this.a);
        }
    }
    public static void main(String[] args) {
        Outer o = new Outer();
        Inner i = o.new Inner();
        i.print();
    }
}

2.2 静态内部类

静态内部类使用static修饰符修饰，不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式进行访问。当静态内部类与外部类的成员名相同时，可以通过 类名.静态成员名 进行访问。静态内部类的对象可以直接通过new进行实例化创建。如下所示：

内部类 对象名 = new 内部类();

public class Outer {
    int a = 80;
    static int b = 100;
    public static class StaticInner{
        int b = 10;
        public void print(){
            System.out.println("内部类中的b:"+b);
            System.out.println("外部类中的b:"+Outer.b);
            System.out.println("外部类中的非静态成员a:"+new Outer().a);
        }
    }
    public static void main(String[] args) {
        StaticInner si = new StaticInner();
        si.print();
    }
}

2.3 方法内部类

方法内部类就是定义在外部类方法中的内部类，不能使用访问控制修饰符和static进行修饰。

public class Outer {
    int a = 80;
    static int b = 100; 
    public void function(){
        int c = 20;
        class FunctionInner{
            int d = 40;
            public void print(){
                System.out.println("方法中的c:"+c);
                System.out.println("方法内部类中的d:"+d);
            }
        }
        FunctionInner fi = new FunctionInner();
        fi.print();
    }
    public static void main(String[] args) {
        Outer o = new Outer();
        o.function();
    }
}

注：文章根据本站相关课程的学习笔记整理而来，有错误或其他任何问题敬请指正，欢迎共同学习交流！