0
0

什么是类和对象？this引用是什么？Java如何初始化对象？

**一.**什么是面向对象

  1.     类和对象是属于面向对象编程中的概念，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。

要搞清楚面向对象，我们还是得拿面向过程来进行比较，就拿洗衣服这个事件进行举例

面向过程：

如果是面向过程，那我们的设计思路就是一步一步来，一个一个功能来，其中少了一个环节都不可以，其中每一个环节，我们都需要关注其中的细节，而且这样的设计是不可逆的，对于不同的衣服，我们需要的时间，拧干的力度，都是不同的，如果将来我们要设计“洗鞋子”的话，这个程序就完全不再适用了

面向对象：

但如果是面向对象的思路的话，我们并不关心其中每一步的过程如何，我们只需要划分出来几个对象，让几个对象各司其职，相互之间也不关心彼此的内部细节

我们将整个洗衣服的过程，划分出4个对象：“人”，“衣服”，“洗衣机”，“洗衣粉”，整个过程由4个对象相互交互完成，人也不需要关心洗衣机是怎么转的，衣服是怎么被洗干净的，我们只需要知道我们把衣服和洗衣服交给洗衣机，我们就可以得到洗干净的衣服了

二.类与对象

类的概念

在了解了面向对象的思维和概念后，我们就可以打开类和对象的大门了，面相对象程序设计关注的是对象，而对象是现实生活中的实体，比如：洗衣机。但是洗衣机计算机并不认识，需要开发人员告诉给计算机什么是洗衣机。

在上图左侧，我们可以看见一系列的参数，这些参数是在简单的描述这个洗衣机，该过程称为对洗衣机对象(实体)进行抽象(对一个复杂事物的重新认知)，而这个过程对应在我们的面向对象编程中就是类的概念，类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了。也就是说，类就是我们对于现实世界中的事物或者概念的抽象，而对于这种抽象的概念，我们可以使用面向对象的编程语言描述出来

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

  • **属性：产品品牌，型号，产品重量，外观尺寸，颜色... **
  • **功能：洗衣，烘干、定时.... **

类的定义格式

在java中定义类时需要用到
class
关键字，其中：

  • class为定义类的关键字
  • ClassName为类的名字
  • { } 中为类的主体，类中包含的内容称为类的成员
  • 属性主要是用来描述类的，称之为类的成员属性或者类成员变量
  • 方法主要说明类具有哪些功能，称为类的成员方法

具体语法如下：

// 创建类

class ClassName { 

  1.        field;         // 字段(属性) 或者 成员变量  
  5.        method;   // 行为 或者 成员方法

}

比如对于我们刚才说到的洗衣机，我们可以做出如下定义：

  1. class WashMachine {
  2.     public String brand; // 品牌
  3.     public String type; // 型号
  4.     public double weight; // 重量
  5.     public double length; // 长
  6.     public double width; // 宽
  7.     public double height; // 高
  8.     public String color; // 颜色
  9.     public void washClothes(){ // 洗衣服
  10.         System.out.println("洗衣功能");
  11.     }
  12.     public void dryClothes(){ // 脱水
  13.         System.out.println("脱水功能");
  14.     }
  15.     public void setTime(){ // 定时
  16.         System.out.println("定时功能");
  17.     }
  18. }

对象的概念

对象是类的实例化，定义了一个类，就相当于在计算机中定义了一种新的类型，与** int ， double 类似，只不过 int 和 double 是 java语言自带的内置类型，而类是用户自定义了一个新的类型，比如上述的：WashMachine 类，就是一个类(一种新定义的类型)，有了这些自定义的类型之后，就可以使用这些类来定义实例，我们将类定义出来的实例就叫做对象，而用类类型创建对象的过程，称为类的实例化**，在java中采用 new关键字，配合类名来实例化对象

比如我们这里有个狗的类，叫做Dog，它有俩个成员变量，俩个成员方法

  1. class Dog {
  2.     public String name;//名字
  3.     public String color;//颜色
  4.     
  5.     // 狗的行为
  6.     public void barks() {
  7.         System.out.println(name + ": 旺旺旺~~~");
  8.     }
  9.     public void wag() {
  10.         System.out.println(name + ": 摇尾巴~~~");
  11.     }
  12. }

我们可以使用** new关键字来为狗这个概念实例化一个对象，在下面这段代码中，就代表了我们对狗这个类实例化了一个对象Labrador**(拉布拉多)，而这条Labrador(拉布拉多)的名字叫“豆豆”，是黑色的皮毛，会汪汪叫会摇尾巴

  1.     public static void main(String[] args) {
  2.         Dog Labrador = new Dog();
  3.         Labrador.name = "豆豆";
  4.         Labrador.color = "黑色";
  5.         Labrador.barks();
  6.         Labrador.wag();
  7.     }

一个类允许有多个对象，也就是说，我们这里还可以示例化很多对象，这里就表示我们这个Dog类有俩个对象，分别是Labrador(拉布拉多)和Husky(哈士奇)，他们都有各自的属性和方法

  1.     public static void main(String[] args) {
  2.         Dog Labrador = new Dog();
  3.         Labrador.name = "豆豆";
  4.         Labrador.color = "黑色";
  5.         Labrador.barks();
  6.         Labrador.wag();
  7.         
  8.         Dog Husky = new Dog();
  9.         Labrador.name = "二哈";
  10.         Labrador.color = "黑白相间";
  11.         Labrador.barks();
  12.         Labrador.wag();
  13.     }

注意

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

关于类和对象的说明

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

三.this****引用

为什么要有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.     
  14.     public static void main(String[] args) {
  15.         // 构造三个日期类型的对象 d1 d2 d3
  16.         Date d1 = new Date();
  17.         Date d2 = new Date();
  18.         Date d3 = new Date();
  19.         // 对d1，d2，d3的日期设置
  20.         d1.setDay(2020, 9, 15);
  21.         d2.setDay(2020, 9, 16);
  22.         d3.setDay(2020, 9, 17);
  23.         // 打印日期中的内容
  24.         d1.printDate();
  25.         d2.printDate();
  26.         d3.printDate();
  27.     }
  28. }

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

形参名不小心与成员变量名相同的话会是怎么样呢？

在这种情况下，编译器很难对我们给出的方法进行判断，那方法体中到底是谁给谁赋值？成员变量给成员变量？参数给参数？参数给成员变量？成员变量参数？

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

什么是this引用

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

  1. public class Date {
  2.     public int year;
  3.     public int month;
  4.     public int day;
  5.     
  6.     public void setDay(int year, int month, int day) {
  7.         this.year = year;
  8.         this.month = month;
  9.         this.day = day;
  10.     }
  11.     
  12.     public void printDate() {
  13.         System.out.println(this.year + "/" + this.month + "/" + this.day);
  14.     }
  15. }

this****引用的特性

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

四.对象的构造及初始化

在Java方法内部定义一个局部变量时，必须要初始化，否则会编译失败 

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

构造方法

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

特性

  • 名字必须与类名相同
  • 没有返回值类型，设置为void也不行
  • 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
  • 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)
  • 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的，但一旦用户定义，编译器则不再生成
  • 不能形成环
  1.     public class Date {
  2.         public int year;
  3.         public int month;
  4.         public int day;
  5.         
  6.         // 无参构造方法
  7.         public Date() {
  8.             this.year = 1900;
  9.             this.month = 1;
  10.             this.day = 1;
  11.         }
  12.         
  13.         // 带有三个参数的构造方法
  14.         public Date(int year, int month, int day) {
  15.             this.year = year;
  16.             this.month = month;
  17.             this.day = day;
  18.         }
  19.         
  20.         public void printDate() {
  21.             System.out.println(year + "-" + month + "-" + day);
  22.         }
  23.     }

另外构造方法中，可以通过this调用其他构造方法来简化代码，但需要注意**this(...)必须是构造方法中第一条语句 **

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

不能形成环意思是说，我们不能形成一个死循环，就像下面这样

  1. public Date(){
  2.         this(1900,1,1);
  3.         }
  4. public Date(int year, int month, int day) {
  5.         this();
  6.         }

就地初始化

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

  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.     public static void main(String[] args) {
  10.         Date d1 = new Date(2021,6,9);
  11.         Date d2 = new Date();
  12.     }
  13. }

本次分享就到此为止了，感谢您的支持，如有不同意见，欢迎评论区积极讨论，私信都会看的，您的三连支持就是博主分享的最大动力，我那我们下次再见

标签： 面向对象 java 经验分享
本文转载自: https://blog.csdn.net/m0_69519887/article/details/134227726
版权归原作者 luming.02 所有， 如有侵权，请联系我们删除。
登录后发布评论

“什么是类和对象？this引用是什么？Java如何初始化对象？”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？