• Java —— 类和对象（一）

    目录

    1. 面向对象的初步认知

    1.1 什么是面向对象

    1.2 面向对象与面向过程

    2. 类定义和使用

    2.1 认识类

    2.2 类的定义格式

    3. 类的实例化(如何产生对象)

    3.1 什么是实例化

    3.2 访问对象的成员

    3.3 类和对象的说明

    4. this引用

    4.1 为什么要有this引用

    4.2 什么是this引用

    4.3 this引用的特性

    4.4 练习

    5. 对象的构造及初始化

    5.1 如何初始化对象

    5.1.1 默认初始化

    5.1.2 就地初始化

    5.2 构造方法

    1. 面向对象的初步认知

    1.1 什么是面向对象

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

    1.2 面向对象与面向过程

    1. 传统洗衣服过程

    传统的方式：

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

    而且不同衣服洗的方式，时间长度，拧干方式都不同，处理起来就比较麻烦。如果将来要洗鞋子，那就是另一种方式。

    按照该种方式来写代码，将来扩展或者维护起来会比较麻烦。

    2. 现代洗衣服过程

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

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

    2. 类定义和使用

    那么对象从何而来?

    比如张三这个人, 就是一个对象. 我们就可以用一些口头语言去描述张三的形象特征, 也就是描述张三这个对象. 于是我们也可以通过代码来描述张三这个人.

    2.1 认识类

    1. class Person {
    2.     // 描述 人的属性
    3.     public int age; // 年龄
    4.     public String name; // 姓名
    5.  
    6.     // 描述 人的行为
    7.     public void eat() {
    8.         System.out.println("吃饭~ ");
    9.     }
    10. }

    以上代码简单的素描了一下人的属性, 但注意这个代码并不等于有了一个"真实的张三".

    那么描述一个对象我们就会通过这样的一个"类"去描述.

    类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了。
    比如：洗衣机，它是一个品牌，在Java中可以将其看成是一个类别。
    属性：产品品牌，型号，产品重量，外观尺寸，颜色...
    功能：洗衣，烘干、定时....

    2.2 类的定义格式

    一个类由两部分组成: 属性 + 行为 (也叫 成员属性 + 成员方法)

    在java中定义类时需要用到class关键字: class 类名{} (注: 类名使用大驼峰)

    1. // 创建洗衣机类
    2. class WashMachine {
    3.     // 属性[字段] -> 成员属性
    4.     public String brand;   // 品牌
    5.     public String type;    // 型号
    6.     public double weight;  // 重量
    7.     public double length;  // 长
    8.     public double width;  // 宽
    9.     public double height;  // 高
    10.     public String color;   // 颜色
    11.     // 行为[方法] -> 成员方法
    12.  
    13.     public void washClothes(){   // 洗衣服
    14.         System.out.println("洗衣功能");
    15.     }
    16.  
    17.     public void dryClothes(){    // 脱水
    18.         System.out.println("脱水功能");
    19.     }
    20.  
    21.     public void setTime(){       // 定时
    22.         System.out.println("定时功能");
    23.     }
    24. }
    注意事项:
    1. 类名使用大驼峰命名; 方法名/变量使用小驼峰命名.
    2. 成员前写法 这里 统一为public.
    3. 这里 写的方法不带static关键字.
    定义 狗 这个类. 
    1. class Dog {
    2.     // 成员变量
    3.     public String name;
    4.     public String color;
    5.  
    6.     // 行为
    7.     public void barks() {
    8.         System.out.println(name + "汪汪叫！");
    9.     }
    10.     public void wag() {
    11.         System.out.println(name + "摇尾巴！");
    12.     }
    13. }
    注意事项:
    1. 一个Java文件一般只定义一个类
    2. main方法所在的类一般要使用public修饰
    3. public修饰的类必须要和文件名相同
    4. 不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改

    3. 类的实例化(如何产生对象)

    有了类之后, 应该怎么用? 应该怎么样拥有一个对象?

    3.1 什么是实例化

    我们现在已经有了一个类, 但是它不是一个具体的实体, 比如上文中的Dog类, 它并不是一个具体的狗, 只是一个类似于模板/图纸一样的东西, 那么要想让这个Dog成为"真正的狗", 那怎么办?我们来看. 
    Dog dog = new Dog();

    这句代码我们称作: 实例化一个Dog对象.

    那么只要new一个Dog, 就真正意义上有一只狗了. 这就是由类变成一个真正的实体.

    定义了一个类，就相当于在计算机中定义了一种新的类型.

    就像 int a = 10;, 类型 变量 = 值;, 我们定义的类Dog也叫做类型, 是我们自己定义的一种类型, 类型 变量 = 实例化一个对象;

    与int，double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一个新的类型. 类(一种新定义的类型)有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。

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

    3.2 访问对象的成员

    那么new了对象后, 类中的属性怎么访问?
    通过 .操作符 
    1. dog.name = "来福";
    2. dog.color = "黑色";

    于是:

    1. System.out.println(dog.name);
    2. System.out.println(dog.color);

    当给对象赋值了之后, 就可以通过 引用.方法 来访问方法.

    1. dog.barks();
    2. dog.wag();

    3.3 类和对象的说明

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

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

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

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

    代码示例: 通过一个类可以实例化无数个对象. 
    1. Dog dog2 = new Dog();
    2. dog2.name = "小灰";
    3. dog2.color = "灰色";
    4.  
    5. Dog dog3 = new Dog();
    6. Dog dog4 = new Dog();

    4. this引用

    4.1 为什么要有this引用

    先看一个日期类的例子：

    1. public class TestDate {
    2.     public int year;    // 年
    3.     public int month;   // 月
    4.     public int day;    // 日
    5.  
    6.     public void setDate(int y, int m, int d) {
    7.         year = y;
    8.         month = m;
    9.         day = d;
    10.     }
    11.  
    12.     public void printDate() {
    13.         System.out.println(year + "-" + month + "-" + day);
    14.     }
    15.  
    16.     public static void main1(String[] args) {
    17.         TestDate testDate = new TestDate();
    18.         System.out.println("fda");
    19.     }
    20. }

    此时打断点,可以看到:

    在testDate中yeah, month, day都为0.

    我们现在要给它们赋值, 于是就要通过testDate这个引用单独的去访问成员属性.

    1.     public static void main(String[] args) {
    2.         TestDate testDate = new TestDate();
    3.         testDate.year = 2023;
    4.         testDate.month = 10;
    5.         testDate.day = 26;
    6.         System.out.println("fda");
    7.     }

    此时再运行Debug:

    可以看到, 三个成员属性被赋值了.

    也可以通过printDate()访问三个成员属性:

    如果不是在main中一个一个赋值的, 那么就可以调用setDate()传入参数进行赋值.

    我们进行Debug, 进入setDate():

    可以看到, 现在y, m, d这些形参的值是有的, 然后yeah, month, day这些默认都是0, 往下走会发现会被赋值.

    然后再运行, 打断点的这一行代码就执行完毕了.

    这里要明白, yeah, month, day都是这个testDate对象里面的.

    对于前面的代码, 如果我们把setDate()的形参变一下:

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

    运行之后会看到, 结果变成了都是0, 三个成员属性没有被赋值.

    原因就在于:
    局部变量优先原则.

    也就是说, 在 setDate()中, 它认为yeah, month, day都是局部变量.
    相当于在这里只是形参自己给自己赋值了, 所以它根本没有赋值到成员变量中.
    那么怎么样才能赋值到成员变量中?
    这里就要使用一个东西叫做 this关键字.
    把 this加到 setDate()中就可以了 
    1.     public void setDate(int year, int month, int day) {
    2.         this.year = year;
    3.         this.month = month;
    4.         this.day = day;
    5.     }

    可以看到, 加上this之后, 运行结果就没有什么问题了.

    为什么加上this就可以了, this又代表什么?

    再来看下面这个例子:

    1.     public static void main(String[] args) {
    2.         TestDate testDate1 = new TestDate();
    3.         TestDate testDate2 = new TestDate();
    4.         TestDate testDate3 = new TestDate();
    5.  
    6.         testDate1.setDate(2023, 10, 26);
    7.         testDate2.setDate(2024, 10, 26);
    8.         testDate3.setDate(2025, 10, 26);
    9.  
    10.         testDate1.printDate();
    11.         testDate2.printDate();
    12.         testDate3.printDate();
    13.     }

    执行结果:

    并且问题是在setDate中就算没有加this, 结果也是一样的.

    三个对象都在调用setDate和printDate函数，但是这两个函数中没有任何有关对象的说明，setDate和

    printDate函数如何知道打印的是那个对象的数据呢？

    4.2 什么是this引用

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

    1. public class Date {
    2.     public int year;
    3.     public int month;
    4.     public int day;
    5.     public void setDay(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(this.year + "/" + this.month + "/" + this.day);
    12.     }
    13. }

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

    1. public static void main(String[] args) {
    2.     Date d = new Date();
    3.     d.setDay(2020,9,15);
    4.     d.printDate();
    5. }

    this有三种使用方法:

    • this.成员变量
    • this.访问成员方法
    • this();访问构造方法
    第三个具体后续讲解.

    4.3 this引用的特性

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

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

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

    4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收

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

    4.4 练习

    写一个学生类 有姓名 年龄 等属性, 然后通过一个方法设置这些属性的值。其次通过写2个方法，在其中一个方法当中，使用this调用另一个方法.

    1. public class Student {
    2.     public String name;
    3.     public int age;
    4.  
    5.     public void setStudent(String name, int age) {
    6.         this.name = name;
    7.         this.age = age;
    8.     }
    9.  
    10.     public void print() {
    11.         System.out.println(this.name + " => " + this.age);
    12.     }
    13.  
    14.     public static void main(String[] args) {
    15.         Student student = new Student();
    16.         student.setStudent("Zhangsan", 18);
    17.         student.print();
    18.     }
    19. }

    5. 对象的构造及初始化

    5.1 如何初始化对象

    5.1.1 默认初始化

    通过new可以实例化一个对象, 在对象中有很多的成员, 如果是方法中的一个局部变量, 我们知道没有初始化时一定会报错, 但是如果是对象, 却是能通过编译的. 
    1.     public static void main(String[] args) {
    2.         Student student = new Student();
    3.         // 没有给成员变量赋值, 直接访问成员变量, 不会报错, 因为它是一个引用变量
    4.         System.out.println(student.name); 
    5.     }

    不会报错的原因就在于默认初始化. 也就是没有给成员变量赋值的时候, 它们有自己的默认值, 这就是默认初始化.

    5.1.2 就地初始化

    写类的时候直接给成员变量赋值.

    1. public class Student {
    2.     public String name = "Zhangsan";
    3.     public int age = 18;
    4.     
    5.     // ..
    6. }
    然而这种写法不好, 因为类本身就是一个模板, 对于上例来说不是所有的学生都叫做yy, 年龄都是18.
    就地初始化的使用取决于代码的需求.

    不同数据类型作为成员变量时所对应的默认值如下表:

    数据类型

    默认值

    byte

    0

    char

    '\u0000'

    short

    0

    int

    0

    long

    0L

    boolean

    false

    float

    0.0f

    double

    0.0

    reference

    null

    那么除了setXXX方法还有其他的方式可以用于对象的初始化

    5.2 构造方法

    通过构造方法给对象中的成员进行初始化.

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

    1. // 对于 Student类
    2. Student() {
    3.     System.out.println("不带参数的构造方法");
    4. }
    5.  
    6. // 可以通过构造方法传参并对成员变量赋值
    7. Student(String name,int age) {
    8.     System.out.println("带2个参数的构造方法");
    9.     this.name = name;
    10.     this.age = age;
    11. }
    虽然构造方法写好了, 但是构造方法如何被调用?
    我们运行代码:

    可以看到, 我们写的Student()方法被调用了. 并且可以知道, 这个方法是在Student student = new Student();这一行代码被调用的.

    构造方法的调用是在new后的Student(). 我们通过new实例化对象, 在实例化对象的时候一定会调用构造方法.

    在前面我们没有写两个Student()构造方法的时候, 并没有编译报错, Student student = new Student();也没有提供参数? 为什么说一定会调用构造方法?

    当我们没有主动提供构造方法的时候, 编译器会默认帮我们提供一个不带参数的构造方法.

    所以理论上来说, 我们在Student student = new Student();什么都没写, 实际上会有默认调用Student()的存在. 那么只要我们主动写了, 就会调用我们写的构造方法.

    注: 一般我们写构造方法会在前面都加上public, 具体原因后续说. 
    1. // 对于 Student类
    2. public Student() {
    3.     System.out.println("不带参数的构造方法");
    4. }
    5.  
    6. // 可以通过构造方法传参并对成员变量赋值
    7. public Student(String name,int age) {
    8.     System.out.println("带2个参数的构造方法");
    9.     this.name = name;
    10.     this.age = age;
    11. }

    那么我们也可以调用带两个参数的构造方法, 在main中加上:

    Student student2 = new Student("Sun",18);

    可以看到, 不带参数的和带2个参数的都已经被打印.

    由此可以说明, 在实例化对象的时候才会调用构造方法, 而且在调用构造方法的时候可以传参, 对成员属性进行赋值. 所以要想实例化对象, 就一定要调用构造方法.

    于是我们可以理解为, 当构造方法调用完成之后, 对象才实际意义上的产生了.

    同时我们可以看到, 构造方法是可以被重载的,

    小结: 构造方法的特性:
    1. 名字必须与类名相同
    2. 没有返回值类型，设置为void也不行
    3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
    4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)
    5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。
    注意：一旦用户定义，编译器则不再生成。
    6. 构造方法中，可以通过this调用其他构造方法来简化代码
    注意：
    this(...)必须是构造方法中第一条语句
    不能形成环
    7. 绝大多数情况下使用public来修饰，特殊场景下会被private修饰(后序讲单例模式时会遇到) 
    1. // 关于构造方法中的 this 的使用
    2. public Student() {
    3.     // 调用 本类当中 其他的构造方法
    4.     this("zhangsan", 23);   // 走到这里, 代码会调到Student(name, age)方法执行
    5.     System.out.println("不带参数的构造方法");
    6. }

  • 相关阅读:
    最全Dubbo面试题和答案详解。
    【洛谷】P1828 [USACO3.2] 香甜的黄油 Sweet Butter （最短路）
    Google Earth Engine（GEE）——GHSL：全球人类住区层，建成网格 1975-1990-2000-2015 (P2016) 数据集
    【Java|golang】210. 课程表 II---拓扑排序
    CSS垂直居中的方法
    GIS前端—地图标注
    一文教你在MindSpore中实现A2C算法训练
    Elasticsearch集群
    vue3 图片/视频 加载失败重试
    论文笔记: 度量学习之 ITML (理解ing)
  • 原文地址：https://blog.csdn.net/YeZh1Yong_Cr/article/details/134109862