JavaSE类和对象

已于 2024-03-30 20:13:26 修改
阅读量996 收藏 32
点赞数 40
分类专栏： JavaSE 文章标签： java 开发语言 算法
于 2024-03-30 18:30:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_61196535/article/details/137131143
版权
本文围绕Java面向对象编程展开，介绍了面向对象的过程，类的定义、使用、实例化及数据访问，还阐述了this引用、对象构造与初始化、封装、static成员类和代码块等内容，包括各部分的概念、特性、使用方法及注意事项。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

1.面向对象

1.1面向对象的过程

2.类的定义和使用

2.1定义

2.2使用

2.2.1实例化

2.2.2访问类中数据 

2.3类和对象说明

 3.this引用

4.对象的构造及初始化

4.1初始化对象

4.2构造方法

4.2.1特性

4.3默认初始化

 4.4就地初始化

 5.封装

5.1概念

​编辑 5.2访问限定符

 5.3private实现封装

5.4包

5.4.1概念

5.4.2导入包中的类

 5.4.3自定义包

 5.4.4常见的包

 6.static成员类

6.1static修饰成员变量

 6.2static修饰成员方法

6.3成员变量的初始化

7.代码块

 7.1普通块

 7.2构造代码块

 7.3静态代码块

7.4执行顺序

1.面向对象

Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。

1.1面向对象的过程

传统洗衣过程（面向结果）

 传统的方式：注重的是洗衣服的过程，少了一个环节可能都不行。

而且不同衣服洗的方式，时间长度，拧干方式都不同，处理起来就比较麻烦。如果将来要洗鞋子，那就是另 一种放方式。 按照该种方式来写代码，将来扩展或者维护起来会比较麻烦。

现代洗衣过程（面向对象）

以面向对象方式来进行处理，就不关注洗衣服的过程，具体洗衣机是怎么来洗衣服，如何来甩干的，用户不用去关 心，只需要将衣服放进洗衣机，倒入洗衣粉，启动开关即可，通过对象之间的交互来完成的。

注意：面向过程和面相对象并不是一门语言，而是解决问题的方法，没有那个好坏之分，都有其专门的应用场景。  

2.类的定义和使用

2.1定义

面相对象程序设计关注的是对象，而对象是现实生活中的实体，比如：洗衣机。但是洗衣机计算机并不认识，需要 开发人员告诉给计算机什么是洗衣机。

上图左侧就是对洗衣机简单的描述，该过程称为对洗衣机对象(实体)进行抽象(对一个复杂事物的重新认知)，但是 这些简化的抽象结果计算机也不能识别，开发人员可以采用某种面相对象的编程语言来进行描述，比如：Java语言。  

类是用来对一个实体(对象)来进行描述的

主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干 啥)，描述完成后计算机就可以识别了。

比如：洗衣机，它是一个品牌，在Java中可以将其看成是一个类别。 属性：产品品牌，型号，产品重量，外观尺寸，颜色... 功能：洗衣，烘干、定时....

定义格式：

/ 创建类
class ClassName{  
    field;       // 字段(属性) 或者 成员变量
    method;      // 行为 或者 成员方法
}

//class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。

方法主要说明类 具有哪些功能，称为类的成员方法。

class WashMachine{
    public String brand;   // 品牌
    public String type;    // 型号
    public double weight;  // 重量
    public double length;  // 长
    public double width;  // 宽
    public double height;  // 高
    public String color;   // 颜色
    
    //以上称为类的成员属性或者类成员变量

    public void washClothes(){   // 洗衣服
        System.out.println("洗衣功能");
   }
    
    public void dryClothes(){    // 脱水
        System.out.println("脱水功能");
   }
    
    public void setTime(){       // 定时
        System.out.println("定时功能");

    //以上称为类的成员方法。
   }
}

方法出了作用域就会失效

采用Java语言将洗衣机类在计算机中定义完成，经过javac编译之后形成.class文件，在JVM的基础上计算机就可以 识别了。

注意事项：

  • 类名注意采用大驼峰定义
  • 成员前写法统一为public，后面会详细解释
  • 此处写的方法不带 static 关键字. 后面会详细解释
class PetDog {
    public String name;//名字
    public String color;//颜色
 
    // 狗的属性
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
   }
    
    // 狗的行为
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
   }
}

 注意事项：

  •  一般一个文件当中只定义一个类
  • main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)
  • public修饰的类必须要和文件名相同
  • 不要轻易去修改public修饰的类的名称

2.2使用

2.2.1实例化

定义了一个类，就相当于在计算机中定义了一种新的类型 

用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

public class Test{
 public static void main(String[] args) {
        Washmachine wanshmachine1 = new Washmachine();     //通过new实例化对象
        Washmachine wanshmachine1 = new Washmachine();
}

 一个类 可以创建多个实例化对象

 

2.2.2访问类中数据 

public class Main{
 public static void main(String[] args) {
        PetDog dogh = new PetDog();     //通过new实例化对象
        dogh.name = "阿黄";
        dogh.color = "黑黄";
        dogh.barks();
        dogh.wag();
        
        PetDog dogs = new PetDog();
        dogs.name = "阿黄";
        dogs.color = "黑黄";
        dogs.barks();
        dogs.wag();
 }
}

 

注意事项

  • new 关键字用于创建一个对象的实例.
  • 使用 . 来访问对象中的属性和方法.
  • 同一个类可以创建多个实例.

2.3类和对象说明

  1. 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.
  2. 类是一种自定义的类型，可以用来定义变量.
  3. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量
  4. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东 西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

 3.this引用

this 代表当前对象的引用,可以借助 this 来访问对象的字段和方法.

public class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(int y,int m,int d) {
        year = y;
        month = m;
        day = d;
    }
    public void printDate() {
        System.out.println(year + "年 " + month + "月 " + day + "日");
    }

    public static void main(String[] args) {
        Date d1 = new Date();
        Date d2 = new Date();
        Date d3 = new Date();

        d1.setDay(2022,3,2);
        d2.setDay(2023,4,2);
        d3.setDay(2024,5,2);

        d1.printDate();
        d2.printDate();
        d3.printDate();
    }
}

注意事项：

1. 形参名不小心与成员变量名相同

public void setDay(int year, int month, int day){
    year = year;
    month = month;
    day = day;
}

 那函数体中到底是谁给谁赋值？成员变量给成员变量？参数给参数？参数给成员变量？成员变量参数？

2. 三个对象都在调用setDate和printDate函数，但是这两个函数中没有任何有关对象的说明，setDate和 printDate函数如何知道打印的是那个对象的数据呢？

所有成员变量均通过this关键字来访问 

注意事项：

  • this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
  • this只能在"成员方法"中使用
  • 在"成员方法"中，this只能引用当前对象，不能再引用其他对象
  • this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法 对象的引用传递给该成员方法，this负责来接收

规范后的代码

public class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(Date this,int y,int m,int d) {
        this.year = y;
        this.month = m;
        this.day = d;
    }
    public void printDate() {
        System.out.println(this.year + "年 " + this.month + "月 " + this.day + "日");
    }

    public static void main(String[] args) {
        Date d1 = new Date();
        d1.setDay(2022,3,2);
        d1.printDate();


        Date d2 = new Date();
        d2.setDay(2023,4,2);
        d2.printDate();
    }
}

4.对象的构造及初始化

4.1初始化对象

//以下代码不会正常编译，无法正确初始化
public static void main(String[] args) {
    Date d = new Date();
    d.printDate();
    d.setDate(2021,6,9);
}


//以下代码可以正常编译
public static void main(String[] args) {
    Date d = new Date();
    d.setDate(2021,6,9);
    d.printDate();
}


//要先进行初始化再打印

1. 每次对象创建好后调用SetDate方法设置具体日期，比较麻烦，那对象该如何初始化？

2. 局部变量必须要初始化才能使用，为什么字段声明之后没有给值依然可以使用？

4.2构造方法

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且 在整个对象的生命周期内只调用一次。

public class Date {
    public int year;
    public int month;
    public int day;
 
    // 构造方法：
    // 名字与类名相同，没有返回值类型，设置为void也不行
    // 一般情况下使用public修饰
    // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
    public Date(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
        System.out.println("Date(int,int,int)方法被调用了");
   }
 
    public void printDate(){
        System.out.println(year + "年 " + month + "月 " + day + "日");
   }
 
    public static void main(String[] args) {
        // 此处创建了一个Date类型的对象，并没有显式调用构造方法
        Date d = new Date(2022,3,2);   // 输出Date(int,int,int)方法被调用了
        d.printDate();    
   }
}

注意：

  • 构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。  

4.2.1特性

构造方法没有返回值，且方法名和类名相同

构造方法是用来实例化对象的

  1. 名字必须与类名相同
  2. 没有返回值类型，设置为void也不行
  3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
  4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)
public class Date {
    public int year;
    public int month;
    public int day;
    
    // 无参构造方法
    public Date(){
        this.year = 1900;
        this.month = 1;
        this.day = 1;
   }
// 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
   }
 
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
   }
 
    public static void main(String[] args) {
        Date d = new Date();
        d.printDate();
   }
}

上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载。

5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。

public class Date {
    public int year;
    public int month;
    public int day;
 
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
   }
 
    public static void main(String[] args) {
        Date d = new Date();
        d.printDate();
   }
}

 上述Date类中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法。 

注意：

  • 一旦用户定义，编译器则不再生成。
public class Date {
    public int year;
    public int month;
    public int day;
 
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
   }
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
   }
 
    public static void main(String[] args) {
        // 如果编译器会生成，则生成的构造方法一定是无参的
        // 则此处创建对象是可以通过编译的
        // 但实际情况是：编译期报错
        Date d = new Date();
        d.printDate();
   }
}
 
/*
Error:(26, 18) java: 无法将类 extend01.Date中的构造器 Date应用到给定类型;
  需要: int,int,int
  找到: 没有参数
  原因: 实际参数列表和形式参数列表长度不同
*/

6. 构造方法中，可以通过this调用其他构造方法来简化代码

public class Date {
    public int year;
    public int month;
    public int day;
    
    // 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
    // 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
    // 但是this(1900,1,1);必须是构造方法中第一条语句
    public Date(){
        //System.out.println(year);   注释取消掉，编译会失败
        this(1900, 1, 1);
        
        //this.year = 1900;
        //this.month = 1;
        //this.day = 1;
   }
 
    // 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
   }
}
public class Dog {
    public String name;
    public int age;
    public String color;

    public Dog(){
        this("大黄",9,"黄色");
        System.out.println("不带参数的构造方法！");
    }

    public Dog(String name, int age, String color) {
        //this(); error
        this.name = name;
        this.age = age;
        this.color = color;
        System.out.println(" Dog(String name, int age, String color) ");
    }

    public void show() {
        System.out.println("姓名："+this.name+" 年龄："+this.age+" 颜色："+this.color);
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.show();

    }
}

注意：

this(...)必须是构造方法中第一条语句

不能形成环

public Date(){
   this(1900,1,1);
}
 
public Date(int year, int month, int day) {
   this();
}
 
/*
无参构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，形成构造器的递归调用
编译报错：Error:(19, 12) java: 递归构造器调用
*/

4.3默认初始化

为什么局部变量在使用时必须要初始化，而成员变量可以不用呢？

public class Date {
    public int year;
    public int month;
    public int day;
 
    public Date(int year, int month, int day) {
        // 成员变量在定义时，并没有给初始值, 为什么就可以使用呢？
        System.out.println(this.year);
        System.out.println(this.month);
        System.out.println(this.day);
   }
    
    public static void main(String[] args) {
        // int a;
        // System.out.println(a);

        // 此处a没有初始化，编译时报错：
        // Error:(24, 28) java: 可能尚未初始化变量a

        Date d = new Date(2021,6,9);
   }
}

 

具体原因还需要我们更加深入的学习来逐步了解 

 4.4就地初始化

在声明成员变量时，就直接给出了初始值。

public class Date {
    public int year = 1900;
    public int month = 1;
    public int day = 1;
 
    public Date(){
   }
 
    public Date(int year, int month, int day) {
   }
 
    public static void main(String[] args) {
        Date d1 = new Date(2021,6,9);
        Date d2 = new Date();
   }
}

 注意：

  • 代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中

 5.封装

5.1概念

面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说 就是套壳屏蔽细节。

 5.2访问限定符

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符：

  • public：可以理解为一个人的外貌特征，谁都可以看得到
  • default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了
  • private：只有自己知道，其他人都不知道
  • public谁都可以访问
  • protected主要是用在继承中
  • default权限指：什么都不写时的默认权限
  • 访问权限除了可以限定类中成员的可见性，也可以控制类的可见性  

 5.3private实现封装

public class Dog {
    private String name = "大黄";
    private int age = 5;
    private String color = "黄";
    
    //此时被private修饰的成员变量只能在当前Dog类下使用    

    public void show() {

        System.out.println("姓名："+this.name+" 年龄："+this.age+" 颜色："+this.color);
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.show();
    }
}

此时字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用. 而需要借助 show 方法.

private 不光能修饰字段, 也能修饰方法

通常情况下我们会把字段（成员变量）设为 private 属性, 但是方法是否需要设为 public, 就需要视具体情形而定. 一般我们希望一个类只提供 “必要的” public 方法, 而不应该是把所有的方法都无脑设为 public.

5.4包

5.4.1概念

为了更好的管理类，把多个类收集在一起成为一组，称为软件包

 在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一 个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在 不同的包中即可。

5.4.2导入包中的类

例如Date类：可以使用 java.util.Date 导入 java.util 这个包中的 Date 类.

public class Test {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
   }
}

使用 import语句导入包.

import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
   }
}
  • 如果需要使用 java.util 中的其他类, 可以使用 import java.util.*
  • *相当于是一个通配符，将包中所有的类全部导入进去
  • 更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.

可以使用import static导入包中静态的方法和字段。  

import static java.lang.Math.*;
public class Test {
 public static void main(String[] args) {
 double x = 30;
 double y = 40;
        
 // 静态导入的方式写起来更方便一些.
 // double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
 double result = sqrt(pow(x, 2) + pow(y, 2));
 System.out.println(result);
 }
}

 5.4.3自定义包

  • 在文件的最上方加上一个 package 语句指定该代码在哪个包中.
  • 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).
  • 包名要和代码路径相匹配. 例如创建 com.baidu.www 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储 代码.
  • 如果一个类没有 package 语句, 则该类被放到一个默认包中.

 5.4.4常见的包

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。

2. java.lang.reflect:java 反射编程包;

3. java.net:进行网络编程开发包。

4. java.sql:进行数据库开发的支持包。

5. java.util:是java提供的工具程序包。(集合类等) 非常重要

6. java.io:I/O编程开发包。

 6.static成员类

public class Student{
    // ...
    public static void main(String[] args) {
        Student s1 = new Student("张三", "男", "112");
        Student s2 = new Student("李四", "女", "112");
        Student s3 = new Student("王五", "男", "112");
   }
}

 被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对 象，是所有对象所共享的。

6.1static修饰成员变量

static修饰的成员变量，称为静态成员变量

静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

静态成员变量特性：

  • 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
  • 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
  • 类变量存储在方法区当中
  • 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)  
public class Student{
    public String name;
    public String sex;
    public static String classRoom = "Bit306";
    
    // ...
    
    public static void main(String[] args) {
        // 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
 
        Student s1 = new Student("张三", "男", "112");
        Student s2 = new Student("李四", "女", "112");
        Student s3 = new Student("王五", "男", "112");
 
        // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);
   }
}

 

 6.2static修饰成员方法

 一般类中的数据成员都设置为private，而成员方法设置为public，那设置之后，Student类中classRoom属性如何 在类外访问呢？

被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过 静态方法来访问的。

public class Student{
    // ...
    
    private static String classRoom = "Bit306";
    
    // ...
    
    public static String getClassRoom(){
        return classRoom;
   }
}
 
public class TestStudent {
    public static void main(String[] args) {
        System.out.println(Student.getClassRoom());
   }
}

静态方法特性

  • 不属于某个具体的对象，是类方法 
  • 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者 
  • 不能在静态方法中访问任何非静态成员变量
public static String getClassRoom(){
    System.out.println(this);
    return classRoom;
}
 
// 编译失败：Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
 
public static String getClassRoom(){
    age += 1;
    return classRoom;
}
 
// 编译失败：Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age

4. 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用，非静态可以调用静态

public static String getClassRoom(){
    doClass();
    return classRoom;
}
 
// 编译报错：Error:(35, 9) java: 无法从静态上下文中引用非静态 方法 doClass()

6.3成员变量的初始化

注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性 

 静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化。

1. 就地初始化

public class Student{
    private String name;
    private String gender;
    private int  age;
    private double score;
    private static String classRoom = "112";  
    
    // ...
}

2. 静态代码块初始化

7.代码块

使用 {} 定义的一段代码称为代码块。

根据代码块定义的位置以及关键字，又可分为以下四种：

1.普通代码块
2.构造块
3.静态块
4.同步代码块（后续讲解多线程部分再谈） 

 7.1普通块

public class Main{
 public static void main(String[] args) {
 { 
     //直接使用{}定义，普通方法块
     int x = 10 ;
     System.out.println("x1 = " +x);
 }
     int x = 100 ;
     System.out.println("x2 = " +x);
 }
}

 7.2构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块/非静态代码块。构造代码块一般用于初始化实例成员变量。

 定义在类中，与成员变量和成员方法为同一级

 7.3静态代码块

使用static定义的代码块称为静态代码块 。 一般用于初始化静态成员变量 。

 

注意事项

  • 静态代码块不管生成多少个对象，其只会执行一次
  • 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
  • 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
  • 实例代码块只有在创建对象时才会执行  

7.4执行顺序

实例代码块优先于构造代码块执行

class Student {

    int age;

    {
        System.out.println("这是实例化代码块");
    }
    
    public Student (){
        this.age = age;
        System.out.println("不带参数的构造方法");
    }

//    {
//        System.out.println("这是实例化代码块");
//    }

}

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
    }
}

 

 实例成员变量和构造块有先后顺序

class Student {
    private String name = "abc";
    int age;

    {
        this.name = "zsj";
        System.out.println("这是实例化代码块");
    }

    public Student (){
        this.age = age;
        System.out.println("不带参数的构造方法");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //    {
//        System.out.println("这是实例化代码块");
//    }

}

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.getName());
    }
}

 

 

静态、实例代码块一起运行时的顺序

class Student {
    int age;
    public Student() {
        System.out.println("这是构造方法");
    }

    {
        System.out.println("这位是实例化代码块");
    }
    static {
        System.out.println("这是静态代码块2");
    }
    static {
        System.out.println("这是静态代码块1");
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
    }
}

 

 静态代码块是根据我们书写代码的顺序进行执行的,按顺序执行。

总结：静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。 

评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值