day04【面向对象、封装、static】

逃离我推掉我的手 2022-09-02 05:20 115阅读 0赞

# day04【面向对象、封装】 #

# 一、面向对象 #

## 1.1 面向对象概述 ##

### 1.1.1 什么是对象 ###

在Java中，对象（Object）是指一个具体事物的实例，任何事物都可以使用对象（类）来描述，如猫、狗、计算机、杯子、云、水、空气、叶子、灰尘等看得见的、看不见的、宏观的、微观的、具体的、抽象的都是对象，总之"万物皆对象"；

### 1.1.2 面向对象程序设计 ###

我们前面就提到过，Java是一门面向对象的编程语言，面向对象是一种程序设计思想，与之对应的还有面向过程程序设计；面向对象是把一个对象的特征（属性）和行为单独封装到对象源代码中；这些属性和行为都被集中到一个地方，这样比把方法或者过程与数据分散开来更为方便和安全，含义更加明确；

### 1.1.3 面向对象和面向过程 ###

举例：开车去上班

*  面向过程：去车库提车、拿钥匙、打火、踩离合、挂挡、踩油门、刹车、加油、到公司、找车库停车
 *  面向对象：找个司机（对象）、到公司

可以看得出来，面向过程关注的是步骤，将所有步骤连在一起"我就能到公司上班"，面向对象则关注的是"开车去上班"这个事物整体，完成这件事的步骤全部**封装**起来，交给指定的对象去做（司机）；

### 1.1.4 面向对象的特点 ###

面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。面向对象的语言中，包含了三大基本特征，即封装、继承和多态。

> tips：关于面向对象和面向过程大家不必太过纠结，我们现在是初学者，理解表面意思即可，随着后面的深入学习，我们会对面向对象有着更深刻的理解；

## 1.2 类和对象 ##

### 1.2.1 类和对象的区分 ###

在现实世界中，属于同一类的对象很多，**类是抽象的**，不是具体的，我们人习惯以对象的方式认识现实世界；

例如我说一辆汽车，那你脑海中立马就能够呈现出一辆汽车的模样吧，不管他是什么品牌、什么颜色、什么价格、什么参数等总而言之，都是一辆汽车，都是属于"汽车类"产品；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]

> tips：**类是抽象的，对象是具体的，对象是类的实例化；**

类是一组相关属性和行为的集合。可以看成是一类事物的**模板**，使用事物的**属性特征**和**行为特征**来描述该类事物。

*  属性：该事物的状态信息；
 *  行为：该事物的功能信息；

### 1.2.2 类和对象的举例 ###

*  类举例：

举例：猫类

属性：名字、体重、年龄、颜色； 行为：走、跑、叫；

*  实例化对象：

猫对象：

属性：旺财、8kg、6岁、棕色；行为：悄悄的走、飞快的跑、喵喵叫；

## 1.3 Java类的定义 ##

### 1.3.1 类的定义格式 ###

public class 类名 { 
    	//成员变量
        //成员方法
    }

*  **定义类：** 就是定义类的成员，包括成员变量和成员方法。
 *  **成员变量：** 和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。
 *  **成员方法：** 和以前定义方法几乎是一样的。只不过把static去掉，static的作用在面向对象后面课程中再详细讲解。

类的定义格式举例：

/** * @author lscl * @version 1.0 * @intro: */
    public class Student { 
        // 成员变量(属性)
        String name;        //姓名
        int age;            //年龄
    
        // 成员方法(行为) 
        public void study(){ 
            System.out.println("学习");
        }
    
        public void eat(){ 
            System.out.println("吃饭");
        }
    }

### 1.3.2 类的实例化 ###

前面我们说道过，类是抽象的，不是具体的，类只是负责把事物描述起来，提供模板；对象是类的实例化，是具体的；我们定义好一个Java类后需要通过对象将类进行实例化；

*  创建对象：

类名 对象名 = new 类名();

*  使用对象访问类中的成员：

对象名.成员变量;
    对象名.成员方法();

*  练习：

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) { 
            //创建对象格式： 类名 对象名 = new 类名();
            Student s = new Student();
    
            System.out.println("s: " + s);            //s: com.dfbz.demo.Student@1540e19d
    
            //直接输出成员变量的值
            System.out.println("姓名: " + s.name);      //null
            System.out.println("年龄" + s.age);         //0
            System.out.println("--------");
    
            //给成员变量赋值
            s.name = "刘德华";
            s.age = 38;
    
            //再次输出成员变量的值
            System.out.println("姓名： " + s.name);      //刘德华
            System.out.println("年龄： " + s.age);       //18
            System.out.println("---------");
    
            //调用成员方法
            s.study();          //学习
            s.eat();            //吃饭
        }
    }

### 1.3.3 成员变量的默认值 ###

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>数据类型</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>基本类型</td> 
   <td>整数（byte，short，int，long）</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>浮点数（float，double）</td> 
   <td>0.0</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>字符（char）</td> 
   <td>‘\u0000’</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>布尔（boolean）</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td>引用数据类型</td> 
   <td>数组，对象，String</td> 
   <td>null</td> 
  </tr> 
 </tbody> 
</table>

*  定义手机类并使用：
    
     *  属性：品牌，价格，颜色；
     *  行为：打电话，发短信

1）定义Phone类：

/** * @author lscl * @version 1.0 * @intro: */
    public class Phone { 
    
        //成员变量
        String brand;
        int price;
        String color;
    
        //成员方法
        //打电话
        public void call(String name){ 
            System.out.println("给"+name+"打电话");
        }
    
        //发短信
        public void sendMessage(){ 
            System.out.println("大家新年好！");
        }
    }

2）定义测试类：

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) { 
            //创建对象
            Phone p=new Phone();
    
            System.out.println("品牌： "+p.brand);     // null
            System.out.println("价格： "+p.price);     // 0
            System.out.println("颜色： "+p.color);     // null
    
            System.out.println("-------");
    
            p.brand="华为";
            p.price=2999;
            p.color="银白色";
    
            System.out.println("品牌： "+p.brand);     //华为
            System.out.println("价格： "+p.price);     //2999
            System.out.println("颜色： "+p.color);     //银白色
            System.out.println("------------");
    
            p.call("刘德华");
            p.sendMessage();
        }
    }

## 1.4 对象内存图 ##

回顾JVM内存，JVM总共分为5大内存区域，寄存器、本地方法栈、方法区、栈内存（虚拟机栈）、堆内存；和我们程序员有关的为方法区、栈内存、堆内存；

*  方法区：存储类的信息（有多少变量、方法、是什么修饰符修饰的等）、常量信息、静态变量等信息
 *  栈内存（VM栈）：方法调用时进栈内存执行，也就是方法运行时消耗的内存；
 *  堆内存：存储类的实例信息，只要是new出来的信息都存在堆内存

new这个类的时候，Jvm去方法区找有没有这个class，没有就加载到方法区，属性方法这些都是在方法区class中的；Jvm加载完后，就根据这个模板在堆中创建对象给属性赋默认值，然后再执行赋值语句给对象赋值；

一个对象内存图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]

两个对象内存图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]

> 对象调用方法时，根据对象中方法标记（地址值），去类中寻找方法信息。这样哪怕是多个对象，方法信息只保存一份，节约内存空间。

## 1.5 局部变量和成员变量 ##

变量根据定义位置的不同，我们给变量起了不同的名字，看下列测试类：

/** * @author lscl * @version 1.0 * @intro: */
    public class Person { 
        String name;            // 成员变量
    
        int age;                // 成员变量
    
        /** * 跑步方法 */
        public void running() { 
            int stretch = 10;           // 局部变量
            System.out.println("跑了" + stretch + "公里");
        }
    
        /** * 自我介绍方法 * @param name: 姓名(局部变量) * @param age: 年龄(局部变量) */
        public void intro(String name, int age) { 
            System.out.println("大家好，我叫" + name + ",今年" + age + "岁");
        }
    
        /** * 计算方法(列出0~num之间的偶数) * @param num: 局部变量 */
        public void calculate(int num) { 
    
            for (int i = 0; i < num; i++) { 
                if (num % 2 == 0) { 
                    System.out.println(num);
                }
            }
        }
    }

*  局部变量与成员变量：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]

> 关于static关键字我们后面再解释，暂时把不用把实例变量与类变量区分开；

*  成员变量和局部变量的区别：
    
     *  成员变量：
        
         *  1）成员变量定义在类中，在整个类中都可以被访问。
         *  2）成员变量分为类成员变量和实例成员变量，实例变量存在于对象所在的堆内存中。
         *  3）成员变量有默认初始化值。
         *  4）成员变量的权限修饰符可以根据需要，选择任意一个
     *  局部变量：
        
         *  1）局部变量只定义在局部范围内，如：方法内，代码块内等。
         *  2）局部变量存在于栈内存中，当方法弹栈（执行完毕）后，局部变量销毁；
         *  3）局部变量没有默认初始化值，使用前必须手动赋值；
         *  4）局部变量声明时不指定权限修饰符；

## 1.6 值传递和引用传递 ##

### 1.6.1 思考 ###

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo04 { 
        public static void main(String[] args) { 
            Phone p1=new Phone();
    
            p1.price=2899;
    
            test(p1);
            System.out.println(p1.price);           // 2899 or 3899?
    
            int i=20;
            test2(i);
    
            System.out.println(i);                  // 20 or 50?
        }
    
        public static void test(Phone p){ 
            p.price=3899;
        }
    
        public static void test2(int i){ 
            i=50;
        }
    }

### 1.6.2 形参和实参 ###

形参也叫形式参数，是一个方法的参数列表中的参数；实参也叫实际参数，是调用者在调用方法时实际传递的参数；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]

### 1.6.3 值传递和引用传递概念 ###

*  值传递：（参数类型是基本数据类型）：方法调用时，实参把它的值传递给对应的形参，形参只是用实参的值初始化自己的存储单元内容，**是两个不同的存储单元**，所以方法执行中形参值的改变不影响实参的值。
 *  引用传递：(参数类型是引用数据类型参数)：也称为传地址。方法调用时，实参是对象（或数组），这时实参与形参指向同一个地址，在方法执行中，对形参的操作实际上就是对实参的操作，这个结果在方法结束后被保留了下来，所以方法执行中形参的改变将会影响实参。

> 在Java中，除了基本数据类型之外的数据类型都是引用数据类型，都是通过new在堆内存开辟空间；

*  引用传递对象内存图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 5]

## 1.7 匿名对象 ##

顾名思义，匿名就是没有名字的对象，在创建对象时，只通过new的动作在堆内存开辟空间，却没有把堆内存空间的地址值赋值给栈内存的某个变量用以存储；

使用场景：

*  1）如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
 *  2）我们经常将匿名对象作为实参传递给一个方法调用。

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo05 { 
        public static void main(String[] args) { 
    
            Student student=new Student();
            intro(student);
            student.study();
    
            // 使用匿名对象传递
            intro(new Student());
    
            // 使用匿名对象调用方法
            new Student().study();
        }
    
        public static void intro(Student student) { 
            System.out.println("姓名： "+student.name+",年龄： "+student.age);
        }
    }

# 二、封装 #

## 2.1 封装概述 ##

封装是面向对象的三大特征之一，面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性

*  举例：

就拿一辆汽车来说，外部有一个壳，将内部的原件封装起来，至于汽车内部的细节是什么，我们不需要关心，对于用户来说，我们只需要会操作这辆汽车就可以，汽车对外提供方向盘、离合器、油门、以及一些娱乐设备，这样就将内部的东西不在直接暴露给外部，增加了安全性；

我们来举例一段代码，看看没有封装的对象会存在什么问题：

准备一个Student类，具备姓名、年龄等属性

/** * @author lscl * @version 1.0 * @intro: */
    public class Student { 
    
        // 学生姓名
        String name;
        
        // 学生年龄
        int age;
    }

编写测试类：

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
    
        public static void main(String[] args) { 
            Student s1 = new Student();
            s1.name = "小灰";
            s1.age = 2800;
    
            intro(s1);
    
            Student s2 = new Student();
            s2.name = "小蓝";
            s2.age = -280;
    
            intro(s2);
        }
    
        public static void intro(Student student) { 
            System.out.println("大家好,我叫" + student.name + ",今年" + student.age + "岁");
        }
    }

![在这里插入图片描述][4730442f498a46f2bddd605cb683c508.png_pic_center]

上述代码是可以正常运行的（编译不会报错），但是对于我们程序逻辑来说是错误的；

Student类未进行封装，其所有属性直接暴露给外部，外部程序可以任意的对Student的属性就行修改，这是非常有安全隐患的，我们的正常年龄可以设置一个正常区间如0~120岁，不可能到2800多岁，也不可能是负的岁数；因此我们要对属性加以管控，而不是直接暴露给外端；

## 2.2 priavte 关键字 ##

1.  private是一个权限修饰符，代表最小权限。
2.  可以修饰成员变量和成员方法。
3.  **被private修饰后的成员变量和成员方法，只在本类中才能访问。**

封装的原则：将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问

1）使用`private` 修饰成员变量，代码如下：

public class Student { 
    
        // 学生姓名
        private String name;
    
        // 学生年龄
        private int age;
    }

2）提供 `getXxx` 方法 / `setXxx` 方法，可以访问成员变量，代码如下

/** * @author lscl * @version 1.0 * @intro: */
    public class Student { 
    
        // 学生姓名
        private String name;
    
        // 学生年龄
        private int age;
    
        public String getName() { 
            return name;
        }
    
        public void setName(String _name) { 
            name = _name;
        }
    
        public int getAge() { 
            return age;
        }
    
        public void setAge(int _age) { 
            if (_age > 0 && _age < 120) { 
                age = _age;
                System.out.println("赋值成功,您的年龄为: " + _age);
            } else { 
                System.out.println("您输入的年龄不合法," + _age);
            }
        }
    }

3）测试类：

/** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
    
        public static void main(String[] args) { 
            Student s1 = new Student();
            s1.setName("小灰");
            s1.setAge(2888);
            s1.setAge(-280);
            s1.setAge(20);
    
        }
    
        public static void intro(Student student) { 
            System.out.println("大家好,我叫" + student.getName() + ",今年" + student.getAge() + "岁");
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 6]

> 经过封装后，属性再也不是直接暴露给外部了，我们可以在外部操作属性之前加以控制；

## 2.3 this 关键字 ##

this是Java中的一个关键字，代表所在类的当前对象的引用（地址值），即对象自己的引用；

*  修改Student中的set方法：

public class Student { 
    
        // 学生姓名
        private String name;
    
        // 学生年龄
        private int age;
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            // this代表当前对象的内存地址值
            this.name = name;
        }
    
        public int getAge() { 
            return age;
        }
    
        public void setAge(int age) { 
            if (age > 0 && age < 120) { 
                // this代表当前对象的内存地址值
                this.age = age;
                System.out.println("赋值成功,您的年龄为: " + age);
            } else { 
                System.out.println("您输入的年龄不合法," + age);
            }
        }
    }

this内存图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 7]

> tips ：方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

## 2.4 构造方法 ##

构造方法也叫构造器，顾名思义就是用来构造类的；当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。

> tips：无论你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法，一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。

*  构造方法的定义格式

修饰符 构造方法名(参数列表){ 
        // 方法体
    }

构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void。使用构造方法后，代码如下：

/** * @author lscl * @version 1.0 * @intro: */
    public class Phone { 
        private String name;
        private int price;
    
        // 无参构造方法
        public Phone() { 
    
        }
    
        // 有参构造方法
        public Phone(String name, int price) { 
            this.name = name;
            this.price = price;
        }
    }

构造方法注意事项：

1.  如果你不提供构造方法，系统会给出无参数构造方法。
2.  如果你提供了构造方法，系统将不再提供无参数构造方法。
3.  构造方法是可以重载的，既可以定义参数，也可以不定义参数。

## 2.5 标准JavaBean ##

`JavaBean` 是 Java语言编写类的一种标准规范。符合 `JavaBean` 的类，要求类必须是和公共的，并且具有无参数的构造方法，提供用来操作成员变量的 `set` 和 `get` 方法，采用private修饰成员变量。

*  格式如下：

public class ClassName{ 
        //成员变量
        //构造方法
        //无参构造方法【必须】
        //有参构造方法【建议】
        //成员方法 
        //getXxx()
        //setXxx()
    }

编写符合 `JavaBean` 规范的类，以学生类为例，标准代码如下：

/** * @author lscl * @version 1.0 * @intro: */
    public class Phone { 
        //成员变量
        private String brand;
        private int price;
    
        //构造方法
        public Phone() { 
    
        }
    
        public Phone(String brand, int price) { 
            this.brand = brand;
            this.price = price;
        }
        //成员方法 
    
        public String getBrand() { 
            return brand;
        }
    
        public void setBrand(String brand) { 
            this.brand = brand;
        }
    
        public int getPrice() { 
            return price;
        }
    
        public void setPrice(int price) { 
            this.price = price;
        }
    
    }

# 三、package包 #

## 3.1 包的概述 ##

package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。它的格式为：

package 顶层包名.子包名;

查看我们的代码目录：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 8]

所有的类都在一个目录下（根目录），随着项目的类越来越，我们的项目会变得难以维护；包（package）类似于我们的文件夹，当文件多了，我们可以创建多个文件夹对文件进行归类，包则是对Java源代码进行归类；

## 3.2 创建包 ##

使用IDEA创建包：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 9]

> 包的名称一般为公司倒写域名，例如com.alibaba、com.baidu等；`.`代表分割，com.dfbz实际创建了一个二级目录；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 10]

也可以通过创建类的方式来创建包：

输入`com.dfbz.Demo02`：在com/dfbz包下创建了一个Demo02类：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 11]

输入`com.abc.Demo01`：在com/abc包下创建了一个Demo01类：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 12]

最终目录结构：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 13]

## 3.3 声明包 ##

在任何类的第一句代码都必须声明这个类在哪个包下的，我们之前的类都创建在根目录（src目录），因此不需要声明所在的包，**除了根目录下的类都需要在类的第一行声明包；**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 14]

> 1）包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；
> 
> 2）包通常用小写单词，类名首字母通常大写；

## 3.4 import导入包 ##

为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.\*)。import语句告诉编译器到哪里去寻找类

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 15]

如果想要导入这个包下的所有类，使用`*`：

import com.dfbz.*;

# 四、static关键字 #

## 4.1 static概述 ##

`static` 关键字它可以用来修饰的**成员变量**和**成员方法**，**被修饰的成员是属于类的**，而不是单单是属于某个对象的。被static修饰的成员由该类的所有实例（对象）共享；

## 4.2 定义和使用格式 ##

### 4.2.1 类变量 ###

当 `static` 修饰成员变量时，该变量称为**类变量**。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作，因为该变量属于类，而不是某个对象。

*  **类变量：** 使用 static关键字修饰的成员变量。

定义格式：

static 数据类型 变量名;

举例：

static int numberID;

现在想为每一位新来报到的同学编学号（sid），从第一名同学开始，sid为1，以此类推。学号必须是唯一的，连续的，这样以便知道，要分配给下一名新同学的学号是多少。这样我们就需要一个变量，与单独的每一个学生对象无关，而是与整个班级同学数量有关。

所以，我们可以这样定义一个静态变量numberID，代码如下：

package com.dfbz.demo;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class demo01 { 
        public static void main(String[] args) { 
    
            Student s1 = new Student("张三", 23);
            Student s2 = new Student("李四", 24);
            Student s3 = new Student("王五", 25);
            Student s4 = new Student("赵六", 26);
    
            s1.show(); // Student : name=张三, age=23, sid=1
            s2.show(); // Student : name=李四, age=24, sid=2
            s3.show(); // Student : name=王五, age=25, sid=3
            s4.show(); // Student : name=赵六, age=26, sid=4
        }
    }
    
    class Student { 
        // 存储到底创建了多少个学生
        static int numberID = 0;
        int sid;
        String name;
        int age;
    
        public Student() { 
            // 每次创建一个学生,id都自增1
            numberID++;
            sid=numberID;
        }
    
        public Student(String name, int age) { 
            // 每次创建一个学生,id都自增1
            numberID++;
            sid=numberID;
            this.name = name;
            this.age = age;
        }
    
        public void show() { 
            System.out.println("sid: " + sid + "-name: " + name + "-age: " + age);
        }
    }

### 4.2.2 静态方法 ###

当 `static` 修饰成员方法时，该方法称为类方法。静态方法在声明中有 static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。

*  **类方法**：使用 static关键字修饰的成员方法，习惯称为**静态方法**。

定义格式：

修饰符 static 返回值类型 方法名 (参数列表) {  
    	// 执行语句
    }

举例：在Student类中定义静态方法

public static void showNum() { 
        System.out.println("numberID:" + numberID);
    }

*  静态方法调用的注意事项：
    
     *  静态方法可以直接访问类变量（被static修饰的变量）和静态方法。（静态方法能够访问静态资源）
     *  静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
     *  静态方法中，不能使用this关键字。

> tips：静态方法只能访问静态成员。

### 4.2.3 调用格式 ###

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个**静态成员**，但是不建议，会出现警告信息。

格式：

// 访问类变量
    类名.类变量名；
    
    // 调用静态方法
    类名.静态方法名(参数)；

调用演示，代码如下：

public static void main(String[] args) { 
        // 访问类变量
        System.out.println(Student.numberID);
        // 调用静态方法
        Student.showNum();
    }

## 4.3 静态原理图解 ##

`static` 修饰的内容：

*  是随着类的加载而加载的，且只加载一次。
 *  存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。
 *  它优先于对象存在，所以，可以被所有对象共享。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 16]

## 4.4 静态代码块 ##

*  静态代码块：定义在成员位置，使用static修饰的代码块\{ \}。
    
     *  位置：类中方法外。
     *  执行：随着类的加载执行，而执行且执行一次。

格式：

public class ClassName { 
        static { 
            //执行语句
        }
    }

作用：给类变量进行初始化赋值。用法演示，代码如下：

public class Computer { 
        private String name;
        private double price;
    
        // 类一加载,静态代码块中的代码就会被执行，而且是执行一次
        static{ 
            System.out.println("加载网卡驱动....");
            System.out.println("加载声卡驱动....");
            System.out.println("加载第三方软件插件....");
        }
    }

> tips：static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况下，去调用方法。下面将介绍两个工具类，来体现static 方法的便利。

--------------------

**上一篇**：[day03【流程控制、JVM内存、数组】][day03_JVM]

**下一篇**：[day05【继承、抽象、权限修饰符、final】][day05_final]

**目录**：【JavaSE零基础系列教程目录】

--------------------

# 记得点赞~！！！ #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/8d6b8a9e12814eb5b3515d1c81a45eb6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20220829/e60d6127366649bb829b84d0e50c4686.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20220829/47a8e51c0475479488571cdbbde1b867.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20220829/3b44932c0a744b65b81265f4e5ff6fdc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20220829/6108fd63b8ac4e0ea2b0cc9aca13488d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20220829/4d4711e5ebc6418387ff2718a94814db.png
[4730442f498a46f2bddd605cb683c508.png_pic_center]: /images/20220829/00b2210e655148afa9293ba84d0073d5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20220829/5d7a2f44883d406a8b056b09792c92c3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20220829/a38ce0037df148ba8b83292c57e05fdf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20220829/9d0b4c51a1d44635ad160e5629c50e69.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20220829/7ca2aae01908429995409ecc0df64c8b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20220829/6878cdbccbcb4c5a8934c842c0e3b0c9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20220829/348c5a87334d4dbb8d9a2795d599a54a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20220829/4ef64da8a66847b995fb0b69c6f99089.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20220829/eb7f63b8cf6d4f1ca59f2d5590ed8f26.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20220829/b9fd5f9b68d944fabc91f87aeafb6f4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20220829/ceac95a52f3040d88deb4612d41b74c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20220829/62f8864cd7c841dc971f7fdf96e85ac2.png
[day03_JVM]: https://blog.csdn.net/Bb15070047748/article/details/119255318?spm=1001.2014.3001.5501
[day05_final]: https://blog.csdn.net/Bb15070047748/article/details/119255496?spm=1001.2014.3001.5501