Java之类与对象

作者简介： zoro-1，目前大一，正在学习Java，数据结构等
作者主页： zoro-1的主页
欢迎大家点赞 收藏 ⭐ 加关注哦！

初始面向对象

什么是面向对象

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

面向对象和面向过程区别

区别：

1. 面向对象是对象之间进行交互不管过程
2. 面向过程是具体到过程

例子：

• 传统洗衣服，拿盆->放水->放衣服…，很多个过程都需要人来亲历亲为，具体到每个过程，都不能缺少，这就是面向过程
• 现代洗衣服，就不关注洗衣服的过程，具体洗衣机是怎么来洗衣服，如何来甩干的，用户不用去关心，只需要将衣服放进洗衣机，倒入洗衣粉，启动开关即可，通过对象之间的交互来完成的。

注意：

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

类的定义和使用

什么是类

Java中的类是一种抽象的数据类型，它定义了一组属性和方法，以构建具有特定行为和功能的对象。类是Java程序中的基本组件之一，它允许开发人员按照面向对象的编程方法来创建对象、封装数据、隐藏实现细节并提供可重用性。在Java中，每个对象都是通过一个类来创建的。类定义了对象的行为和属性，对象是类的实例，通过调用类中定义的方法和访问类中定义的属性来使用这些行为和属性。

类的定义

Java类的定义需要以下几个步骤：

1. 选择一个类名，通常以大写字母开头；

2. 写出类的定义的语法格式，包括类的修饰符、类名、类的实现接口（如果有）、类体；

3. 在类体中定义类的数据成员（属性）和方法。

下面是一个简单的Java类定义例子：

//类的定义语法格式：修饰符 class 类名 [extends 父类名] [implements 接口名] {类体}
public class Person {
    //属性
    private String name;
    private int age;
    
    //方法
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public int getAge() {
        return age;
    }
}

在这个例子中，我们定义了一个名为Person的类。该类具有两个属性，一个名为name（字符串类型），一个名为age（整数类型）；还有四个方法，分别是setName、getName、setAge和getAge。其中，setName和setAge是用于设置属性值的方法，getName和getAge是用于获取属性值的方法。
注意：
一个java文件中只有一个类能使用public
类名注意采用大驼峰定义

类的实例化

什么是类的实例化

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

public class Main{
 public static void main(String[] args) {
        PetDog dogh = new PetDog();     //通过new实例化对象

        dogh.name = "阿黄";
        dogh.color = "黑黄";
        dogh.barks();
        dogh.wag();
        
        PetDog dogs = new PetDog();
        dogs.name = "阿黄";
        dogs.color = "黑黄";
        dogs.barks();
        dogs.wag();
 }
}
 

输出结果：
阿黄: 旺旺旺~~~

阿黄: 摇尾巴~~~

赛虎: 旺旺旺~~~

赛虎: 摇尾巴~~~

注意事项

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

类和对象使用说明

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

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

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

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

this关键词

为什么使用this关键词

例子：

public void setDay(int year, int month, int day){
    year = year;
    month = month;
    day = day;
}

那函数体中到底是谁给谁赋值？成员变量给成员变量？参数给参数？参数给成员变量？成员变量参数？估计自己都搞不清楚了。
这时候就要用到this关键词了，在非静态方法里其实有一个隐藏的参数

public void setDay(类名 this，int year, int month, int day)

谁调用这个方法this就代表哪个对象，当然这个参数我们不需要传，编译器会自动传
这个函数正确的书写是这样的：

public void setDay(int year, int month, int day){
    this.year = year;
    this.month = month;
    this.day = day;
}

this特性

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

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

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

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

三种使用

1.this.构造方法
2.this.成员变量
3.this.成员方法

对象的构造和初始化

对象初始化

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. 局部变量必须要初始化才能使用，为什么字段声明之后没有给值依然可以使用？

构造方法

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

public class Date {
    public int year;
    public int month;
    public int day;
 
    // 构造方法：

    // 名字与类名相同，没有返回值类型，设置为void也不行

    // 一般情况下使用public修饰

    // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次

    public Date(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
        System.out.println("Date(int,int,int)方法被调用了");
   }
 
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
   }
 
    public static void main(String[] args) {
        // 此处创建了一个Date类型的对象，并没有显式调用构造方法

        Date d = new Date(2021,6,9);   // 输出Date(int,int,int)方法被调用了

        d.printDate();    // 2021-6-9

   }
}

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

构造方法注意事项

1. 名字必须与类名相同

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

3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)

4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)

5. 如果没写构造方法，编译器会自动给一个无参构造方法，如果写了构造方法，那么则没有编译器给的无参构造方法·

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;
   }
}

8. 不能形成环

public Date(){
   this(1900,1,1);
}
 

public Date(int year, int month, int day) {
   this();
}
 

/*

无参构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，形成构造器的递归调用
编译报错：Error:(19, 12) java: 递归构造器调用

*/

默认初始化

成员变量会默认初始化，所以不需要手动初始化也能使用

就地初始化

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

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

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

封装

封装概念

封装是Java面向对象编程中的一种重要概念，它指的是把数据和方法包装在一起，形成一个类，通过访问控制符（private、protected、public）来控制外部程序对数据的访问和方法的调用。

封装提供了一种重要的数据隐藏机制，使得对象之间的相互作用仅通过定义在封装的类中的函数和方法进行。这样可以保护数据不被不恰当的修改、误用或破坏，提高了代码的安全性和可靠性。

在Java中，封装通常包括以下几个方面：

1. 数据的私有化：将类的属性定义为private，防止外部直接访问和修改。

2. 公共的setter和getter方法：提供公共方法用于访问和修改私有属性，这样可以控制属性的访问和修改，保证数据的完整性和安全性。

3. 方法的封装：将类的方法定义为private或protected，限制外部方法的访问，保证类的行为特性不会被侵犯。

总之，封装是Java面向对象编程的核心之一，通过封装可以实现数据安全、代码可靠性和代码的模块化程度，是编写高质量代码的不可或缺的手段之一。

访问限定符

访问限定符是指在面向对象编程中，用来限定对象或类成员的访问权限的关键字。常见的访问限定符包括：

1. public：公有限定符，表示该对象或成员可以被任何其他对象或类访问。

2. private：私有限定符，表示该对象或成员只能在当前类中被访问，其他类无法直接访问。

3. protected：保护限定符，表示该对象或成员可以被当前类及其子类访问，但不能被其他类访问。

访问限定符可以帮助我们控制程序的访问权限，从而保证程序的安全性和正确性。

包的概念

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

导包注意点

使用 import语句导入包.
如果需要使用 java.util 中的其他类, 可以使用 import java.util.*
可以使用import static导入包中静态的方法和字段。
当两个包都有同一个类时，我们需要导入完整的包名

今天的分享到这里就结束了，感谢大家支持，创作不易，希望大家能给博主个三连