当前位置： 首页 > news >正文

Java之类与对象（图文结合）

news 文章来源：https://blog.csdn.net/weixin_73616913/article/details/129613280 2025/5/20 17:02:30

目录

 一、面向对象的初步认知

1、什么是面向对象

2、面向对象与面向过程

二、类定义和使用

1、简单认识类

2、类的定义格式 

3、练习

（1）定义一个狗类

（2）定义一个学生类

三、类的实例化

1、什么是实例化

2、类和对象的说明  

四、this引用

1、为什么要有this引用

2、什么是this引用

3、this引用的特性

五、对象的构造及初始化

1、如何初始化对象

2、构造方法

(1)概念

（2）特性

3、默认初始化

4、就地初始化

六、封装

1、封装的概念

2、访问限定符

3、封装扩展之包

（1）包的概念

（3）自定义包

（4）包的访问权限控制

（5）常见的包 

七、static成员

1、再谈学生类

2、static修饰成员变量

3、static修饰成员方法

4、static成员变量初始化

（1） 就地初始化

（2）静态代码块初始化

八、代码块

1、代码块概念以及分类

2、普通代码块

3、构造代码块

4、静态代码块

 十、对象的打印

 一、面向对象的初步认知

1、什么是面向对象

Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。
下图就是一个关于面向对象的例子：

2、面向对象与面向过程

我们用洗衣服来举例子，了解一下面向对象和面向过程

（1）传统洗衣服过程

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

而且不同衣服洗的方式，时间长度，拧干方式都不同，处理起来就比较麻烦。如果将来要洗鞋子，那就是另一种放方式。
按照该种方式来写代码，将来扩展或者维护起来会比较麻烦，因此在后来人们便发明了洗衣机也就是我们现代的洗衣服方法。

以面向对象方式来进行处理，就不关注洗衣服的过程，具体洗衣机是怎么来洗衣服，如何来甩干的，用户不用去关心，只需要将衣服放进洗衣机，倒入洗衣粉，启动开关即可，通过对象之间的交互来完成的。
注意：面向过程和面相对象并不是一门语言，而是解决问题的方法，没有那个好坏之分，都有其专门的应用场景。

二、类定义和使用

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

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

1、简单认识类

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

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

我们接下来就来学习一下类的定义格式

2、类的定义格式 

在java中定义类时需要用到class关键字，具体语法如下： 
// 创建类
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的基础上计算机就可以识别了。
注意事项：
1、类名注意采用大驼峰定义
2、成员前写法统一为public.
3、此处写的方法不带 static 关键字.
4、一个Java文件中可以定义多个class类，但只能一个类是public修饰，而且public修饰的类名必须成为代码文件名。 实际开发中建议还是一个文件定义一个class类。

3、练习

（1）定义一个狗类

class PetDog {public String name;//名字public String color;//颜色// 狗的属性public void barks() {System.out.println(name + ": 旺旺旺~~~");}// 狗的行为public void wag() {System.out.println(name + ": 摇尾巴~~~");}
}

（2）定义一个学生类 

public class Student{public String name;public String gender;public short age;public double score;public void DoClass(){}public void DoHomework(){}public void Exam(){}
}
注意事项：
1. 一般一个文件当中只定义一个类
2. main方法所在的类一般要使用public修饰
   (注意：Eclipse默认会在public修饰的类中找main方法)
3. public修饰的类必须要和文件名相同
4. 不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改。

三、类的实例化

1、什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一个新的类型，比如上述的：PetDog类和Student类。它们都是类(一种新定义的类型)有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。
用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。
那么接下来，我们利用之前已经创建好了的”狗“类来完成实例化对象的操作： 

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来完成了实例化对象，然后通过.操作符来访问这个对象中的属性和方法，由此，我们可以得到以下实例化对象中的注意事项：

注意事项:

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

2、类和对象的说明  

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

此外，我们还要注意一个类可以用new关键词实例化多个对象，并且这些对象指向的内存空间是不同的：

四、this引用

1、为什么要有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);}

接下来，我们在main方法中创建三个对象，并通过Date这个类来实现对日期的打印操作

public static void main(String[] args) {
// 构造三个日期类型的对象 d1 d2 d3Date d1 = new Date();Date d2 = new Date();Date d3 = new Date();
// 对d1，d2，d3的日期设置d1.setDay(2020,9,15);d2.setDay(2020,9,16);d3.setDay(2020,9,17);
// 打印日期中的内容d1.printDate();d2.printDate();d3.printDate();
}

此时，为了更好地观看代码，我们将它们合起来看看：


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) {
// 构造三个日期类型的对象 d1 d2 d3Date d1 = new Date();Date d2 = new Date();Date d3 = new Date();
// 对d1，d2，d3的日期设置d1.setDay(2020,9,15);d2.setDay(2020,9,16);d3.setDay(2020,9,17);
// 打印日期中的内容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引用有关

2、什么是this引用

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
我们来重温一下刚才的那段代码: 

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

我们可以将这个先放到IDEA中执行试一下，这时我们会发现，当方法中的形参和类的成员对象名一致的时候，year\month\day的打印结果均为0

这是因为：

这里的year是给局部变量自己赋值，但是并没有给到成员变量赋值

那么这个时候，就轮到我们的this引用出场了！

那么接下来，我们来看一下当遇到形参和成员变量名相同的时候，方法内部该如何书写代码：

public class Date {public int year;public int month;public int day;public void setDay(int year, int month, int day){this.year = year;this.month = month;this.day = day;}public void printDate(){System.out.println(this.year + "/" + this.month + "/" + this.day);}
}

在这里面，this表示对当前对象的引用，也就是说：谁调用了setDay，那么这个this就是谁，那么为了防止以后出现类似这样的问题，我们推荐习惯使用this，这样就可以规避错误了

注意：this引用的是调用成员方法的对象。
接下来，我们 通过一段代码和一幅图来更深入地了解一下this的含义：
public static void main(String[] args) {Date d = new Date();d.setDay(2020,9,15);d.printDate();}

那么为什么会有this这样的情况出现呢，我们来看一下this的本质：

 我们可以发现，在形参中本身就存在一个this ,只是我们的编译器帮我们隐藏起来了，因此在平时我们是看不到的。

3、this引用的特性

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

那么接下来，在代码层面来简单演示--->注意：下图右侧中的Date类也是可以通过编译的

五、对象的构造及初始化

1、如何初始化对象

通过前面知识点的学习知道，在Java方法内部定义一个局部变量时，必须要初始化，否则会编译失败。
也就是说，当出现和下面这段代码一样的情况的时候，便会导致编译失败：
public static void main(String[] args) {int a;System.out.println(a);}

这是由于可能未对变量a进行初始化导致的，要让上述代码通过编译，非常简单，只需在正式使用a之前，给a设置一个初始值即可。如果是对象：

public static void main(String[] args) {Date d = new Date();d.printDate();d.setDate(2021,6,9);d.printDate();}

我们会发现：需要调用之前写的SetDate方法才可以将具体的日期设置到对象中。

通过上述例子发现两个问题：

1. 每次对象创建好后调用SetDate方法设置具体日期，比较麻烦，那对象该如何初始化？
2. 局部变量必须要初始化才能使用，为什么声明之后没有给值依然可以使用？
那么这个时候，就轮到我们的构造方法出场了

2、构造方法

(1)概念

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

 那么有了构造方法，我们的Date类应该是这个样子的：

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(2021,6,9); // 输出Date(int,int,int)方法被调用了d.printDate(); // 2021-6-9}
}
注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

（2）特性

1. 名字必须与类名相同
2. 没有返回值类型，设置为void也不行
3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)
5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。
6. 构造方法中，可以通过this调用其他构造方法来简化代码
7. 绝大多数情况下使用public来修饰，特殊场景下会被private修饰
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();}
}

在这段代码中，我们可以发现此时我们并没有创建一个构造方法，但是编译器会给我们默认生成一个不带任何参数的构造方法，只不过被编译器隐藏起来了，所以我们看不到。

但是一旦我们自己定义了一个构造方法的情况下，编译器便不会再帮助我们定义一个构造方法了

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
找到: 没有参数
原因: 实际参数列表和形式参数列表长度不同
*/

 在上面这个代码中，我们可以发现编译器进行了报错，这是因为我们在这个类中已经创建好了一个含有三个参数的构造方法，因此编译器便不会再为我们创建一个不含参数的构造方法，但是此时我们在main方法中调用了不含参数的构造方法，因此导致了编译器报错

6. 构造方法中，可以通过this调用其他构造方法来简化代码 
 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);System.out.println("调用了无参数的构造方法");}// 带有三个参数的构造方法public Date(int year, int month, int day) {this.year = year;this.month = month;this.day = day;System.out.println(year + " " + month + " " + day);}
}public class Test {public static void main(String[] args) {Date date = new Date();}
}

我们观察这段代码，会发现在其中一个构造方法中，有这么一行代码:

this(1900, 1, 1);

这段代码表示的其实就是调用了另一个包含三个参数的构造方法，并且在该方法调用完成后，还会继续执行原来的方法。

因此这段代码的执行情况是这个样子的：

注意：1、 this(...)必须是构造方法中第一条语句
如果this()不是构造方法中的第一条语句的话，编译器会进行报错：

    

    2、不能形成环

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

在这段代码中，我们可以发现，在第一个构造方法中，用this调用了第二个构造方法，在第二个构造方法中，又使用this调用了第一个构造方法，两个构造方法之间形成环，导致编译器报错：

7. 绝大多数情况下使用public来修饰，特殊场景下会被private修饰

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) {
// 此处a没有初始化，编译时报错：
// Error:(24, 28) java: 可能尚未初始化变量a
// int a;
// System.out.println(a);Date d = new Date(2021,6,9);}
}

要搞清楚这个过程，就需要知道 new 关键字背后所发生的一些事情：

Date d = new Date(2021,6,9);
在程序层面只是简单的一条语句，在JVM层面需要做好多事情，下面简单介绍下:
1. 检测对象对应的类是否加载了，如果没有加载则加载
2. 为对象分配内存空间
3. 处理并发安全问题
比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突
4. 初始化所分配的空间

5. 设置对象头信息

6. 调用构造方法，给对象中各个成员赋值

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();}
}

在这段代码中，我们直接先对成员变量进行了初始化，这种初始化便被称为就地初始化，但是由于不可能所有的年份都是1900，所有的日期都是1月1日，因此就地初始化通常很少被使用到。

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

六、封装

1、封装的概念

面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节
那么什么什么时候使用封装呢？例如当客户有一个需求：不想让类外看到我的细节，此时我们便可以使用封装来使类外无法观察到细节
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互
我们也可以理解为：把类的实现细节进行了隐藏，此时类外看不到这个数据

2、访问限定符

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

那么这些访问限定符是什么意思呢？
public：可以理解为一个人的外貌特征，谁都可以看得到
default: 什么都不写的时候，对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了
private：只有自己知道，其他人都不知道
protected：受保护的（在学完继承之后才能够了解）

注意:这些只是访问权限，不仅可以修饰方法，也可以用于修饰类

【说明】
1、protected主要是用在继承中，继承部分详细介绍
2、default权限指：什么都不写时的默认权限
3、访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

 此时，我们创建一个电脑类，来进一步了解访问限定符：

public class Computer {private String cpu; // cpuprivate String memory; // 内存public String screen; // 屏幕String brand; // 品牌---->default属性public Computer(String brand, String cpu, String memory, String screen) {this.brand = brand;this.cpu = cpu;this.memory = memory;this.screen = screen;}public void Boot(){System.out.println("开机~~~");}public void PowerOff(){System.out.println("关机~~~");}public void SurfInternet(){System.out.println("上网~~~");}
}
public class TestComputer {public static void main(String[] args) {Computer p = new Computer("HW", "i7", "8G", "13*14");System.out.println(p.brand); // default属性：只能被本包中类访问System.out.println(p.screen); // public属性： 可以任何其他类访问
// System.out.println(p.cpu); // private属性：只能在Computer类中访问，不能被其他类访问}
}
注意：一般情况下成员变量设置为private，成员方法设置为public
看完这段代码，你一定会疑惑什么是包，那么接下来，我们便开始学习一下"包"

3、封装扩展之包

（1）包的概念

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。有点类似于目录。比如：为了更好的管理电脑中的歌曲，一种好的方式就是将相同属性的歌曲放在相同文件下，也可以对某个文件夹下的音乐进行更详细的分类。

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

（2）导入包中的类

Java 中已经提供了很多现成的类供我们使用. 例如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());}
}
如果需要使用 java.util 中的其他类, 可以使用 import java.util.*
import java.util.*;
public class Test {public static void main(String[] args) {Date date = new Date();
// 得到一个毫秒级别的时间戳System.out.println(date.getTime());}
}

那么这里的.*是什么意思呢？

其实在这里，.*相当于一个通配符：可以充当任何类，但不是导入util下的所有类，而是当你用到哪个类，便会帮你导哪个类

但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况
这是为什么呢，我们来看一下下面这段代码：
import java.util.*;
import java.sql.*;
public class Test {public static void main(String[] args) {
// util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错Date date = new Date();System.out.println(date.getTime());}
}
// 编译出错
Error:(5, 9) java: 对Date的引用不明确java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配
 util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错

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

import java.util.*;
import java.sql.*;
public class Test {public static void main(String[] args) {java.util.Date date = new java.util.Date();System.out.println(date.getTime());}
}
可以使用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);}
注意事项: import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要. import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using

（3）自定义包

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

 操作步骤：

1. 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包

2. 在弹出的对话框中输入包名, 例如 com.baidu.www

  

 3. 在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可.

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

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

 那么这个package便是声明Java文件在哪个包当中

（4）包的访问权限控制

访问权限与访问限定符和是否调用了这个包有关，我们可以根据之前已经展示过的这个图来判断包的访问权限：

（5）常见的包 

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
2. java.lang.reflflect:java 反射编程包;
3. java.net:进行网络编程开发包。
4. java.sql:进行数据库开发的支持包。
5. java.util:是java提供的工具程序包。(集合类等) 非常重要
6. java.io:I/O编程开发包。

七、static成员

1、再谈学生类

使用前文中介绍的学生类实例化三个对象s1、s2、s3，每个对象都有自己特有的名字、性别，年龄，学分绩点等成员信息，这些信息就是对不同学生来进行描述的，如下所示： 
public class Student{// ...public static void main(String[] args) {Student s1 = new Student("Li leilei", "男", 18, 3.8);Student s2 = new Student("Han MeiMei", "女", 19, 4.0);Student s3 = new Student("Jim", "男", 18, 2.6);}
}

假设三个同学是同一个班的，那么他们上课肯定是在同一个教室，那既然在同一个教室，那能否给类中再加一个成员变量，来保存同学上课时的教室呢？答案是不行的。

之前在Student类中定义的成员变量，每个对象中都会包含一份(称之为实例变量)，因为需要使用这些信息来描述具体的学生。而现在要表示学生上课的教室，这个教室的属性并不需要每个学生对象中都存储一份，而是需要让所有的学生来共享。在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。
我们可以这样理解：
当classroom没有被static修饰的时候，是普通成员变量，所有
对象都有一份classroom，而如果此时我们用static来修饰classroom，那么classroom便变成了静态成员变量，所有对象公用一份。
那么现在，我们来比较一下我们目前已经学了的三种变量：

2、static修饰成员变量

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

【静态成员变量特性】
1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
3. 类变量存储在方法区当中
4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

我们可以来看一个访问静态成员变量的例子：

public class Student{public String name;public String gender;public int age;public double score;public static String classRoom = "Bit306";// ...public static void main(String[] args) {
// 静态成员变量可以直接通过类名访问System.out.println(Student.classRoom);Student s1 = new Student("Li leilei", "男", 18, 3.8);Student s2 = new Student("Han MeiMei", "女", 19, 4.0);Student s3 = new Student("Jim", "男", 18, 2.6);
// 也可以通过对象访问：但是classRoom是三个对象共享的System.out.println(s1.classRoom);System.out.println(s2.classRoom);System.out.println(s3.classRoom);}
}

静态成员的访问，不建议通过对象的引用访问，建议通过类名.的方式访问

类的静态成员变量通过类名访问，也就是说，这个静态成员变量不属于对象！！！

当我们以调试方式运行上述代码，然后在监视窗口中可以看到，可以发现静态成员变量并没有存储到某个具体的对象中，也证明了静态成员不属于变量这个概念。

最后，我们来思考几个问题：

1、引用可以指向引用吗？

答案是不可以！！  引用只能指向对象！！

这时候有人就会提问了：下面这种情况不就是引用指向引用吗？

 但是实际上，这段代码的意思是：student2这个引用指向了student1这个引用指向的对象，也就是说，实际上还是引用指向了一个对象

2、一个引用可以指向多个对象吗？

例如:

答案也是不可以！！

在这段代码种，我们可以运行发现，最终的结果是student1中存放的是"zhangsan3"和18,由此我们可以知道：一个引用不能指向多个对象

3、Person p = null;代表不指向任何对象

classRoom不在对象当中，不属于对象，而又不指向任何对象，因此不会发生空指针异常

3、static修饰成员方法v

一般类中的数据成员都设置为private，而成员方法设置为public，那设置之后，Student类中classRoom属性如何在类外访问呢？
我们先来看一段错误的代码：
public class Student{private String name;private String gender;private int age;private double score;private static String classRoom = "Bit306";
// ...
}
public class TestStudent {public static void main(String[] args) {System.out.println(Student.classRoom);}
}
那static属性应该如何访问呢？
Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。 
public class Student{// ...private static String classRoom = "306";// ...public static String getClassRoom(){return classRoom;}
}
public class TestStudent {public static void main(String[] args) {System.out.println(Student.getClassRoom());}
}

静态方法的内部是不能直接调用非静态的方法的，因为静态方法不依赖对象，但是非静态方法依赖对象

【静态方法特性】
1. 不属于某个具体的对象，是类方法
2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者
3. 不能在静态方法中访问任何非静态成员变量
4. 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用
5. 静态方法无法重写，不能用来实现多态

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

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()

4、static成员变量初始化

注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性
静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化

（1） 就地初始化

就地初始化指的是：在定义时直接给出初始值 
public class Student{private String name;private String gender;private int age;private double score;private static String classRoom = "Bit306";
// ...
}

（2）静态代码块初始化

八、代码块

1、代码块概念以及分类

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：
1、普通代码块
2、构造块
3、静态块
4、同步代码块（后续讲解多线程部分再谈）

2、普通代码块

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

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);}
}
// 执行结果
x1 = 10x2 = 100

这种用法较少见  

3、构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。 
public class Student{//实例成员变量private String name;private String gender;private int age;private double score;public Student() {System.out.println("I am Student init()!");}//实例代码块{this.name = "lisi";this.age = 12;this.sex = "man";System.out.println("I am instance init()!");}public void show(){System.out.println("name: "+name+" age: "+age+" sex: "+sex);}
}
public class Main {public static void main(String[] args) {Student stu = new Student();stu.show();}
}// 运行结果I am instance init()!I am Student init()!name: lisi age: 12 sex: man

4、静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。
public class Student{private String name;private String gender;private int age;private double score;private static String classRoom;//实例代码块{this.name = "LISI";this.age = 12;this.gender = "man";System.out.println("I am instance init()!");}// 静态代码块static {classRoom = "LISI306";System.out.println("I am static init()!");}public Student(){System.out.println("I am Student init()!");}public static void main(String[] args) {Student s1 = new Student();Student s2 = new Student();}
}
【注意事项】
1、静态代码块不管生成多少个对象，其只会执行一次
2、静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
3、如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
4、实例代码块只有在创建对象时才会执行

那么这时候，我们要注意一个问题：当静态代码块，构造块，和不调用参数的构造方法之间如果同时出现，那么哪个会先执行呢？我们来做一个小实验：

class Student{public  String name;public int age;public String sex;Student(){System.out.println("不带参数的构造方法");}{this.name = "lisi";this.age = 12;this.sex = "man";System.out.println("构造方法块");}static {System.out.println("静态方法块");}
}public class Test {public static void main(String[] args) {Student student = new Student();}
}

那么现在我们来看一下这段代码的运行结果是什么：

 由此，我们可以知道这三个代码块之间的运行顺序：

 十、对象的打印

class Person {String name;String gender;int age;public Person(String name, String gender, int age) {this.name = name;this.gender = gender;this.age = age;}public static void main(String[] args) {Person person = new Person("Jim","男", 18);System.out.println(person);}
}
// 打印结果：day20210829.Person@1b6d3586

这段代码的运行结果表示的是这个对象所存储的地址

那么如果想要默认打印对象中的属性该如何处理呢？

答案：重写toString方法即可。

public class Person {
String name;
String gender;
int age;
public Person(String name, String gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
@Override
public String toString() {
return "[" + name + "," + gender + "," + age + "]";
}
public static void main(String[] args) {
Person person = new Person("Jim","男", 18);
System.out.println(person);
}
}
// 输出结果：[Jim,男,18]

相关文章：

Java之类与对象（图文结合）

目录 一、面向对象的初步认知 1、什么是面向对象 2、面向对象与面向过程 二、类定义和使用 1、简单认识类 2、类的定义格式 3、练习 （1）定义一个狗类 （2）定义一个学生类 三、类的实例化 1、什么是实例化 2、类和对象的…...

编程日记 2023/3/21 6:54:33

基于 VCS-NLP 的动态低功耗仿真验证介绍

🔥点击查看精选 IC 技能树系列文章🔥 🔥点击进入【芯片设计验证】社区，查看更多精彩内容🔥 📢 声明： 🥭 作者主页：【MangoPapa的CSDN主页】。⚠️ 本文首发于CSDN&#…...

编程日记 2023/3/21 6:49:31

ESP32-S3 自带usb/jtag初步尝试体验

一、背景 最近在做一台小机器，设备初步规划使用几个实体按钮，这样方便用户戴手套操作。但因为设备有一些需要配置的参数，有需要配备屏幕。但是开发时间比较紧。考虑再三，决定先在初步配备一个简单的控制箱。控制箱上不带屏幕。后…...

编程日记 2023/3/21 6:44:29

前端性能优化总结

前端性能优化是指在设计和开发网站时，采取一些措施来提升网站的性能。这对用户来说是非常重要的，因为高性能的网站可以带来更好的用户体验，同时也有助于提升搜索引擎排名。一、常见前端性能优化措施常见的前端性能优化方法有：压缩…...

编程日记 2023/3/21 6:39:26

React(四) ——hooks的使用

🧁个人主页：个人主页 ✌支持我 ：点赞👍收藏🌼关注🧡 文章目录⛳React Hooks💸useState(保存组件状态)🥈useEffect(处理副作用)🔋useCallback（记忆函数&#…...

编程日记 2023/4/13 6:51:59

iphone手机热点卡顿多次断连解决办法

文章目录解决方法检查一下几个地方：1.个人热点是否打开2.查看手机是否为4g3.查看手机的最大兼容性开关是否关闭！！很重要解决方法 检查一下几个地方： 1.个人热点是否打开 这个个人热点容易自动断开，先检查一下是不是…...

编程日记 2023/4/28 9:42:05

设置Typora图床（Github）

PicGo，Github，Typora Nodejs下载： Node.js PicGo下载： GitHub - Molunerfinn/PicGo: A simple & beautiful tool for pictures uploading built by vue-cli-electron-builder 选择downloads或release. 然后进行安装。 Gith…...

编程日记 2023/4/13 6:53:56

jira提交bug规范

一、目的 1）方便开发人员根据bug描述快速进行定位问题原因，减少沟通成本。 2）规范bug编写，可以提现测试团队的专业性、严谨性。 3）可以帮助产品、项目经理及其它人员快速了解bug。 二、说明 本文档主要描述了技术产…...

编程日记 2023/4/13 6:54:25

【数据结构】链表相关题目（中档题）

🚀write in front🚀 📜所属专栏：初阶数据结构 🛰️博客主页：睿睿的博客主页 🛰️代码仓库：🎉VS2022_C语言仓库 🎡您的点赞、关注、收藏、评论，是对…...

编程日记 2023/3/21 6:14:13

小菜鸟Python历险记：(第四集)

今天写的文章是记录我从零开始学习Python的全过程。在Python中函数是非常重要的，这里也可以称为方法。在前面分享的几篇文章中用到的方法有print(),str(),int().这些都是方法，而除了上面写的这几种内置方法以外，我们也可以自己在程序中自定义…...

编程日记 2023/3/21 6:09:10

字符函数和字符串函数【下篇】

文章目录🎖️1.函数介绍📬1.8. strstr📬1.9. strtok📬1.10. strerror📬1.11. memcpy📬1.12. memmove📬1.13. memcmp📬1.14. memset🎖️1.函数介绍 📬1.8. st…...

编程日记 2023/5/11 19:28:33

【CSS】盒子模型内边距 ② ( 内边距复合写法 | 代码示例 )

文章目录一、内边距复合写法1、语法2、代码示例 - 设置 1 个值3、代码示例 - 设置 2 个值4、代码示例 - 设置 3 个值5、代码示例 - 设置 4 个值一、内边距复合写法 1、语法 盒子模型内边距 可以通过 padding-left 左内边距padding-right 右内边距padding-top 上内边距padding-…...

编程日记 2023/3/21 5:59:06

uni-app ——使用uploadFile上传多张图片

前言：最近的工作中出现了一个功能点，具体写法我在前面的文章中已经阐述过，不过之前的情况是上传图片调用后端的一个接口，整个表单页面提交的时候调用的是另一个接口，我也从中学到了另外的一种方法，写到这里…...

编程日记 2023/3/21 5:54:04

Linux - 进程控制(进程等待)

进程等待必要性之前讲过，子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力&#…...

编程日记 2023/3/21 5:49:00

Python 可视化最频繁使用的10大工具

今天介绍Python当中十大可视化工具，每一个都独具特色，惊艳一方。 文章目录Matplotlib技术提升SeabornPlotlyBokehAltairggplotHoloviewsPlotnineWordcloudNetworkxMatplotlib Matplotlib 是 Python 的一个绘图库，可以绘制出高质量的折线图、…...

编程日记 2023/4/13 6:57:12

Windows与Linux端口占用、查看的方法总结

Windows与Linux端口占用、查看的方法总结 文章目录Windows与Linux端口占用、查看的方法总结一、Windows1.1Windows查看所有的端口1.2查询指定的端口占用1.3查询PID对应的进程1.4查杀死/结束/终止进程二、Linux2.1lsof命令2.2netstat命令一、Windows 1.1Windows查看所有的端口 …...

编程日记 2023/3/21 5:38:57

48天强训 Day1 JavaOj

48天强训 & Day1 & JavaOj 1. 编程题1 - 组队竞赛 组队竞赛_牛客笔试题_牛客网 (nowcoder.com) 1.1 读题 1.2 算法思想基础 我们应该尽量的让每一个队伍的中间值都最大化~我们应该尽量的让每一个队伍的最小值都足够小~前33%的不应该都作为每个队伍的最大值~ 接下来…...

编程日记 2023/3/21 5:33:55

崩溃的一瞬间

——我可以忍受黑暗，除非我从未见过光明 原来，人真的会崩溃，如果不是昨夜的眼泪，我到现在还不知道人为什么会在一瞬间崩溃。 刚和认识不久的女孩子聊完天准备入睡。忽然想到自己可能过几个月就要离开这座待了仅一年多的城市…...

编程日记 2023/3/21 5:28:53

13回归网络：HTTP/2是怎样的网络协议？

本篇文章我们先放下实践，回归网络，深入gRPC底层的HTTP/2协议，去探究一下框架底层网络协议的原理，提升对高性能网络协议的认知，相信读完这篇文章以后，我们就可以了解HTTP/2有哪些优势，为什么gRPC要使用HTTP/2作为底层的传输协议。 在众多研究HTTP/2的博客和资料中，最具…...

编程日记 2023/3/21 5:23:51

CSS学习笔记——基础选择器，字体属性，文本属性，三种样式表

文章目录基础选择器标签选择器类选择器多类名使用方式id选择器通配符选择器字体属性字体系列字体字号字体粗细文字样式复合属性文本属性文本颜色对齐文本装饰文本文本缩进行间距CSS的三种样式表行内样式表（行内式）内部样式表（嵌入式&#xff…...

编程日记 2023/3/21 5:18:49

第十四届蓝桥杯三月真题刷题训练——第 16 天

目录 第 1 题：英文字母 问题描述 输入格式 输出格式 样例输入 1 样例输出 1 样例输入 2 样例输出 2 评测用例规模与约定 运行限制 代码： 第 2 题：单词分析 题目描述 输入描述 输出描述 输入输出样例 运行限制 数组代码&…...

编程日记 2023/3/21 5:13:46

鸟哥的Linux私房菜 Shell脚本

第十二章、学习 Shell Scripts https://linux.vbird.org/linux_basic/centos7/0340bashshell-scripts.php 12.2 简单的 shell script 练习 #!/bin/bash# Program: # User inputs his first name and last name. Program shows his full name.read -p "Please in…...

编程日记 2023/4/13 6:57:40

FPGA基于RIFFA实现PCIE采集ov5640图像传输，提供工程源码和QT上位机

目录1、前言2、RIFFA理论基础3、设计思路和架构4、vivado工程详解5、上板调试验证并演示6、福利：工程代码的获取1、前言 PCIE是目前速率很高的外部板卡与CPU通信的方案之一，广泛应用于电脑主板与外部板卡的通讯，PCIE协议极其复杂&#xff0c…...

编程日记 2023/3/21 5:03:42

week13周报

一.动态规划走楼梯2难点：不能连续走三次两级台阶如何表示思路：可以用二维数组f[i][j],i表示当前台阶数，j表示已经连续走了j次二级台阶了转移方程：f[i2][j1]f[i2][j1]f[i][j] 当j！2时，我们可以选择走二级台阶…...

编程日记 2023/3/21 4:58:40

离散选择模型中的分散系数theta到底该放在哪里呢？

前言 \quad~~一直都在想为啥子离散选择模型中分散系数以分母形式出现而在路径选择公式中以系数形式出现呢？看着公式想了想，现在想出了一个似乎感觉应该差不多很合理的答案，希望与大家一起探讨。 进入正题 根据随机效用理论，决策…...

编程日记 2023/3/21 4:53:38

【CSAPP】进程 | 上下文切换 | 用户视角下的并发进程

💭 写在前面：本文将学习《深入理解计算机系统》的第六章 - 关于异常控制流和系统级 I/O 的 进程部分。CSAPP 是计算机科学经典教材《Computer Systems: A Programmers Perspective》的缩写，该教材由Randal E. Bryant和David R. OHallaron 合著…...

编程日记 2023/4/13 6:58:26

节流还在用JS吗？CSS也可以实现哦

函数节流是一个我们在项目开发中常用的优化手段，可以有效避免函数过于频繁的执行。一般函数节流用在scroll页面滚动，鼠标移动等。 为什么需要节流呢，因为触发一次事件就会执行一次事件，这样就形成了大量操作dom,会出现卡顿的情况…...

编程日记 2023/3/21 4:43:35

带你看看 TypeScript 5.0 的新特性

一、写在前面 TypeScript 5.0 已经于 2023 年 3 月 16 日发布了，带来了许多新功能，同时也在性能方面进行了优化，下面让我们来一起看看新版 TypeScript 中比较有重要的变化吧。 二、新特性 2-1、速度、包体积优化 首先是新版本性能的提升&…...

编程日记 2023/3/21 4:38:33

C语言预处理条件语句的 与或运算

C语言预处理条件语句的 与或运算 1.#ifdef 与或运算 #ifdef (MIN) && (MAX) ----------------------------错误使用 #if defined(MIN) && defined(MAX) ---------------- 正确使用 #ifdef (MIN) || (MAX) -----------------------------错误使用 …...

编程日记 2023/3/21 4:33:31

从零实现深度学习框架——学习率调整策略介绍

引言 本着“凡我不能创造的，我就不能理解”的思想，本系列文章会基于纯Python以及NumPy从零创建自己的深度学习框架，该框架类似PyTorch能实现自动求导。 要深入理解深度学习，从零开始创建的经验非常重要，从自己可以理解的角度出发，尽量不使用外部完备的框架前提下，实现我…...

编程日记 2023/3/21 4:28:30