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

2019-06-15 00:00:00 关键字 部类 面向对象


一、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();
    }
}

程序执行后的运行结果如下:
《Java面向对象之static关键字与内部类》

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


二、内部类

内部类就是定义在一个类里面的类,它提供了更好的封装,不允许同一个包中的其他类访问该类,内部类的方法可以访问外部类的所有数据,包括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();
    }
}

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

相关文章