Java类和对象Static以及代码块

最新推荐文章于 2023-02-10 14:13:57 发布
最新推荐文章于 2023-02-10 14:13:57 发布
阅读量447 收藏 1
点赞数 1
分类专栏： JavaSE 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44070116/article/details/127790759
版权
  1. sratic修饰成员变量：静态成员变量，也叫类变量
    static修饰成员方法：静态成员方法，也叫类方法
  2. （sratic修饰成员变量的总结）定义某个班级的学生的学生类，包含姓名、年龄、班级。
class Student {
    public String name;
    public int age;
    public String classRoom = "Java学习";

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

}
public class Test2 {
    public static void main(String[] args) {
        Student s1 = new Student("小王",22);
        Student s2 = new Student("小帅",21);
        Student s3 = new Student("小军",22);
        System.out.println("在此条语句设置断点，调试以上代码");
    }
}

调试代码：
在这里插入图片描述
分析：s1和s2以及s3的成员变量classRoom的值都相同为java学习，即Student类中定义的成员比哪里，每个对象中都会包含一份。
但是classRoom并不需要每个学生对象中都存储一份，而是需要让所有的学生来共享。
因此使用static修饰classRoom成员变量。

    public String name;
    public int age;
    public static String classRoom = "Java学习";

调试结果：
在这里插入图片描述
分析：此时static修饰classRoom，则在s1和s2以及s3中，静态成员变量classRoom并没有存储到某个具体的对象中，此时的classRoom在方法区，而不在堆上。
在这里插入图片描述

  1. 如何访问静态成员变量？
        //通过类名访问（更推荐）
        System.out.println(Student.classRoom);
        //通过对象访问
        Student s = null;
        System.out.println(s.classRoom);

静态成员变量即可以通过对象访问，也可以通过类名访问。
通过对象访问的时候，Idea不会有代码提示，而且会出现警告，一般更推荐使用类名访问。
代码中虽然s被赋值为null（不指向任何对象），但是s.classRoom并没有报错，因为静态成员变量不属于对象，静态的不依赖对象，通过类名/类型调用。

  1. 成员变量被分成2类：（根据有无static修饰）
    ①静态成员变量，也叫 类变量，也叫 类成员。（有static修饰）
    ②非静态成员变量，也叫 普通成员变量。（无static修饰）

  2. 静态成员变量特性
    static修饰的成员变量，成为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。Java中不允许定义局部的静态变量（就是局部变量加static在Java中是不允许的）。
    ①不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中。
    ②既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问（所有叫做类变量）。
    ③类变量存储在方法区中。
    ④生命周期伴随类的一生，随类的加载而创建，随类的卸载而销毁。

  3. static修饰成员方法：被static修饰的成员方称为静态成员方法，是类的方法，不是某个对象所特有的。
    static修饰成员方法被分成2类：（根据有无static修饰）
    ①静态成员方法，也叫 类方法。（有static修饰）
    ②非静态成员方法。（无static修饰）

  4. 被static修饰的成员方法分析（静态成员方法）

    public static String classRoom = "Java学习";

    public static String getClassRoom() {
        return classRoom;
    }

    public static void setClassRoom(String classRoom) {
        Student.classRoom = classRoom;
    }

调用上述静态成员方法：

    public static void main(String[] args) {
        System.out.println(Student.getClassRoom());
    }

运行结果：
在这里插入图片描述
分析：此时我们并没有new创建对象，直接通过类名.静态成员方法名调用，这也说明静态成员方法不依赖于对象。

  1. 静态方法特性：
    ①不属于某个具体的对象，是类方法
    ②可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐后者
    ③不能再静态方法中访问任何非静态成员变量/非静态成员方法

  2. 在静态方法内部中不能直接使用非静态成员变量/非静态成员方法
    在这里插入图片描述

分析：在静态成员方法func中，访问非静态成员变量name和age会出现报错，调用非静态成员方法eat也会报错。【因为非静态的数据成员属于对象的，在调用静态方法的时候可以没有实例的对象，只要是非静态的数据成员和方法都必须通过对象的引用才能调用】。而且静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时无法传递this参数，故静态方法里面不能使用this。

  1. 普通成员方法内部可以调用静态成员方法
    public static void func() {
        System.out.println("静态成员方法");
    }

    public void eat(){
        System.out.println(this.name + "吃饭");
        func();
    }

    public static void main(String[] args) {
        Student s = new Student("小王",22);
        s.eat();
    }

运行结果：
在这里插入图片描述
分析：在非静态成员方法中调用静态成员方法func，通过运行结果显示：调用成功。静态成员方法有类就可与用，非静态成员方法有对象才可以用，有对象则一定有类，可以根据类和对象的联系关系进行理解。

  1. 对于静态成员变量的初始化（5种方法）
    ①直接赋值
    public static String classRoom = "Java学习";

②默认初始化（示例中因为classRoom为String类型，所以默认初始化为0）

    public static String classRoom;

③通过get和set方法初始化

class Person {
    private String name;
    private int age;
    private static String classRoom;

    public static String getClassRoom() {
        return classRoom;
    }

    public static void setClassRoom(String classRoom) {
        Person.classRoom = classRoom;
    }
}

public class Test {
    public static void main(String[] args) {
        Person.setClassRoom("Java");
        String ret = Person.getClassRoom();
        System.out.println(ret);
    }
}

运行结果：
在这里插入图片描述
分析：获取静态成员变量或者设置静态成员变量，此时的方法最好是静态的，否则如果是非静态的方法，则又要实例化对象**（多此一举）才能调用。
④在构造对象的时候，在构造方法中进行赋值
在这里插入图片描述
分析：虽然此时能够成功给静态成员变量classRoom赋值，但是不建议这样进行赋值，因为每次构造对象的时候，都会传入classRoom形参的值，所以classRoom的值会不断随着对象而更新，静态成员变量的控制权不应该是某个对象，而应该是属于类的。
⑤通过代码块**进行赋值

  • 普通代码块
  • 构造块，又叫 非静态代码块，实例代码块，构造代码块
  • 静态块，又叫 静态代码块
  • 同步代码块（多线程部分）
  1. 普通代码块：定义在方法里的代码块
public class Test3 {
    public static void main(String[] args) {
        {
            int a = 10;
            System.out.println(a);
        }
        a = 20;
        System.out.println(a);
    }
}

报错：
在这里插入图片描述
分析：
在这里插入图片描述
所以当执行a = 20；这条语句时，a出现未定义的情况。

  1. 构造代码块，又叫 非静态代码块 又叫 实例代码块：定义在 类的里面，方法的外面，一般用于初始化实例成员变量，即初始化非静态的成员变量。在构造方法之前就可以对成员变量赋值。
class Dog {
    private String name;
    private int age;



    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("构造方法被调用");
    }
    {
        this.name = "小狗";
        this.age = 12;
        System.out.println("实例代码块");
    }

    public void eat() {
        System.out.println(name + "吃饭");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}


public class Test3 {
    public static void main(String[] args) {
        Dog dog = new Dog("小dog",1);
        System.out.println(dog.getAge());
        System.out.println(dog.getName());
    }
}

运行结果：
在这里插入图片描述

分析：通过运行结果，可以看到实例代码块在构造方法之前运行，因此最后实例化出来的对象name值和age值为构造方法传入的形参值，而不是实例代码块的值。
可以简单认为：编译器编译好代码之后，会把非静态代码块的东西放到构造方法的最前面。
在这里插入图片描述

如果都是非静态的，那么看定义的顺序，谁在后，最后就是哪个值。

    {
        this.name = "小狗";
        this.age = 1;
        System.out.println("实例代码块1");
    }

    {
        this.name = "小狗狗";
        this.age = 2;
        System.out.println("实例代码块2");
    }
    {
        this.name = "小狗狗狗";
        this.age = 3;
        System.out.println("实例代码块3");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.getAge());
        System.out.println(dog.getName());
    }

运行结果：
在这里插入图片描述
分析：因为实例代码块3在最后，所以最后非静态成员变量name和age的值为实例代码块3赋值的结果。

  1. 静态代码块，给代码块加static即可，作用：初始化静态的数据成员，提前准备一些数据。
    使用static定义的代码块称为静态代码块，一般用于初始化静态成员变量，也是在类的里面，方法的外面。
class Stu {
    private String name;
    private int age;
    private static String classRoom = "一年级1班";

    {
        this.age = 21;
        this.name = "小王";
        System.out.println("实例代码块");
    }
    static {
        classRoom = "一年级2班";
        System.out.println("静态代码块1");
    }
    static {
        classRoom = "一年级3班";
        System.out.println("静态代码块2");
    }

    public static String getClassRoom() {
        return classRoom;
    }
    public static void setClassRoom(String classRoom) {
        Stu.classRoom = classRoom;
    }

}

public class Test4 {
    public static void main(String[] args) {
        System.out.println(Stu.getClassRoom());
    }
}

运行结果：
在这里插入图片描述
分析：实例代码块并没有被调用，因为实例代码块只有在创建对象时才会执行。这个类中有2个静态代码块，在代码编译的时候，编译器会按照定义的先后次数依次执行（合并）。

class Stu {
    private String name;
    private int age;
    private static String classRoom = "一年级1班";

    {
        this.age = 21;
        this.name = "小王";
        System.out.println("实例代码块");
    }
    static {
        classRoom = "一年级2班";
        System.out.println("静态代码块");
    }
//    static {
//        classRoom = "一年级3班";
//        System.out.println("静态代码块2");
//    }

    public Stu(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("构造方法");
    }

    public static String getClassRoom() {
        return classRoom;
    }
    public static void setClassRoom(String classRoom) {
        Stu.classRoom = classRoom;
    }
    public void show() {
        System.out.println("姓名：" + name + "，年龄：" + age + "，班级：" + classRoom);
    }

}

public class Test4 {
    public static void main(String[] args) {
        Stu s = new Stu("小王",22);
        s.show();

    }
    public static void main1(String[] args) {
        System.out.println(Stu.getClassRoom());
    }
}

运行结果：
在这里插入图片描述
分析：通过运行结果，可以发现代码块的执行顺序时：①静态代码块②非静态代码块（实例代码块）③构造方法。
静态代码块不管生成多少个对象，都只会执行一次。

    public static void main(String[] args) {
        Stu s1 = new Stu("小王",22);
        System.out.println("!!!!!!");
        Stu s2 = new Stu("小王",22);
    }

运行结果：
在这里插入图片描述
分析：代码中实例化了2次对象，但是静态代码块只执行了1次。

    static {
        classRoom = "一年级2班";
        System.out.println("静态代码块");
    }
    private static String classRoom = "一年级1班";

运行结果：
在这里插入图片描述
分析：多个静态的，看先后顺序，取最后一次赋值。

  1. 对象的打印
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person);
    }

运行结果：
在这里插入图片描述
分析：Person是类名的全路径，1b6d3586为真实地址的哈希值，可以近似理解为就是唯一的地址，存的是堆上对象的地址。【为什么是这个打印结果——进printIn源码中寻找答案】
在这里插入图片描述
因此我们想要用printIn打印对象的属性，我们只需要重写toString方法

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public static void main(String[] args) {
        Person person = new Person("小王",22);
        System.out.println(person);
    }

运行结果：
在这里插入图片描述
分析：对于你想输出一个对象的引用的值的时候，如果你没有自己写一个toString方法，那么就会调用Object这个类的toStriing方法，如果自己写了，则调用自己写的toSting方法。

CodeKnightShuai
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Java——代码块
qq_59708493的博客
05-17 1387
> 代码块又称为初始化块，属于类中的成员（类的一部分），类似于方法，讲逻辑语句封装在方法体中，用{}抱起来； > > 但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用。 基本语法 > （修饰符）（可有可无）{代码}； > 注： > 1.修饰符可选，要写只能写static > 2.代码块可分为两类，使用static修饰的叫静态代码块，没有static修饰的叫普通代码块。 > 3.；可有可无
静态方法和静态代码块
qq_43644198的博客
09-22 544
静态方法 形成了静态方法。属于类而不再属于对象了，应该由类来访问，但是对象也可以访问。 普通的方法由对象调用。 静态方法中：只能访问属于类，不能访问属于对象。 A：访问静态属性 B：访问静态方法 C：不能直接访问非静态属性 D：不能直接访问非静态方法 非静态方法中：属于类，属于对象都可以访问 A：访问静态属性 B：访问静态方法 C：访问非静态属性 D：访问非静态方法 静态代码块 代码块，就是一块代码。使用{}包裹起来的。 普通代码块：{}包裹起来一段代码。注意作用域。
面向对象--代码块--静态代码块与构造代码块详解
赤兔胭脂小吕布的博客
12-14 164
Java中静态代码块与构造代码块的执行顺序 静态代码块：用staitc声明，jvm加载类时执行，仅执行一次构造代码块：类中直接用{}定义，每一次创建对象时执行。执行顺序优先级：静态代码块➡main()➡构造代码块➡构造方法。 构造方法 public HelloA(){ //构造方法 } 关于构造方法，以下几点要注意： 对象一建立，就会调用与之相应的构造方法，也就是说，不建立对象，构造方法是不会...
成员代码块和静态代码块的区别
weixin_45290168的博客
07-18 232
成员代码块和静态代码块的区别？ 成员代码块： 在类的内部 方法的外部 先执行代码块 再执行 构造器 创建几个对象 执行几次 成员代码块 当拥有多个成员代码块时 从上到下依次执行 可以给成员变量进行赋值 静态代码块： 只会执行一次 先于构造器执行 静态代码块 用于对静态变量执行初始化操作 当存在多个静态代码块时 从上到下依次执行 ...
java基础笔记1 new，static关键字
qq_59294119的博客
03-28 565
面向对象 （一）访问控制四种：public，private，default,protected 封装：在外部类不能随意访问，使用方法为了更好的管理，提供安全的访问方式，只能在内部类访问 构造方法（不可写void，不然就不是构造方法了） 必须用new关键字调用 相当于生活中某商品的生产线，每一个类默认提供一个无参的构造方法 （1）构造方法名称和类名一样 （2）构造方法没有返回类型 （3）构造方法不能使用return语句返回内容，但是可以单独写return语句作为方法的结束 关键字 1，th
Java中的static静态代码块的使用详解
09-05
类`StaticBlock`的执行顺序展示了静态代码块和构造块的执行次序：静态代码块先执行，然后是非静态代码块，最后是构造方法。每次创建新对象时，这个顺序都会重复。 5. **执行顺序：** - 类的加载：静态变量初始化...
Java面向对象（高级）- 类的成员之四：代码块
最新发布
11-19
Java面向对象编程中的类成员之一是代码块，这部分内容主要探讨了Java中代码块的概念、分类、用途以及执行时机。代码块在Java中扮演着初始化类或对象成员变量的角色，特别是在需要复杂计算或获取外部信息来设定初始值...
java 代码块与静态代码块加载顺序
08-29
在 Java 语言中，代码块和静态代码块的加载顺序是严格按照类的加载顺序执行的。具体来说，类的加载顺序如下： 1. 父类静态代码块 2. 子类静态代码块 3. 父类实例代码块 4. 子类实例代码块 在上面的实例代码中，...
Java静态代码块作用及执行顺序解析
08-19
Java静态代码块是Java语言中的一种特殊代码块，它们在类加载的时候执行，且只执行一次。它们通常用来初始化静态变量、设置静态变量的初始值等。静态代码块的作用域是整个类，而不是某个对象实例。 静态代码块的执行...
java static块和构造函数的实例详解
08-29
在 Java 中，static 块是指在类加载时执行的代码块。它们通常用于初始化静态变量、静态方法和静态块本身。Static 块的执行顺序是按照它们在类中的出现顺序执行的。需要注意的是，static 块在类加载时只执行一次，...
Java静态代码块中静态变量初始化报错
明明
01-06 1446
Web服务器中使用Java类中某个参数是从文件中读取的，所以使用了静态代码块读取文件并给静态变量赋值，但是因为某种原因Web服务器突然报错某个空指针异常，但是堆栈报错信息追踪不到具体的错误文件的行数。最后查看原来静态代码块读取文件的文件内容是有问题，但是因为代码处于静态代码块中所以报出错误为Error级别的异常，所以catch 异常没用catche住。所以无法追踪问题位置。 ...
Static用法详解及代码块执行时刻、创建和初始化对象的过程
m0_58339106的博客
08-15 2193
目录 Static用法详解 1、静态属性 1.1、静态属性的存储位置 1.2、静态属性的初始化 内存图 2、静态方法 2.1、静态方法的调用 3、静态代码块 3.1、什么是静态代码块 3.2、静态代码块的执行时刻 3.3、匿名代码块 3.3、匿名代码块执行的时刻 创建和初始化对象的过程 静态导入 Static用法详解 1、静态属性 在类中，使用static修饰的属性，就是静态属性。例如， public...
Java中static的用法
TuttuYYDS的博客
05-11 1076
Java中static的用法
java 静态块exception_java含有静态代码块新建的时候报错java.lang.ExceptionInInitializerError...
weixin_33268492的博客
02-13 376
问题描述最近在写一些单元测试用例，为了避免连接外界服务，所有选择mock了数据库Dao层，计划将数据库所需要的数据存在List中，在类加载的时候初始化List并且填充数据。代码如下：1 public class UserDaoMock extendsUserDao {2 @Override3 public ListselectUserInfo() {4 returngetU...
java静态方法不能创建内部类对象
meng70345meng的专栏
12-08 1364
public class Test { private String name; public static void main(String[] args) { InnerClass inner = new InnerClass();//这里会出现错误 System.out.println(inner); } class InnerClass{ public void...
Java创建对象数组报错：java.lang.NullPointerException
tjk12345的博客
11-02 998
错误代码： class Student { public int id; } public class Test { public static void main(String[] args) { Student[] students = new Student[100]; for (int i = 0; i < 100; i++) { students[i].id = i; } } } 代码未报错，
static静态关键字详解(工具类、代码块、单例模式)
weixin_53622554的博客
02-10 3478
静态成员变量(类变量)静态方法（类方法）。可以被类的所有对象共享（访问、修改）
Java中关键字“static”以及代码块的详解
Superkom666的博客
08-18 966
java中被static修饰的变量被称为当我们的变量被static修饰以后我们的变量就不在存储到里面，而是存放在里面这也就意味着静态成员是不属于某一个对象的，而是大家所共享的静态成员的生命周期是随着在类里面创建所诞生的，随着类的销毁所销毁的。...
用java代码实现查询数据库
weixin_67481784的博客
09-05 7024
用java代码实现查询数据库
Java面向对象高级：深入理解代码块分类与执行
1. 类及类的内部成员：Java面向对象的核心围绕着类展开，包括类的属性（如成员变量）、方法（实现功能）、构造器（用于创建对象）、代码块（封装代码）以及内部类。类的三大特性，即封装、继承和多态，是设计良好类...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CodeKnightShuai

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值