Java——类与对象

一、面向对象的初步认识

1.1 什么是面向对象

1.2 面向对象与面向过程

二、类的定义与使用

2.1 简单认识类

2.2 类的定义格式

三、类的实例化

3.1 什么是实例化

3.2 类和对象的说明

四、this引用

4.1 为什么要有this引用

4.2 什么是this引用

编辑

4.3 this引用的特性

五、对象的构造及初始化

5.1 初始化对象的成员变量

5.1.1 默认初始化

编辑

5.1.2 就地初始化

5.2 构造方法

5.2.1 概念

5.2.2 特性

5.2.3 构造方法中的this引用

六、封装

6.1封装

6.2 访问修饰限定符

6.3 封装扩展包

6.3.1 导入包中的类

6.3.2 自定义包

6.3.3 包的访问权限控制

6.3.4 常见的包

七、static成员

7.1 再说前文人类

7.2 static修饰成员变量

7.3 static修饰成员方法

7.4 static成员变量初始化

7.4.1 就地初始化

7.4.2 静态代码块初始化

八、代码块

8.1 代码块概念及分类

8.2 普通代码块

8.3 构造代码块儿

8.4 静态代码块

九、对象的打印

一、面向对象的初步认识

1.1 什么是面向对象

Java 是一门纯面向对象的语言 (Object Oriented Program ，简称 OOP) ，在面向对象的世界里，一切

皆为对象。

面 向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情 。用面向对象的思想来涉

及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。

1.2 面向对象与面向过程

常说C语言是面向过程，Java是面向对象。

那什么是面向对象，什么是面向过程呢？

简单举个例子，现在我要将一个大象装入冰箱里。如何思考这个问题

那么大部分情况下，首先想到的就是，怎么打开冰箱门，怎么装进去，怎么又关上冰箱门。

这就是面向过程。

而我还可以这样想

整个过程是冰箱、人、大象这三个对象交互完成的，具体这个冰箱门怎么打开的，大象怎么关进去

的，冰箱门又是怎么关上的这些过程不关注。全程都是由三个对象交互完成的

这就是面向对象。

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

门的应用场景。

二、类的定义与使用

面相对象程序设计关注的是对象，而对象是现实生活中的实体，比如：人。但是计算机他并不认识

需要开发人员去告诉计算机什么是人

上图左侧就是 对人简单的描述，该过程称为对人对象 ( 实体 ) 进行抽象 ( 对一个复杂事物的重新认

知 ) ，但是这些简化的抽象结果计算机也不能识别，开发人员可以采用某种面相对象的编程语言来

进行描述，比如：Java 语言。

2.1 简单认识类

类是用来对一个实体 ( 对象 ) 来进行描述的 ，主要描述该实体 ( 对象 ) 具有哪些属性 ( 外观尺寸等 ) ，哪些

功能 ( 用来干啥) ，描述完成后计算机就可以识别了。

在 Java 语言中，如何对上述的人类来进行定义呢？

2.2 类的定义格式

在 java 中定义类时需要用到 class 关键字 ，具体语法如下

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

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

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

public class Person{
    public String name;
    public String sex;
    public String edbd;//Educational background
    public String occupation;
    public String interest;
    public int age;
    public float  height;

    public void eat(){
        System.out.println(name+"正在吃饭");
    }
    public void  sleep(){
        System.out.println(name+"正在睡觉");
    }
    public void walk(){
        System.out.println(name+"正在散步");
    }
}

采用 Java 语言将人类在计算机中定义完成，经过 javac 编译之后形成 .class 文件，在 JVM 的基础

上计算机就可以识别了。

注意事项

1.类名注意采用大驼峰定义

2.成员前写法统一为 public ，以后的文章会详细解释

3.此处写的方法不带 static 关键字 . 以后的文章会详细解释

4. 一般一个文件当中只定义一个类

5. main 方法所在的类一般要使用 public 修饰 ( 注意： Eclipse 默认会在 public 修饰的类中找 main 方法 )

6. public 修饰的类必须要和文件名相同

三、类的实例化

3.1 什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型 ，与 int ， double 类似，只不过 int 和 double

是 java 语言自带的内置类型，而类是用户自定义了一个新的类型，比如人类。它们都是类(一种新

定义的类型) 有了这些自定义的类型之后，就可以使用这些类来定义实例 ( 或者称为对象 ) 。

形式上与C语言中的结构体类似

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

注意事项

new 关键字用于创建一个对象的实例.

使用 . 来访问对象中的属性和方法 .

同一个类可以创建多个实例 .

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.age = 18;
        person.name = "张三";
        person.edbd = "本科";
        person.height = 1.75f;
        person.eat();
        person.sleep();
    }
}

3.2 类和对象的说明

1. 类只是 一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员 .

2. 类是一种自定义的类型 ，可以用来定义变量 .

3. 一个类可以实例化出多个对象， 实例化出的对象占用实际的物理空间，存储类成员变量

4. 做个比方。 类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图 ，只设计出

需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际

存储数据，占用物理空间

一个Java文件中可以有多个类，被 public修饰的类，该类名必须与Java文件名相同

四、this引用

4.1 为什么要有this引用

class Person{
    public String name ;
    public  int age ;

    public void sleep(){
        System.out.println(this.name+"正在睡觉！");
    }
    public void eat(){
        System.out.println(this.name+"正在吃饭！");
    }
    public void setperson1(String name,int age){
        name = name;
        age = age;
    }
 
    public void printperson(){
        System.out.println(name);
        System.out.println(age);
    }
}

public class Javacode{

    public static void main(String[] args) {
        Person person = new Person();
        person.setperson1("卢本伟",18);
        person.printperson();
        person.setperson1("卢本伟",18);
        person.printperson();
    }
}

形参名与成员变量名相同

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

数？

两个对象都在调用setperson1和printperson函数，但是这两个函数中没有任何有关对象说

明,setperson和 printperson函数如何知道打印的是那个对象的数据呢？

4.2 什么是this引用

这里可以认为这里有一个隐藏的参数

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操

作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自

动完成。

class Person{

    public String name ;
    public  int age ;

    public void sleep(){
        System.out.println(this.name+"正在睡觉！");
    }
    public void eat(){
        System.out.println(this.name+"正在吃饭！");
    }
    public void setperson1(String name,int age){
        name = name;
        age = age;
    }
    public void setperson2(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void printperson(){
        System.out.println(this.name);
        System.out.println(this.age);
    }
}
public class Javacode{


    public static void main(String[] args) {
        Person person = new Person();
        person.setperson2("卢本伟",18);
        person.printperson();
        person.setperson2("666",20);
        person.printperson();
    }
}

在进行成员方法的定义时，若要调用成员变量，都带上this,这样赋值就不会错。

同时，在成员方法中，可以使用this来调用另一个成员方法

class Person{

    public String name ;
    public  int age ;

    public void sleep(){
        System.out.println(this.name+"正在睡觉！");
    }
    public void eat(){
        System.out.println(this.name+"正在吃饭！");
    }
    public void setperson1(String name,int age){
        name = name;
        age = age;
    }
    public void setperson2(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void printperson(){
        this.eat();
        this.sleep();
        System.out.println(this.name);
        System.out.println(this.age);

    }
}
public class Javacode{


    public static void main(String[] args) {
        Person person = new Person();
        person.setperson2("卢本伟",18);
        person.printperson();
        person.setperson2("666",20);
    }

4.3 this引用的特性

1. this 的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型

2. this 只能在 " 成员方法 " 中使用

3. 在 " 成员方法 " 中， this 只能引用当前对象，不能再引用其他对象

4. this 是 “ 成员方法 ” 第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将

调用成员方法对象的引用传递给该成员方法，this 负责来接收

五、对象的构造及初始化

5.1 初始化对象的成员变量

5.1.1 默认初始化

在使用局部变量时，不初始化编译器就会报错

但在使用成员变量就不初始化就可以使用

class Person{

    public String name ;
    public  int age ;


    public void sleep(){
        System.out.println(this.name+"正在睡觉！");
    }
    public void eat(){
        System.out.println(this.name+"正在吃饭！");
    }

    public void setperson(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void printperson(){
        System.out.println(name);
        System.out.println(age);
    }
}
public class Javacode4_28_2 {
    public static void main(String[] args) {
        Person person = new Person();
        person.printperson();
    }
}

在未对成员变量进行初始化时，Java会自动为他们进行默认初始化

数据类型	默认值
int	0
float	0.0f
double	0.0
char	'\u0000'
boolean	false
引用类型(如String)	null

5.1.2 就地初始化

即在类中就对成员变量进行初始化

class Person{

    public String name ="小明" ;
    public  int age = 12;


    public void sleep(){
        System.out.println(this.name+"正在睡觉！");
    }
    public void eat(){
        System.out.println(this.name+"正在吃饭！");
    }

    public void setperson(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void printperson(){
        System.out.println(name);
        System.out.println(age);
    }
}
public class Javacode4_28_2 {
    public static void main(String[] args) {
        Person person = new Person();
        person.printperson();
    }
}

5.2 构造方法

5.2.1 概念

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器

自动调用，并且在整个对象的生命周期内只调用一次。

5.2.2 特性

1.名字必须与类名相同

2.没有返回值类型，设置为void也不行

3.创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人

只能出生一次)

4.构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)

class Person{

    public String name ;
    public  int age ;


    public void sleep(){
        System.out.println(this.name+"正在睡觉！");
    }
    public void eat(){
        System.out.println(this.name+"正在吃饭！");
    }

    public Person(){
        this.name = "张三";
        this.age = 6;
    }
    public  void print(){
        System.out.println(this.name +" "+this.age);
    }
}

public class Javacode {
    public static void main(String[] args) {
        Person person = new Person();
        person.print();
    }
}

这里进行一下验证

class Person{

    public String name ;
    public  int age ;


    public void sleep(){
        System.out.println(this.name+"正在睡觉！");
    }
    public void eat(){
        System.out.println(this.name+"正在吃饭！");
    }

    public Person(){
        System.out.println("调用构造方法");

    }
    public  void print(){
        System.out.println(this.name +" "+this.age);
    }
}

public class Javacode {
    public static void main(String[] args) {
        Person person = new Person();
        person.print();
    }
}

class Person{

    public String name ;
    public  int age ;


    public void sleep(){
        System.out.println(this.name+"正在睡觉！");
    }
    public void eat(){
        System.out.println(this.name+"正在吃饭！");
    }

    public Person(){
        this.name = "张三";
        this.age = 6;
        System.out.println("调用构造方法");

    }
    public  void print(){
        System.out.println(this.name +" "+this.age);
    }
}

public class Javacode {
    public static void main(String[] args) {
        Person person = new Person();
        person.print();
    }
}

可以看到，是在创建对象的时候就已经调用这个方法了

那么此时看回默认初始化，在没有手动定义一个构造方法的情况下，那么编译器会自动生成一份默

认的构造方法，生成的默认构造方法一定是无参的

这里可以看到，再手动定义一个含参数构造方法后，main函数中就报错了，原因是没有传参

这说明编译器只会在没有手动定义的情况下生成一个无参的构造方法

同时说明，实例化一个对象的时候，至少是有两步是很关键的：

1.为对象分配内存

2.调用合适的构造方法

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

5.2.3 构造方法中的this引用

在构造方法中，可以通过this来调用其他构造方法

class Person{

    public String name ;
    public  int age ;


    public void sleep(){
        System.out.println(this.name+"正在睡觉！");
    }
    public void eat(){
        System.out.println(this.name+"正在吃饭！");
    }

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

    public Person(String name) {
        this.name = name;
    }

    public Person() {
         this("卢本伟",18);
    }

    public  void print(){
        System.out.println(this.name +" "+this.age);
    }
}
public class Javacode4_28_3 {
    public static void main(String[] args) {
        Person person = new Person();
        person.print();
    }

}

需要注意的是，在构造方法中使用this调用其他方法的时候，this必须是该构造方法的第一句语句

同时，不能形成环（不能自己调用自己）

在一些书和博客中，有这样的话

this代表当前对象，这句话是有歧义的

在上文中，说到了这两步，而这两步是对象在被初始化出来的过程中进行的（也就是说这时候对象

还没有完成初始化）。

所以这里更加严谨的说法应是

this代表当前对象的引用

六、封装

面向对象程序三大特性：封装、继承、多态 。而类和对象阶段，主要研究的就是封装特性。何为封

装呢？简单来说就是套壳屏蔽细节。

6.1封装

比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器，

USB 插孔等，让用户来和计算机进行交互，完成日常事务。但实际上：电脑真正工作的却是

CPU 、显卡、内存等一些硬件元件。

对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的， CPU 内部是如何

设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机

厂商在出厂时，在外部套上壳 子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘

插孔等，让用户可以与计算机进行交互即可 。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和

对象进行交互

从语法上来说，就是被private修饰的成员方法或成员变量只能在当前类中使用

6.2 访问修饰限定符

Java 中主要通过类和访问权限来实现封装： 类可以将数据以及封装数据的方法结合在一起 ，更符合

人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用 。 Java 中提供了四种访

问限定符

	范围	private	default	protected	public
1	同一包中同一类	√	√	√	√
2	同一包中不同类		√	√	√
3	不同包中的子类			√	√
4	不同包中非子类				√

比如：

public ：可以理解为一个人的外貌特征，谁都可以看得到

default: 对于自己家族中 ( 同一个包中 ) 不是什么秘密，对于其他人来说就是隐私了

private ：只有自己知道，其他人都不知道

protected 主要是用在继承中，后续文章详细介绍

default权限指：什么都不写时的默认权限

访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

注意：一般情况下成员变量设置为private，成员方法设置为public。

6.3 封装扩展包

在面向对象体系中，提出了一个软件包的概念，即： 为了更好的管理类，把多个类收集在一起成为

一组，称为软件 包。有点类似于目录。

比如：为了更好的管理电脑中的歌曲，一种好的方式就是将相同属性的歌曲放在相同文件

下，也可以对某个文件夹下的音乐进行更详细的分类。

在 Java 中也引入了包，其实就是为了更好的组织和管理类

包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式 ，比如：一

个包中的类不想被其他包中的类使用。包还有一个重要的作用： 在同一个工程中允许存在相同名称

的类，只要处在 不同的包中即可

6.3.1 导入包中的类

Java 中已经提供了很多现成的类供我们使用. 例如Scanner类

可以使用java.util.Scanner导入java.util这个包中的Scanner

public class Test2 {
    public static void main(String[] args) {
        java.util.Scanner scanner = new Scanner(System.in);
        Person person = new Person();
    }
}

但是这种写法比较麻烦 , 可以使用 import 语句导入包 .

import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Person person = new Person();
    }
}

如果需要使用 java.util 中的其他类 , 可以使用 import java.util.*

这样相当于是可以使用 java.util中的所有类

但是 更建议显式的指定要导入的类名 . 否则还是容易出现冲突 的情况 .

这里报错了

util 和 sql 中都存在一个 Date 这样的类 , 此时就会出现歧义 , 编译出错

在这种情况下需要使用完整的类名

import 和 C++ 的 #include 差别很大 . C++ 必须 #include 来引入其他文件内容 , 但是 Java 不需

要 . import 只是为了写代码的时候更方便 . import 更类似于 C++ 的 namespace 和 using

6.3.2 自定义包

基本规则

在文件的最上方加上一个 package 语句指定该代码在哪个包中.

包名需要尽量指定成唯一的名字 , 通常会用公司的域名的颠倒形式（例如com.baidu.www）

包名要和代码路径相匹配 . 例如创建com.baidu.www,那么就会存在一个对用路径为com/baidu/www

来存储代码

如果一个类没有 package 语句 , 则该类被放到一个默认包中

此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了

同时我们也看到了 , 在新创建的 Test.java 文件的最上方 , 就出现了一个 package 语句

6.3.3 包的访问权限控制

类中成员变量没有任何访问修饰限定符的时候，认为该成员变量是包访问权限

此时可以实例化对象，但是不能给成员变量初始化（这是因为不在同一个包中）

这里是在同一个包中，所以可以调用

6.3.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 编程开发包。

七、static成员

7.1 再说前文人类

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person();
        Person person3 = new Person();
    }
}

假设这三个人的学历都是本科，那能否给类中再加一个成员变量，来保存他们的学历呢？答案是不

行的。

之前在Person 类中定义的成员变量，每个对象中都会包含一份 ( 称之为实例变量 ) ，因为需要使用

这些信息来描述具体的人。而现在要表示这些人的学历，这个学历的属性并不需要每个人类对

象中都存储一份，而是需要让所有的人来共享。

在 Java 中，被 static 修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对

象，是所有对象所共享的 。

7.2 static修饰成员变量

static 修饰的成员变量，称为静态成员变量 ，静态成员变量最大的特性： 不属于某个具体的对象，

是所有对象所共 享的。

这里看到，出现了黄色警告

打个断点debug一下

可以看到person1当中并没有edbd这个属性

这说明不需要通过对象引用访问edbd，这个属性不依赖对象

直接通过类名访问就可以了

public class Person{
    public String name;
    public String sex;
     public static String edbd = "本科";//Educational background
    public String occupation;
    public String interest;
    public int age;
    public float  height;

    public void eat(){
        System.out.println(name+"正在吃饭");
    }
    public void  sleep(){
        System.out.println(name+"正在睡觉");
    }
    public void walk(){
        System.out.println(name+"正在散步");
    }
    public static void func(){
        System.out.println("静态方法！");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person();
        Person person3 = new Person();
//        System.out.println(person1.edbd);
//        System.out.println(person2.edbd);
//        System.out.println(person3.edbd);

        System.out.println(Person.edbd);
        Person.func();
    }
}

【静态成员变量特性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

3. 类变量存储在方法区当中

4. 生命周期伴随类的一生 ( 即：随类的加载而创建，随类的卸载而销毁 )

7.3 static修饰成员方法

Java 中，被 static 修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的 。静态

成员一般是通过静态方法来访问的。

【 静态方法特性 】

1. 不属于某个具体的对象，是类方法

2. 可以通过对象调用，也可以通过类名 . 静态方法名 (...) 方式调用，更推荐使用后者

3. 不能在静态方法中访问任何非静态成员变量

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

传递 this 引用

7.4 static成员变量初始化

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

属性

7.4.1 就地初始化

在定义时就进行初始化

7.4.2 静态代码块初始化

什么是代码块初始化，继续往下看

八、代码块

8.1 代码块概念及分类

使用 {} 定义的一段代码称为代码块 。根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块

构造块

静态块

同步代码块（后续文章会谈到）

8.2 普通代码块

通代码块：定义在方法中的代码块

public class Main {
    public static void main(String[] args) {
        {
            int a = 10;
            System.out.println(a);
        }
       int x = 100;
        System.out.println(x);
    }

8.3 构造代码块儿

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例

成员变量。


public class Person{
    public String name;
    public String sex;
    public String edbd ;//Educational background
    public String occupation;
    public String interest;
    public int age;
    public float  height;

    {
        this.name = "张三";
        this.age = 18;
        this.sex = "male";
        System.out.println("666");
    }
 public void show(){
     System.out.println(this.name+" "+this.age+" "+this.sex);
 }
    public void eat(){
        System.out.println(name+"正在吃饭");
    }
    public void  sleep(){
        System.out.println(name+"正在睡觉");
    }
    public void walk(){
        System.out.println(name+"正在散步");
    }
    public static void func(){
        System.out.println("静态方法！");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
    }

8.4 静态代码块

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


public class Person{
    public String name;
    public String sex;
    public static String edbd ;//Educational background
    public static String occupation;
    public String interest;
    public int age;
    public float  height;

    {
        this.name = "张三";
        this.age = 18;
        this.sex = "male";
        System.out.println("666");
//    构造代码块
    }

  static {
        edbd = "本科";
        occupation = "码农";
        System.out.println("123456");
//        静态代码块
    }
 public void show(){
     System.out.println(this.name+" "+this.age+" "+this.sex);
 }
    public void eat(){
        System.out.println(name+"正在吃饭");
    }
    public void  sleep(){
        System.out.println(name+"正在睡觉");
    }
    public void walk(){
        System.out.println(name+"正在散步");
    }
    public static void func(){
        System.out.println("静态方法！");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person();
    }

这里可以看到静态代码块中的方法在构造代码块前出现，且仅出现了一次

注意事项

静态代码块不管生成多少个对象，其只会执行一次

静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的

如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)

实例代码块只有在创建对象时才会执行

九、对象的打印


public class Person{
    public String name;
    public String sex;
    public static String edbd ;//Educational background
    public static String occupation;
    public String interest;
    public int age;
    public float  height;

    public Person(String name, String sex, String interest, int age, float height) {
        this.name = name;
        this.sex = sex;
        this.interest = interest;
        this.age = age;
        this.height = height;
    }

    public void show(){
     System.out.println(this.name+" "+this.age+" "+this.sex);
 }
    public void eat(){
        System.out.println(name+"正在吃饭");
    }
    public void  sleep(){
        System.out.println(name+"正在睡觉");
    }
    public void walk(){
        System.out.println(name+"正在散步");
    }
    public static void func(){
        System.out.println("静态方法！");
    }
}
public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("张三","male","basketball",18,1.75f);
        System.out.println(person1);
    }
}

这里看一下println是怎么做的

那么这里重写一下to String(重写在后续文章会介绍)


public class Person{
    public String name;
    public String sex;
    public static String edbd ;//Educational background
    public static String occupation;
    public String interest;
    public int age;
    public float  height;

    public Person(String name, String sex, String interest, int age, float height) {
        this.name = name;
        this.sex = sex;
        this.interest = interest;
        this.age = age;
        this.height = height;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", interest='" + interest + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }

    public void show(){
     System.out.println(this.name+" "+this.age+" "+this.sex);
 }
    public void eat(){
        System.out.println(name+"正在吃饭");
    }
    public void  sleep(){
        System.out.println(name+"正在睡觉");
    }
    public void walk(){
        System.out.println(name+"正在散步");
    }
    public static void func(){
        System.out.println("静态方法！");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person("张三","male","basketball",18,1.75f);
        System.out.println(person1);


    }