java（类变量类方法（static）、main语法、代码块、final）

最新推荐文章于 2024-07-09 16:17:35 发布

明明不想懂256

最新推荐文章于 2024-07-09 16:17:35 发布

阅读量266

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_63954483/article/details/124915391

版权

类变量：（静态变量）

1.类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个类的对象去修改它时，修改的也是同一个变量

2.语法：访问修饰符 static 数据类型变量名；

static 访问修饰符数据类型变量名；

3.如何访问类变量：（静态变量的访问修饰符的访问权限范围和普通属性是一样的）

类名.类变量名或者对象名.类变量名

public class Study {
    public static void main(String[] args) {
        //类变量是随着类的加载而创建，所以即使没有创建对象实例也可以访问
        System.out.println(A.name);
    }
}
class A{
    public static String name="张三";
}

注意事项：

1.什么时候需要用类变量

当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量

2.类变量与实例变量（普通属性）区别

类变量是该类的所有对象共享的，而实例变量是每个对象独享的

3.加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量

类方法：（静态方法）

1.形式：访问修饰符 static 数据返回类型方法名(){}

2.类方法的调用：类名.方法名

3.使用场景：当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法

注意事项：

1.类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区：

类方法中无this的参数

普通方法中隐含着this的参数

class A{
    private String name;
    public static String getName(){
        return this.name;//this无法在static方法中使用
    }
}

2.类方法可以通过类名调用，也可以通过对象名调用

public class Study {
    public static void main(String[] args) {
        A.say();
    }
}
class A{
    public static void say(){
        System.out.println("A的静态方法");
    }
}

3.普通方法和对象有关，需要通过对象名调用，不能通过类名调用

4.类方法中不允许使用和对象有关的关键字

如：this和super等关键字

5.类方法（静态变量）中只能访问静态变量或静态方法

class A{
    private String name;
    public static void getName(){
        System.out.println(name);
    }
}

6.普通成员方法，既可以访问普通变量（方法），也可以访问静态变量（方法）

main方法

解释main方法的形式 public static void main(String[] args){}

1.java虚拟机需要调用类的main方法，所以该方法的访问权限必须是public

2.java虚拟机在执行main方法时不必创建对象，所以该方法必须是static

3.该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数

4.main方法由虚拟机调用

注意事项：

1.在main方法中，我们可以直接调用main方法所在类的静态方法或静态属性

2.但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态变量

代码块

概念：代码块又称为初始化块，属于类中的成员（即是类的一部分）类似于方法，将逻辑语句封装在方法体中，通过{}包围起来

和方法不同，没有方法名，没有返回值，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用

基本语法：

[修饰符]{ 代码块 }；

1.修饰符可选，要写的话，只能写static

2.代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的叫普通代码块

3.逻辑语句可以为任何逻辑语句

4.；号可以写上，也可以省略

如何应用：

1.相当于另外一种形式的构造器，可以做初始化的操作

2.如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性

注意事项：

1.static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会被执行一次。如果是普通代码块，每创建一个对象，就执行

public class Study {
    public static void main(String[] args) {
        System.out.println(A.age);
    }
}
class A{
    public static int age;
    static {
        System.out.println("A的静态代码块");
    }
}

2.类什么时候被加载

（1）创建对象实例时

public class Study {
    public static void main(String[] args) {
        new A();//输出A的静态代码块
    }
}
class A{
    static {
        System.out.println("A的静态代码块");
    }
}

（2）创建子类对象实例，父类也会被加载

public class Study {
    public static void main(String[] args) {
        new B();//输出A的静态代码块
    }
}
class A{
    static {
        System.out.println("A的静态代码块");
    }
}
class B extends A{}

（3）使用类的静态成员时

public class Study {
    public static void main(String[] args) {
        A.say();
    }
}
class A{
    public static void say(){
        System.out.println("A的say方法");
    }
    static {
        System.out.println("A的静态代码块");
    }
}

3.普通的代码块，在创建对象实例时，会被隐式的调用，被创建一次，就会调用一次

如果只是使用类的静态成员时，普通代码块并不会执行

4.创建一个对象时，在一个类调用顺序是：

（1）调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用）

（2）调用普通代码块和普通属性的初始化（普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用）

（3）调用构造方法

5.构造器的最前面其实隐含了super（）和调用普通代码块

public class Study {
    public static void main(String[] args) {
        A a = new A(10);
    }
}
class A{
    public int n1;
    {
        System.out.println("A的普通代码块");
    }
    public A(int n1) {
        //super()
        //调用普通代码块
        this.n1 = n1;
    }
}

6.创建子类时，调用顺序：

（1）父类的静态代码块和静态属性初始化

（2）子类的静态代码块和静态属性初始化

（3）父类的普通代码块和普通属性初始化

（4）父类的构造器

（5）子类的普通代码块和普通属性初始化

（6）子类的构造器

7.静态代码块只能调用静态成员，普通代码块可以任意调用成员

final关键字

final可以修饰类、属性、方法和局部变量

在以下情况可使用：

1.当不希望类被继承时，可以用final修饰

2.当不希望父类的某个方法被子类重写

3.当不希望类的某个属性的值被修改

4.当不希望某个局部变量被修改

注意事项：

（1）final修饰的属性又叫常量，一般用xx_xx来命名

（2）final修饰的属性在定义时，必须赋初值，并且以后不能再修改

可以在定义时、构造器、代码块中赋初值

（3）如果final修饰的属性是静态的，则初始化的位置只能是定义时、静态代码块，不能在构造器中赋初值

（4）final类不能继承，但是可以实例化对象

（5）如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承

（6）final不能修饰构造方法

（7）final和static往往搭配使用，效率更高，不会导致类加载

public class Study {
    public static void main(String[] args) {
        System.out.println(A.num);//静态代码块未被执行，类没有加载
    }
}
class A{
    public final static int num=20;
    static {
        System.out.println("A的静态代码块");
    }
}

（8）包装类（Integer，Double，Float，Boolean等都是final类）String也final类