类

一、面向对象

1.1什么是面向对象

咱们先来看看面向对象的定义：

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

1.2面向对象和过程区别

我们拿洗衣服这个例子来说。
传统的洗衣服需要经过这几个步骤：

我们注重的是洗衣服的过程，少一个环节可能都会有影响。每一关都需要我们严格把控。总之，怪麻烦的是吧。对，没错的。
但是！现代的洗衣服方法是怎样的呢

清晰明了，一目了然。
这里面总共有四个对象：人，衣服，洗衣机，洗衣粉。
而过程是怎么样的呢，我们将衣服放进洗衣机没导入洗衣粉，启动洗衣机，OK，完成了。整个过程主要是人，衣服，洗衣机，洗衣粉四个对象之间交互完成的，人不需要关心洗衣机具如何洗衣服，甩干啥的。
总结：

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

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

二、类的定义和使用

好，既然Java是一门面向对象的语言，那么我们怎么才能够拿到一个对象？要想拿到一个对象，必须要有类。接下来咱们说说发关于类的定义以及使用。

2.1认识类

类的定义：

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

比如说我们定义一个人的类。一个人的属性有啥，一个鼻子，两个耳朵…等等。同时，一个人还有行为：吃饭，睡觉，唱，跳，rap，打篮球，music对吧。代码来表示可以这样：

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

这一段代码里面class是定义类的关键字，ClassName为类的名字，{}中为类的主体。类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法。
例1：定义一个洗衣机类：

class WashMachine{
public String brand; // 品牌
public String type; // 型号
public double weight; // 重量
public double length; // 长
public double width; // 宽
public double height; // 高
public String color; // 颜色
public void washClothes(){ // 洗衣服
System.out.println("洗衣功能");
}
public void dryClothes(){ // 脱水
System.out.println("脱水功能");
}
public void setTime(){ // 定时
System.out.println("定时功能");
}
}

再比如说定义一个狗的类：

class PetDog {
public String name;//名字
public String color;//颜色
// 狗的属性
public void barks() {
System.out.println(name + ": 旺旺旺~~~");
}
// 狗的行为
public void wag() {
System.out.println(name + ": 摇尾巴~~~");
}
}

这样类的定义我们就讲完辣。是不通俗易懂

2.2类的实例化

什么是类的实例化？我们先看定义：

定义了一个类，就相当于在计算机中定义了一种新的类型，与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();
}
}

2.3注意事项（重要）

（1）当一个引用赋值为null的时候，代表这这个引用不指向任何对象。
也就是说当我们Date d = null 时。这个d就不会指向任何对象了，再d.name啥的就会报错
（2）引用不能指向引用

public static void main(String[] args) {
person person1 = new person();
person person2 = new person();
person1 = person2;
}

也就是说像这样这种写法时完全错误的

我们可以看到person1和person分别在栈上面，他们所指向的name和age在堆上。两个分别指向不同的对象。
（3）一个引用只能指向一个对象。
你写的相同的new的越多，最后只会运行一个。再说了，你还想当海王？肯定一个人只能有一个对象啊。

三、this引用

在这里我们将引用一个新的定义叫做this。那么好了啥情况我们可以用this呢。
（1）形参名不小心和成员变量名相同，像这种：

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

这种情况编译器一定会懵的，啊，这到底是谁和谁。函数体中到底是谁给谁赋值？成员变量给成员变量？参数给参数？参数给成员变量？成员变量参数？最后有可能估计自己都搞不清楚了。
（2）当多个对象都在调用函数时。但是这些函数没有任何有关对象的说明，这些函数自然不知道如何打印哪个对象的数据。
这些，我们就需要int来排上用场了。

3.1this引用的定义

什么是this引用？

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

OK,知道了定义，请康下面代码：

public class Date {
public int year;
public int month;
public int day;
public void setDay(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
public void printDate(){
System.out.println(this.year + "/" + this.month + "/" + this.day);
}
}

看到没有，Look用了this是不是就完美地解决了分不清谁是谁这个问题了。非常的神奇有没有，哈哈。

3.2this引用特性

（1）this的类型，有对应类类型引用，即哪个对象调用就是哪个对象引用类型。
（2）this只能在“成员方法”中使用
（3）在“成员方法”中，this只能引用当前对象，不能在引用其他对象。
（4）this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收。
最最重要的两点：

（1）必须放在第一行。
（2）只能在构造方法内部才能使用。

四、对象构造及初始化

一般而言。在java内部定义一个局部变量时，必须初始化，而成员变量则并不需要。

4.1构造方法

你看，咱们有引入了一个新的概念，叫构造方法。首先按照惯例i，先说说它的定义

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

OK我们直接上代码，对照代码我们在一一讲解

public class Date {
    public int year;
    public int month;
    public int day;

    public Date() {
        this(2025,9,24);
    }

    public Date(int month) {
        this.month = month;
    }

    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        //this.day = day;
    }
    public void printDate() {
        System.out.println(year + " " + month + " " + day);
    }

    public static void main(String[] args) {
        Date d = new Date(2022,11, 11);
        d.printDate();
        Date d2 = new Date();
        d2.printDate();
    }
}

不知道大家记不记得，我们在刚开始实例化一个对象的时候，我们没有给任何参数，其实编译器已经默认给我们添加了一个不带参数的构造方法。这段代码中publicx Date()括号里面，我们并没有给任何参数。那假如说我们在这个构造方法里给了呢，就像上面我们给了year,month,day这三个参数，所以我们下面实例化对象的时候，也要给三个参数。
好家伙，问题又来了，如果我们这个时候再实例化一个对象，不给任何参数，并且将上面无参数的构造方法去掉，再运行，还会有结果吗？答案是否定的，以为前面编译器默认会给的是在你没有任何构造方法的情况下，现在你已经有了一个构造方法。编译器就不会再给你了。

在这里！！！！注意！！！！
还有一个更为强大的方法，这就是IDEA的强大的地方，我们来看：

看看，看看，多强大啊，咱们不用IDEA用啥啊？直接点几下，构造方法自己就生成好了

4.2默认初始化

为什么局部变量在使用时必须要初始化，而成员变量可以不用呢？要搞清楚这个过程，就需要知道 new 关键字背后所发生的一些事情：
在程序层面只是简单的一条语句，在JVM层面需要做好多事情：

1. 检测对象对应的类是否加载了，如果没有加载则加载
2. 为对象分配内存空间
3. 处理并发安全问题
   比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突。🎉

五、封装

啊，封装这个东西说实话有点意思。何为封装呢？简单来说就是套壳屏蔽细节。
就像我们一个手机，手机壳掀起来，里面有很多东西主板啥的，这些东西我们一般看不到。看个图意思意思得了：

那如果我们想要隐藏某些细节，我们应该用什么方法呢？这就是限定符该做的。JAVA提供了四种限定符：

| no | 范围 | private | default | protected | public
| 1 | 同一包中同一类 | √ | √ | √ | √
| 2 | 同一包中不同类 | | √ | √ | √
| 3 | 不同包中子类 | | | √ | √
| 4 | 不同包中非子类| | | | √
public：可以理解为一个人的外貌特征，谁都可以看得到
default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了
private：只有自己知道，其他人都不知道
【说明】
protected：主要是用在继承中，继承部分详细介绍
default权限指：什么都不写时的默认权限
访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

class Person {
    private String name;
    private int age;
    public Person() {

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return this.name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void show() {
        System.out.println(name+" "+age);
    }
}
public class Test {
    Person person = new Person("zhangsan", 29);

}

呐_呐就这样哈哈

嘿嘿画了个草图是不是有点明了。

六、总结

路漫漫其修远兮，吾将上下而求索。刚开始接触这些类和对象的概念还是非常容易混的，没关系这是正常现象，从面向过程到面向对象是有一个过程的。我们多看几遍，多敲几遍代码，保持空杯心态，一定能学好哒！加油诸位。

我慢慢地写，你们慢慢地读