• JAVA中类和对象的认识

    1、面向对象的初步认知

    1.1 什么是面向对象

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

    1.2 面向对象与面向过程

    1.2.1. 传统洗衣服过程

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

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

    1.2.2. 现代洗衣服过程

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

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

    面向对象：不关注过程！

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

    2. 类定义和使用

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

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

    2.1简单认识类

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

    比如：洗衣机，它是一个品牌，在Java中可以将其看成是一个类别。

    属性：产品品牌，型号，产品重量，外观尺寸，颜色...

    功能：洗衣，烘干、定时....

    2.2类的定义格式  

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

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

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

    类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类 具有哪些功能，称为类的成员方法。

    1. public class WashMachine {
    2.     public String brand;
    3.     public String type;
    4.     public double weight;
    5.     public double width;
    6.     public double height;
    7.     public String color;
    8.  
    9.     public void washMachine(){
    10.         System.out.println("洗衣服！");
    11.     }
    12.     public void dryClothes(){
    13.         System.out.println("烘干衣服！");
    14.     }
    15.     public void setTime(){
    16.         System.out.println("定时");
    17.     }
    18. }

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


    2.3 定义一个学生类

    1. public class Student{
    2. public String name;
    3. public String gender;
    4. public short age;
    5. public double score;
    6. public void DoClass(){}
    7. public void DoHomework(){}
    8. public void Exam(){}
    9. }

    注意事项：

    1. 一般一个文件当中只定义一个类
    2. main 方法所在的类一般要使用 public 修饰 ( 注意： Eclipse 默认会在 public 修饰的类中找 main 方法 )
    3. public 修饰的类必须要和文件名相同
    4. 不要轻易去修改 public 修饰的类的名称，如果要修改，通过开发工具修改


    3. 类的实例化

    3.1 什么是实例化

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

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

    1.  class Dog {
    2.  
    3.         public String name;//名字
    4.         public String color;//颜色
    5.         // 狗的属性
    6.         public void barks() {
    7.             System.out.println(name + ": 旺旺旺~~~");
    8.             System.out.println(name + " "+color+"的尾巴！！！");
    9.         }
    10.         // 狗的行为
    11.         public void wag() {
    12.             System.out.println(name + ": 摇尾巴~~~");
    13.         }
    14.  
    15.         public static void main(String[] args) {
    16.             Dog dog1 = new Dog(); //通过new实例化对象
    17.             dog1.name = "旺财";
    18.             dog1.color = "白色";
    19.             dog1.barks();
    20.             dog1.wag();
    21.             System.out.println("---------------------------");
    22.             Dog dog2 = new Dog();
    23.             dog2.name = "小黄";
    24.             dog2.color = "黄色";
    25.             dog2.barks();
    26.             dog2.wag();
    27.         }
    28.     }
    29.  
    30.

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

    3.2 类和对象的说明

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

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

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

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

    4. this引用

    4.1 为什么要有this引用

    先看一个日期类的例子：

    1. public class Date {
    2. public int year;
    3. public int month;
    4. public int day;
    5. public void setDay(int y, int m, int d){
    6. year = y;
    7. month = m;
    8. day = d;
    9. }
    10. public void printDate(){
    11. System.out.println(year + "/" + month + "/" + day);
    12. }
    13. public static void main(String[] args) {
    14. // 构造三个日期类型的对象 d1 d2 d3
    15. Date d1 = new Date();
    16. Date d2 = new Date();
    17. Date d3 = new Date();
    18. // 对d1，d2，d3的日期设置
    19. d1.setDay(2020,9,15);
    20. d2.setDay(2020,9,16);
    21. d3.setDay(2020,9,17);
    22. // 打印日期中的内容
    23. d1.printDate();
    24. d2.printDate();
    25. d3.printDate();
    26. }
    27. }

    以上代码定义了一个日期类，然后 main 方法中创建了三个对象，并通过 Date 类中的成员方法对对象进行设置和打印，代码整体逻辑非常简单，没有任何问题。

    但是细思之下有以下两个疑问：

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

    1. public void setDay ( int year , int month , int day ){
    2. year = year ;
    3. month = month ;
    4. day = day ;
    5. }

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

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

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

    4.2 什么是this引用

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

    1. public class Data {
    2.     public int year;
    3.     public int month;
    4.     public int day;
    5.  
    6.     public void setDay(int y,int m,int d){
    7.        this.year = y;
    8.         this.month = m;
    9.         this.day = d;
    10.     }
    11.     public void printData(){
    12.         System.out.println(this.year+"年"+this.month+"月"+this.day+"日");
    13.     }
    14.  
    15.     public static void main(String[] args) {
    16.  
    17.         Data data = new Data();
    18.         data.setDay(2022,11,10);
    19.         data.printData();
    20.     }
    21. }

    注意： this 引用的是调用成员方法的对象 。

    1.   public static void main(String[] args) {
    2.  
    3.         Data data = new Data();
    4.         data.setDay(2022,11,10);
    5.         data.printData();
    6.     }

    4.3 this引用的特性

    1. this 的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
    2. this 只能在 " 成员方法 " 中使用
    3. 在 " 成员方法 " 中， this 只能引用当前对象，不能再引用其他对象
    4. this 是 “ 成员方法 ” 第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this 负责来接收
    在代码层面来简单演示--->注意：下图右侧中的Date类也是可以通过编译的

    5. 对象的构造及初始化

    5.1 如何初始化对象

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

    1.  
    2. public static void main(String[] args) {
    3. int a;
    4. System.out.println(a);
    5. }
    6. // Error:(26, 28) java: 可能尚未初始化变量a

    要让上述代码通过编译，非常简单，只需在正式使用 a 之前，给 a 设置一个初始值即可。如果是对象：

    1.  
    2. public static void main(String[] args) {
    3. Date d = new Date();
    4. d.printDate();
    5. d.setDate(2021,6,9);
    6. d.printDate();
    7. }
    8. // 代码可以正常通过编译

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

    5.2 构造方法  

    5.2.1 概念

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

    1. public class Date {
    2. public int year;
    3. public int month;
    4. public int day;
    5. // 构造方法：
    6. // 名字与类名相同，没有返回值类型，设置为void也不行
    7. // 一般情况下使用public修饰
    8. // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
    9. public Date(int year, int month, int day){
    10. this.year = year;
    11. this.month = month;
    12. this.day = day;
    13. System.out.println("Date(int,int,int)方法被调用了");
    14. }
    15. public void printDate(){
    16. System.out.println(year + "-" + month + "-" + day);
    17. }
    18. public static void main(String[] args) {
    19. // 此处创建了一个Date类型的对象，并没有显式调用构造方法
    20. Date d = new Date(2021,6,9); // 输出Date(int,int,int)方法被调用了
    21. d.printDate(); // 2021-6-9
    22. }
    23. }

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

    5.2.2 构造方法的特性

    1. 名字必须与类名相同

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

    3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次 ( 相当于人的出生，每个人只能出生一次 )
    4. 构造方法可以重载 ( 用户根据自己的需求提供不同参数的构造方法 )。
     

    1. public class Data {
    2.     public int year;
    3.     public int month;
    4.     public int day;
    5. //有参数的构造方法
    6.     public Data(int year, int month, int day){
    7.         this.year = year;
    8.         this.month = month;
    9.         this.day = day;
    10.     }
    11. //无参数的构造方法 并且初始化
    12.     public Data(){
    13.         this.year = 2002;
    14.         this.month = 03;
    15.         this.day = 19;
    16.     }
    17.  
    18.     public void printData(){
    19.         System.out.println(this.year+"年"+this.month+"月"+this.day+"日");
    20.     }
    21.  
    22.     public static void main(String[] args) {
    23.         //实例化有参数构造方法 并且初始化
    24.         Data data = new Data(2022,11,10);
    25.         //实例化无参数的构造方法
    26.         Data data2 = new Data();
    27.         
    28.         data.printData();
    29.         data2.printData();
    30.     }
    31. }

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

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

    1. public class Data1 {
    2.     public int year;
    3.     public int month;
    4.     public int day;
    5.  
    6.     public void printData(){
    7.         System.out.println(this.year+"年"+this.month+"月"+this.day+"日");
    8.     }
    9.  
    10.     public static void main(String[] args) {
    11.         Data data2 = new Data();
    12.         data2.printData();
    13.     }
    14. }

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

    注意： 一旦用户定义，编译器则不再生成。

    1. public class Date {
    2. public int year;
    3. public int month;
    4. public int day;
    5. public Date(int year, int month, int day) {
    6. this.year = year;
    7. this.month = month;
    8. this.day = day;
    9. }
    10.     public void printDate(){
    11.         System.out.println(year + "-" + month + "-" + day);
    12.     }
    13.     public static void main(String[] args) {
    14. // 如果编译器会生成，则生成的构造方法一定是无参的
    15. // 则此处创建对象是可以通过编译的
    16. // 但实际情况是：编译期报错
    17.         Date d = new Date();
    18.         d.printDate();
    19.     }
    20. }
    21. /*
    22. Error:(26, 18) java: 无法将类 extend01.Date中的构造器 Date应用到给定类型;
    23. 需要: int,int,int
    24. 找到: 没有参数
    25. 原因: 实际参数列表和形式参数列表长度不同
    26. */

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

    1. public class Date {
    2. public int year;
    3. public int month;
    4. public int day;
    5. // 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
    6. // 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
    7. // 但是this(1900,1,1);必须是构造方法中第一条语句
    8. public Date(){
    9. //System.out.println(year); 注释取消掉，编译会失败
    10. this(1900, 1, 1);
    11. //this.year = 1900;
    12. //this.month = 1;
    13. //this.day = 1;
    14. }
    15. // 带有三个参数的构造方法
    16. public Date(int year, int month, int day) {
    17. this.year = year;
    18. this.month = month;
    19. this.day = day;
    20. }
    21. }

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

               不能形成环像下面代码这样！！！

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

    5.3 默认初始化

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

    1. public class Date {
    2. public int year;
    3. public int month;
    4. public int day;
    5. public Date(int year, int month, int day) {
    6. // 成员变量在定义时，并没有给初始值, 为什么就可以使用呢？
    7. System.out.println(this.year);
    8. System.out.println(this.month);
    9. System.out.println(this.day);
    10. }
    11. public static void main(String[] args) {
    12. // 此处a没有初始化，编译时报错：
    13. // Error:(24, 28) java: 可能尚未初始化变量a
    14. // int a;
    15. // System.out.println(a);
    16. Date d = new Date(2021,6,9);
    17. }
    18. }

    要搞清楚这个过程，就需要知道 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 就地初始化

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

    1.     public class Date {
    2.         public int year = 1900;
    3.         public int month = 1;
    4.         public int day = 1;
    5.         public Date(){
    6.         }
    7.     public Date(int year, int month, int day) {
    8.  
    9.     }
    10.     public void print(){
    11.         System.out.println(year+"/"+month+"/"+day);
    12.     }
    13.     public static void main(String[] args) {
    14.         //Date d1 = new Date(2021,6,9);
    15.         Date d2 = new Date();
    16.        // d1.print();
    17.         d2.print();
    18.     }
    19. }

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

    6. 封装

    6.1 封装的概念

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

    比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器， USB 插孔等，让用户来和计算机进行交互，完成日常事务。但实际上：电脑真正工作的却是CPU 、显卡、内存等一些硬件元件。

    对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。
    封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互

    6.2 访问限定符

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

    范围

    private

    default

    protected

    public

    同一包中的同一类

    √

    √

    √

    √

    同一包中的不同类

    √

    √

    √

    不同包中的子类

    √

    √

    不同包中的非子类

    √

    比如：
    public ：可以理解为一个人的外貌特征，谁都可以看得到
    default: 对于自己家族中 ( 同一个包中 ) 不是什么秘密，对于其他人来说就是隐私了
    private ：只有自己知道，其他人都不知道

    【 说明 】

    protected 主要是用在继承中，继承部分详细介绍

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

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

    1. public class Computer {
    2.     private String cpu; // cpu
    3.     private String memory; // 内存
    4.     public String screen; // 屏幕
    5.     String brand; // 品牌---->default属性
    6.     public Computer(String brand, String cpu, String memory, String screen) {
    7.         this.brand = brand;
    8.         this.cpu = cpu;
    9.         this.memory = memory;
    10.         this.screen = screen;
    11.     }
    12.     public void Boot(){
    13.         System.out.println("开机~~~");
    14.     }
    15.     public void PowerOff(){
    16.         System.out.println("关机~~~");
    17.     }
    18.     public void SurfInternet(){
    19.         System.out.println("上网~~~");
    20.     }
    21.  
    22.  
    23. //public class TestComputer {
    24.     public static void main(String[] args) {
    25.         Computer p = new Computer("HW", "i7", "8G", "13*14");
    26.         System.out.println(p.brand); // default属性：只能被本包中类访问
    27.         System.out.println(p.screen); // public属性： 可以任何其他类访问
    28. // System.out.println(p.cpu); // private属性：只能在Computer类中访问，不能被其他类访问
    29.     }
    30. }

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

    6.3 封装扩展之包  

    6.3.1 包的概念

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

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

    6.3.2 导入包中的类

    Java 中已经提供了很多现成的类供我们使用. 例如Date类：可以使用 java.util.Date 导入 java.util 这个包中的 Date类.

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

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

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

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

    1. import java.util.*;
    2. public class Test {
    3. public static void main(String[] args) {
    4. Date date = new Date();
    5. // 得到一个毫秒级别的时间戳
    6. System.out.println(date.getTime());
    7. }
    8. }

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

    1. import java.util.*;
    2. import java.sql.*;
    3. public class Test {
    4. public static void main(String[] args) {
    5. // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
    6. Date date = new Date();
    7. System.out.println(date.getTime());
    8. }
    9. }
    10. // 编译出错
    11. Error:(5, 9) java: 对Date的引用不明确
    12. java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

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

    1. import java.util.*;
    2. import java.sql.*;
    3. public class Test {
    4. public static void main(String[] args) {
    5. java.util.Date date = new java.util.Date();
    6. System.out.println(date.getTime());
    7. }
    8. }
    可以使用 import static 导入包中静态的方法和字段。

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

    注意事项:

    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 语句 , 则该类被放到一个默认包中 .

    6.3.4 常见的包

    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 static修饰成员变量

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

    【静态成员变量特性】

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

    2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
    3. 类变量存储在方法区当中
    4. 生命周期伴随类的一生 ( 即：随类的加载而创建，随类的卸载而销毁 )

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

    运行上述代码，然后在监视窗口中可以看到，静态成员变量并没有存储到某个具体的对象中。
     

    7.2 static修饰成员方法

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

    1. public class Student{
    2. private String name;
    3. private String gender;
    4. private int age;
    5. private double score;
    6. private static String classRoom = "Seven306";
    7. // ...
    8. }
    9. public class TestStudent {
    10. public static void main(String[] args) {
    11. System.out.println(Student.classRoom);
    12. }
    13. }
    14. 编译失败：
    15. Error:(10, 35) java: classRoom 在 extend01.Student 中是 private 访问控制

    那 static 属性应该如何访问呢？
    Java 中， 被 static 修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的 。静态成员一般是通过静态方法来访问的。

    1. public class Student{
    2. // ...
    3. private static String classRoom = "Seven306";
    4. // ...
    5. public static String getClassRoom(){
    6. return classRoom;
    7. }
    8. }
    9. public class TestStudent {
    10. public static void main(String[] args) {
    11. System.out.println(Student.getClassRoom());
    12. }
    13. }

    【静态方法特性】  

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

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

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

    1. public static String getClassRoom(){
    2. System.out.println(this);
    3. return classRoom;
    4. }
    5. // 编译失败：Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
    6. public static String getClassRoom(){
    7. age += 1;
    8. return classRoom;
    9. }
    10. // 编译失败：Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age

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

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

    7.3 static成员变量初始化

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

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

    1. 就地初始     就地初始化指的是：在定义时直接给出初始值

    1. public class Student{
    2. private String name;
    3. private String gender;
    4. private int age;
    5. private double score;
    6. private static String classRoom = "Bit306"; 
    7. // ...
    8. }

    8. 代码块

    8.1 代码块概念以及分类

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

    普通代码块

    构造块

    静态块

    同步代码块

    8.2 普通代码块

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

    1. public class Main{
    2. public static void main(String[] args) {
    3. { //直接使用{}定义，普通方法块
    4. int x = 10 ;
    5. System.out.println("x1 = " +x);
    6. }
    7. int x = 100 ;
    8. System.out.println("x2 = " +x);
    9. }
    10. }
    11. // 执行结果
    12. x1 = 10
    13. x2 = 100

    8.3 构造代码块

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

    1. public class Student{
    2. //实例成员变量
    3. private String name;
    4. private String sex;
    5. private int age;
    6. private double score;
    7. public Student()
    8. {
    9. System.out.println("I am Student init()!");
    10. }
    11. //实例代码块
    12. {
    13. this.name = "Jack";
    14. this.age = 12;
    15. this.sex = "man";
    16. System.out.println("I am instance init()!");
    17. }
    18. public void show(){
    19. System.out.println("name: "+name+" age: "+age+" sex: "+ sex);
    20. }
    21.  
    22.  
    23. public static void main(String[] args) {
    24. Student stu = new Student();
    25. stu.show();
    26. }
    27. }

    8.4 静态代码块  

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

    1. public class Student{
    2. private String name;
    3. private String gender;
    4. private int age;
    5. private double score;
    6. private static String classRoom;
    7. //实例代码块
    8. {
    9. this.name = "bit";
    10. this.age = 12;
    11.     this.gender = "man";
    12.     System.out.println("I am instance init()!");
    13. }
    14.     // 静态代码块
    15.     static {
    16.         classRoom = "bit306";
    17.         System.out.println("I am static init()!");
    18.     }
    19.     public Student(){
    20.         System.out.println("I am Student init()!");
    21.     }
    22.     public static void main(String[] args) {
    23.         Student s1 = new Student();
    24.         Student s2 = new Student();
    25.     }
    26. }

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

  • 相关阅读:
    Android 逆向之安全防护基本策略
    8.5 数据结构——归并排序和基数排序
    一图讲清楚公众号扫码关注绑定手机号自动登录
    iOS16新特性 | 灵动岛适配开发与到家业务场景结合的探索实践
    CNN卷积层：ReLU函数
    pychon/PIL/opencv学习过程中遇到的问题
    C++双整数转双字节16进制
    github使用手册
    centos7部署Nginx和RabbitMQ
    verdi -play选项加载settings，执行一些自定义的初始化Verdi命令
  • 原文地址：https://blog.csdn.net/Brenda_Bestow/article/details/134254831