java中static关键字的用法

static关键字

static静态方法就是没有this的方法
通常写this的时候，都是指“这个对象”或“当前对象”，而且它本身表示对当前对象的引用。

用于修饰类的成员方法、类的成员变量；可以编写static代码块来优化程序性能

• 特点：
  • 被所有的对象所共享
  • 可以直接使用类名调用
  • 不能作用于局部变量
  • 在static方法内部不能调用非静态方法，但反过来是成立的

非静态成员变量和成员方法是属于对象的，而被static修饰的成员变量及方法并不属于特定的对象。
初始化的顺序先是静态对象，后是非静态对象，并且静态初始化动作只进行一次（当首次生成这个类的一个对象时，或者首次访问那个类的静态数据成员时）

• 在static静态方法中可以调用静态成员变量，及态成员方法
• 在static静态方法中不能调用非静态成员变量，及非静态成员方法
• 静态方法只能调用静态成员
• 非静态方法可以调用静态成员变量，及静态成员方法

public class Static_access {
    public static void main(String[] args) {
        Student st = new Student();
        Student.name = "mo fei";
        Student.name();
        st.eat();
    }
}

class Student {
    static String name;
    public static void name() {
        System.out.println(name);
        sport();
    }
    public static void sport() {
        System.out.println("sport");
    }
    public void eat() {
        System.out.println("eat");
        System.out.println(name);
        sport();
    }
}
/*
mo fei
sport
eat
mo fei
sport
*/

• static 的优点
  –对对象的共享数据提供单独空间的存储，节省空间，没有必要每一个对象都存储一份
  –可以直接被类名调用，不用在堆内创建对象
• static 的弊端
  –访问出现局限性。（静态虽好，但只能访问静态）

代码块

• 局部代码块
  –局部代码块：存在于方法中，控制变量的声明周期

public class Part_block {
    public static void main(String[] args) {
        {
            int num = 1;
            for(int i = 0; i < 3; i++)
                System.out.println(num);
        }
        //当将代码块内部的变量拿出代码块输出时，将会会编译错误
        //System.out.println(num);    //Error
    }
}
/*
1
1
1
 */

• 构造代码块
  –构造代码块：提取构造方法中的共性，每次创建对象都会执行，并且在执行构造方法之前执行

class Stu {
    String name;
    int data;
    Stu() {
        System.out.println("女学生");
    }

    Stu(String name, int data) {
        this.name = name;
        this.data = data;
        System.out.println("男学生");
    }

    {
        for(int i = 0; i < 3; i++)
            System.out.println("java 学习");
    }
}

public class Structure_block {
    public static void main(String[] args) {
        Stu stu = new Stu();
        Stu stu2 = new Stu("mofei", 2020);
    }
}
/*
java 学习
java 学习
java 学习
女学生
java 学习
java 学习
java 学习
男学生
 */

• 静态代码块
  –静态代码块：随着类的加载而加载，只加载一次，加载类时需要做一些初始化，比如加载驱动

class Stu {
    String name;
    int data;
    Stu() {
        System.out.println("女学生");
    }

    Stu(String name, int data) {
        this.name = name;
        this.data = data;
        System.out.println("男学生");
    }

    static {
        for(int i = 0; i < 3; i++)
            System.out.println("java 学习");
    }
}

public class Structure_block {
    public static void main(String[] args) {
        Stu stu = new Stu();
        Stu stu2 = new Stu("mofei", 2020);
    }
}
/*
java 学习
java 学习
java 学习
女学生
男学生
 */

执行顺序

一.

class Code {
    static {
        System.out.println("Code静态代码块");
    }

    {
        System.out.println("Code构造代码块");
    }

    Code() {
        System.out.print("Code无参构造执行");
    }
}

public class Order_block {
    public static void main(String[] args) {
        Code c = new Code();
    }
}
/*
Code静态代码块
Code构造代码块
Code无参构造执行
 */

二.

class Code {
    static {
        System.out.println("Code静态代码块");
    }

    {
        System.out.println("Code构造代码块");
    }

    Code() {
        System.out.println("Code无参构造执行");
    }
}

public class Order_block {
    static {
        System.out.println("Order_block静态代码块");
    }

    {
        System.out.println("Order_block构造代码块");
    }

    public Order_block() {
        System.out.print("Order_block 无参构造执行");
    }
    public static void main(String[] args) {
        Code c = new Code();
        Code cc = new Code();
    }
}
/*
Order_block静态代码块
Code静态代码块
Code构造代码块
Code无参构造执行
Code构造代码块
Code无参构造执行
 */

static修饰内部类

普通类是不允许声明为静态的，，只有内部类才可以。

• 被static修饰的内部类通常被称为嵌套类，嵌套类意味着：1，要创建嵌套类的对象，并不需要其外围类的对象；2，不能从嵌套类的对象中访问非静态的外围类对象。
  – 外部类.内部类 c = new 外部类.内部类（）;

class Outer {
    public static class Inner {
        Inner() {
            System.out.println("Inner");
        }
    }
}

public class Static_Class {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
    }
}

• 如果内部类没有用static修饰，只能先创建外部类引用
  – 外部类 t = new 外部类（）;
  – 外部类.内部类 c = t.new 内部类（）

class Outer1 {
    public class Inner {
        Inner() {
            System.out.println("Inner");
        }
    }
}

public class Static_Class2 {
    public static void main(String[] args) {
        Outer1 t = new Outer1();
        Outer1.Inner inner = t.new Inner();
    }
}

最后

以上就是震动未来为你收集整理的java中static关键字的用法的全部内容，希望文章能够帮你解决java中static关键字的用法所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。