类和对象的认识

最新推荐文章于 2023-06-15 17:30:06 发布
最新推荐文章于 2023-06-15 17:30:06 发布
阅读量475 收藏 2
点赞数 1
分类专栏： java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65210521/article/details/127780166
版权

hello，小编又来了，有菜有爱写，希望能够帮助到你们！！！

目录

hello，小编又来了，有菜有爱写，希望能够帮助到你们！！！

​编辑

1. 面向对象的初步认知

1.1 什么是面向对象

1.2 面向对象与面向过程

1. 传统洗衣服过程（面向过程）

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

2. 类定义和使用

2.1、 简单认识类

2.2、 类的定义格式 

2.3.1、 定义一个学生类

 3. 类的实例化

3.1、 什么是实例化

3.2 、类和对象的说明

4. this引用  

4.1 为什么要有this引用

4.2 什么是this引用

 4.3 this引用的特性

5. 对象的构造及初始化  

5.1 如何初始化对象

5.2 构造方法  

5.2.1 概念

5.2.2 构造方法的特性

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

5.3 默认初始化

5.4 就地初始化

6. 封装

6.1 封装的概念

6.2 访问限定符

6.3 封装扩展之包  

6.3.1 包的概念

6.3.2 导入包中的类

6.3.3 自定义包  

6.3.4 包的访问权限控制举例  

6.3.5 常见的包

7. static成员

7.1 再谈学生类

7.2 static修饰成员变量

7.3 static修饰成员方法

7.4 static成员变量初始化

8. 代码块

8.1 代码块概念以及分类

8.2 普通代码块

8.3 构造代码块

8.4 静态代码块  

 

1. 面向对象的初步认知

1.1 什么是面向对象

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

1.2 面向对象与面向过程

1. 传统洗衣服过程（面向过程）

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

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

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

 

 

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

面向过程：注重过程！！！

面向对象：不关注过程！！！

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

2. 类定义和使用

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

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

2.1、 简单认识类

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

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

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

2.2、 类的定义格式 

在 java 中定义类时需要用到 class 关键字 ，具体语法如下 ： 
// 创建类
class ClassName{
field; // 字段(属性) 或者 成员变量
method; // 行为 或者 成员方法
}
class 为 定义类的关键字， ClassName 为类的名字， {} 中为类的主体。
类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法。 
public class WashMachine {
    public String brand;
    public String type;
    public double weight;
    public double width;
    public double height;
    public String color;

    public void washMachine(){
        System.out.println("洗衣服！");
    }
    public void dryClothes(){
        System.out.println("烘干衣服！");
    }
    public void setTime(){
        System.out.println("定时");
    }
}
采用 Java 语言将洗衣机类在计算机中定义完成，经过 javac 编译之后形成 .class 文件，在 JVM 的基础上计算机就可以识别了。
注意事项：
类名注意采用大驼峰定义
成员前写修饰限定符（public、private、protected、默认的）
此处写的方法不带 static 关键字 . 

2.3.1、 定义一个学生类

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 修饰的类的名称，如果要修改，通过开发工具修改 ( 给同学演示 ) 。

 3. 类的实例化

3.1、 什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一个新的类型，比如上述的：WashMachine类和Student类。它们都是类(一种新定义的类型)有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。

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

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

public static void main(String[] args) {
    PetDog dog1 = new PetDog(); //通过new实例化对象
    dog1.name = "啦啦";
    dog1.color = "白色";
    dog1.barks();
    dog1.wag();
    System.out.println("---------------------------");
    PetDog dog2 = new PetDog();
    dog2.name = "哆哆";
    dog2.color = "白色";
    dog2.barks();
    dog2.wag();
    }
}

 输出：

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

3.2 、类和对象的说明

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

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

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

4. 做个比方。 类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图 ，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。

4. this引用  

4.1 为什么要有this引用

先看一个日期类的例子： 

public class Data {
    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 printData(){
        System.out.println(this.year+"年"+this.month+"月"+this.day+"日");
    }

    public static void main(String[] args) {
        Data data = new Data();
        data.setDay(2022,11,10);
        data.printData();
    }
}
以上代码定义了一个日期类，然后 main 方法中创建了三个对象，并通过 Date 类中的成员方法对对象进行设置和打印，代码整体逻辑非常简单，没有任何问题。
但是细思之下有以下两个疑问：
1. 形参名不小心与成员变量名相同 ：
public void setDay ( int year , int month , int day ){
year = year ;
month = month ;
day = day ;
}

 那函数体中到底是谁给谁赋值？成员变量给成员变量？参数给参数？参数给成员变量？成员变量参数？估计自己都搞不清楚了。

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

一切让this引用来揭开这层神秘的面纱。

4.2 什么是this引用

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

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

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

    public static void main(String[] args) {

        Data data = new Data();
        data.setDay(2022,11,10);
        data.printData();
    }
}
注意： this 引用的是调用成员方法的对象 。 
  public static void main(String[] args) {

        Data data = new Data();
        data.setDay(2022,11,10);
        data.printData();
    }

 4.3 this引用的特性

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

5. 对象的构造及初始化  

5.1 如何初始化对象

通过前面知识点的学习知道，在Java方法内部定义一个局部变量时，必须要初始化，否则会编译失败。

public static void main(String[] args) {
int a;
System.out.println(a);
}
// Error:(26, 28) java: 可能尚未初始化变量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. 局部变量必须要初始化才能使用，为什么字段声明之后没有给值依然可以使用？

5.2 构造方法  

5.2.1 概念

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

    public Data(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
    
    public void printData(){
        System.out.println(this.year+"年"+this.month+"月"+this.day+"日");
    }

    public static void main(String[] args) {

        Data data = new Data(2022,11,10);

        data.printData();
    }
}

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

5.2.2 构造方法的特性

1. 名字必须与类名相同

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

3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次 ( 相当于人的出生，每个人只能出生一次 )
4. 构造方法可以重载 ( 用户根据自己的需求提供不同参数的构造方法 ) 
public class Data {
    public int year;
    public int month;
    public int day;
//有参数的构造方法
    public Data(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
//无参数的构造方法 并且初始化
    public Data(){
        this.year = 2002;
        this.month = 03;
        this.day = 19;
    }

    public void printData(){
        System.out.println(this.year+"年"+this.month+"月"+this.day+"日");
    }

    public static void main(String[] args) {
        //实例化有参数构造方法 并且初始化
        Data data = new Data(2022,11,10);
        //实例化无参数的构造方法
        Data data2 = new Data();
        
        data.printData();
        data2.printData();
    }
}
上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载。
5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。 
public class Data1 {
    public int year;
    public int month;
    public int day;

    public void printData(){
        System.out.println(this.year+"年"+this.month+"月"+this.day+"日");
    }

    public static void main(String[] args) {
        Data data2 = new Data();
        data2.printData();
    }
}
上述 Data 类中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法。
注意： 一旦用户定义，编译器则不再生成。 
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;
}
}
注意： this(...) 必须是构造方法中第一条语句
不能形成环像下面代码这样！！！ 
public Date(){
this(1900,1,1);
}
public Date(int year, int month, int day) {
this();
}
/*
无参构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，形成构造器的递归调用
编译报错：Error:(19, 12) java: 递归构造器调用
*/

5.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. 初始化所分配的空间
即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值，比如：
数据类型
默认值
byte0
char'\u0000'
short0
int0
long0L
booleanfalse
float0.0f
double0.0
referencenull
5. 设置对象头信息 ( 关于对象内存模型后面会介绍 )
6. 调用构造方法，给对象中各个成员赋值

5.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 void print(){
        System.out.println(year+"/"+month+"/"+day);
    }
    public static void main(String[] args) {
        //Date d1 = new Date(2021,6,9);
        Date d2 = new Date();
       // d1.print();
        d2.print();
    }
}
注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中

6. 封装

6.1 封装的概念

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

比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器， USB 插孔等，让用户来和计算机进行交互，完成日常事务。但实际上：电脑真正工作的却是CPU 、显卡、内存等一些硬件元件。
对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的， CPU 内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳 子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可 。
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

6.2 访问限定符

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

比如：
public ：可以理解为一个人的外貌特征，谁都可以看得到
default: 对于自己家族中 ( 同一个包中 ) 不是什么秘密，对于其他人来说就是隐私了
private ：只有自己知道，其他人都不知道
【 说明 】
protected 主要是用在继承中，继承部分详细介绍
default 权限指：什么都不写时的默认权限
访问权限除了可以限定类中成员的可见性，也可以控制类的可见性 
public class Computer {
    private String cpu; // cpu
    private 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 。

6.3 封装扩展之包  

6.3.1 包的概念

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

 

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

6.3.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());
        }
    }
但是这种写法比较麻烦一些 , 可以 使用 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 java.util.*;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
但是我们 更建议显式的指定要导入的类名 . 否则还是容易出现冲突 的情况 . 
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 都匹配
在这种情况下需要使用完整的类名 
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

6.3.3 自定义包  

基本规则：
       1）在文件的最上方加上一个 package 语句指定该代码在哪个包中 .
        2）包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式 ( 例如 com.bit.demo1 ).
        3）包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径            com/bit/demo1 来存储代码.
       4） 如果一个类没有 package 语句 , 则该类被放到一个默认包中 .
操作步骤 ：
1. 在 IDEA 中先新建一个包 : 右键 src -> 新建 -> 包

 2. 在弹出的对话框中输入包名，即可

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

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

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

6.3.4 包的访问权限控制举例  

Computer 类位于 com.bit.demo1 包中， TestComputer 位置 com.bit.demo2 包中： 
package com.bit.demo1;

public class Computer {
    private String cpu; // cpu
    private String memory; // 内存
    public String screen; // 屏幕
    String brand; // 品牌
    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 static void main(String[] args) {
        Computer p = new Computer("HW", "i7", "8G", "13*14");
        System.out.println(p.screen);
// System.out.println(p.cpu); // 报错：cup是私有的，不允许被其他类访问
// System.out.println(p.brand); // 报错：brand是default，不允许被其他包中的类访问
    }

}

///
package com.bite.demo2;
import com.bite.demo1.Computer;
public class TestComputer {
public static void main(String[] args) {
Computer p = new Computer("HW", "i7", "8G", "13*14");
System.out.println(p.screen);
// System.out.println(p.cpu); // 报错：cup是私有的，不允许被其他类访问
// System.out.println(p.brand); // 报错：brand是default，不允许被其他包中的类访问
}
}
// 注意：如果去掉Computer类之前的public修饰符，代码也会编译失败

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

7. static成员

7.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 修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对 象，是所有对象所共享的 。

7.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);
    }
}
同学以调试方式运行上述代码，然后在监视窗口中可以看到，静态成员变量并没有存储到某个具体的对象中。

7.3 static修饰成员方法

一般类中的数据成员都设置为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);
}
}
编译失败：
Error:(10, 35) java: classRoom 在 extend01.Student 中是 private 访问控制
那 static 属性应该如何访问呢？
Java 中， 被 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());
}
}
输出： Bit306

【静态方法特性】  

1. 不属于某个具体的对象，是类方法
2. 可以通过对象调用，也可以通过类名 . 静态方法名 (...) 方式调用，更推荐使用后者
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()

7.4 static成员变量初始化

注意： 静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性
静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化 。
1. 就地初始化
                就地初始化指的是：在定义时直接给出初始值 
public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom = "Bit306"; 
// ...
}

 2. 静态代码块初始化

那什么是代码块呢？继续往后看 :) ~~~

8. 代码块

8.1 代码块概念以及分类

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

普通代码块

构造块

静态块
同步代码块（后续讲解多线程部分再谈）

8.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 = 10
x2 = 100
这种用法较少见!!!

8.3 构造代码块

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

public class Student{
//实例成员变量
private String name;
private String sex;
private int age;
private double score;
public Student()
{
System.out.println("I am Student init()!");
}
//实例代码块
{
this.name = "bit";
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 static void main(String[] args) {
Student stu = new Student();
stu.show();
}
}

输出

 

8.4 静态代码块  

使用 static 定义的代码块称为静态代码块。 一般用于初始化静态成员变量。 
public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom;
//实例代码块
{
this.name = "bit";
this.age = 12;
    this.gender = "man";
    System.out.println("I am instance init()!");
}
    // 静态代码块
    static {
        classRoom = "bit306";
        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） 实例代码块只有在创建对象时才会执行

总结： 内容很多，第一次看不懂，多看几次，上B站搜比特大博哥讲的很详细，希望可以帮助大家，在前进在路上不要放弃！努力会有回报哒！！！

Dreamer马
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面向对象(一) 类和对象
qq_44954371的博客
08-22 655
python中的类和对象
类和对象的基本概念
2201_75897538的博客
05-09 1752
类的组成是由属性和行为两部分组成属性：在类中通过成员变量来体现（类中方法外的变量）行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）类的定义步骤：①定义类②编写类的成员变量③编写类的成员方法public class 类名 {// 成员变量变量1的数据类型 变量1；变量2的数据类型 变量2;// 成员方法方法1;方法2;
什么是类和对象
m0_51666421的博客
04-21 770
类的组成是由属性和行为两部分组成属性：在类中通过成员变量来体现（类中方法外的变量）行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）类的定义步骤：①定义类②编写类的成员变量③编写类的成员方法public class 类名 {// 成员变量变量1的数据类型 变量1；变量2的数据类型 变量2;// 成员方法方法1;方法2;
【Java】类和对象详解
qq_61635026的博客
06-15 6408
面向对象（Object-oriented）是一种程序设计的方法和编程范式，它以对象作为程序的基本单位，通过封装、继承、多态等概念来组织和实现程序逻辑。面向对象的编程思想强调将问题分解为对象的集合，每个对象具有自己的状态（属性）和行为（方法），并通过相互之间的消息传递来实现协助和交互。类（Class）是用来对一个实体（对象）进行描述的，主要包括实体（对象）的属性和行为的描述。在Java语言中，类是面向对象编程的基本组织单位，它是对象的模版或者蓝图，描述了对象的属性和行为。
C++ 类和对象
AusrEnder的博客
05-18 1301
万事万物均可作为, 每个对象都有其对于某些具有和的对象, 可以抽象为比如所有的圆形都属于圆类, 人都属于人类.
重新认识面向对象
03-03
火龙果软件工程技术中心 经常可以从开发人员口中听到“面向对象”这个词：场景1、A：我今天开始用面向对象的方法设计程序了！B：你怎么做的？A：我把保存文件、加载文件封装成了一个类，以后只要调用这个类就可以...
类与对象实验
12-24
2.以下是一个类中包含另一个类对象成员（类的组合）的例子，试分析并给出程序的运行结果． #include class Son { 　int age; public: Son(){ age=1;} Son(int i){age=i;} void print(){ cout儿子的年龄是:";} ...
Java第4章 认识类和对象.含源代码
11-08
在Java编程语言中，类和对象是核心概念，它们构成了面向对象编程的基础。本章将深入探讨这两个概念，以及如何在实际编程中运用它们。源代码的提供将帮助我们更直观地理解这些理论知识。 首先，我们需要理解什么是类...
VC类与对象详解
02-04
由浅入深讲解VC中的类与对象的概念，使你对类和对象有一个清晰的认识。
七：面向对象--＞认识类与对象
qq_42263859的博客
06-20 272
该章节主要介绍了类和对象的创建和使用、
对类和对象的一些理解
qq_45870665的博客
10-27 319
类和对象的相关理解 1.面向对象的概念： 面向对象是思考问题的一种思考方式，是一种思想。比如：理论与实践。 类就是一类对象的统称。对象就是这一类具体化的一个实例。 .面向对象的好处：将复杂的事情变简单了，只要面对一个对象就行。 2.类和类的实例化 类是一类对象的统称，对象是这一类具体化的实例。 类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。 声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型， Java 使用关键字 class 来声明类。我们来看以下简单的声明
谈谈我对面向对象以及类与对象的理解
weixin_33795743的博客
10-09 732
文章最初发表于我的个人博客非典型性程序猿 对于刚接触JAVA或者其他面向对象编程语言的朋友们来说，可能一开始都很难理解面向对象的概念以及类和对象的关系。笔者曾经带过一个短期培训班教授java入门基础，在最后结束课程的时候，还有很多同学不太理解面向对象的思维以及类与对象的意义。这几天有空，就想着整理整理自己的思路，谈谈自己对面向对象以及类...
浅谈JAVA中类和对象的理解
果冻的杂记
10-21 818
我们知道编程语言是一个帮助我们和计算机“对话”的工具，我们可以通过它去让计算机做一些事。而JAVA语言又是其中的高级语言，那么什么是高级？机器语言和人类语言之间有着巨大的鸿沟，人们不断的想要跨过这个鸿沟，在这个过程中出现了一些“工具”，就是所谓的编程语言。通过这些语言我们也实现了和计算机沟通的能力，但是这些语言依然和自然语言有很大的差别，以至于学习这些语言变得困难，在这个问题上人们也在不断的改进，
Java第十三天---类和对象以及方法
m0_55694442的博客
07-28 581
现实世界中客观存在的物体，具有属性和方法属性描述对象的特征方法描述对象的行为（能干什么）定义属性访问权限修饰符（暂时不写）属性类型（数据类型）属性名（变量名）;定义方法访问权限修饰符返回值类型方法名(参数列表[可以不写]){方法体}创建对象类名对象名=new类名();给对象的属性赋值对象名.属性名=数据;对象调用方法对象名.方法名()...
类和对象相关解释及实例
fool_Java的博客
07-16 1689
类、成员变量、成员方法、以及对象用法
Java类和对象 详解（一）
热门推荐
wei_zhi的博客
10-06 18万+
一、面向对象简述面向对象是一种现在最为流行的程序设计方法，几乎现在的所有应用都以面向对象为主了，最早的面向对象的概念实际上是由IBM提出的，在70年代的Smaltalk语言之中进行了应用，后来根据面向对象的设计思路，才形成C++，而由C++产生了Java这门面向对象的编程语言。但是在面向对象设计之前，广泛采用的是面向过程，面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主，实
类和对象的简单理解
twier_的博客
05-27 431
C语言和Objective-CC语言是面向过程的编程语言：是把要考虑做的事情做完才考虑对象是谁，而Objective-C是面向对象的编程语言，要先明白对象是谁。Objective类与对象类我理解就是一大类的总称，人类可以算是一类，而每个人都是不同的对象，人执行的任何事情，吃饭，睡觉，运动......等一系列是对对象的操作。@autoreleasepool{ //自动释放池 //使在创建新对象时，系...
什么是类？什么是对象？类和对象有什么关系？
谦
05-13 11万+
面向对象(Object Oriented,OO)。 起初，“面向对象”是指在程序设计中采用封装、继承、多态等设计方法。现在，面向对象的思想已经涉及到软件开发的各个方面。如，面向对象的分析（OOA，ObjectOriented Analysis），面向对象的设计（OOD，Object Oriented Design）、以及面向对象的编程实现（OOP，Object Oriented Programm
认识类和对象
maduan12的博客
08-09 143
一、定义类 二、定义对象 三、类和对象的关系 首先了解类和对象之前我们需要知道为什么要用到类和对象，在之前我们的开发方法都是结构化开发，面向功能划分软件结构，是自顶向下的运行代码，最小的子系统是方法，也就制约了软件的可维护性和可扩展性 而面向对象开发是把软件系统看成各种对象的集合，系统结构较为稳定，子系统也相对独立，所以软件的可重用性、可维护性和可扩展性强。 类是什么，对象又是什么，我们所了解的类有很多种，人类、金属类、动物类等等，都是一个类，分类，对象也就是其中具体的东西，比如人类有男人
java认识类和对象
最新发布
06-15
对象则是类的实例，是类的具体表现形式，每个对象都有其特定的属性值和可以执行的方法。 **类的定义**： - 属性：类中包含的数据成员，也称为字段或属性变量，用来描述对象的状态。 - 方法：类中的函数，用于描述...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值