Java类和对象基础 - 码农知识堂

Java类和对象基础
1. 什么是面向对象？
  Java是一门纯面向对象的语言（Object Oriented Program，简称OOP），面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情，实体(对象)之间相互协作完成的。Java中一切皆对象
2. 面向过程和面向对象
  以洗衣服为例
  面向过程：盆子—>放衣服—>放水—>放洗衣液---->手搓----->换水—>手搓—>拧干（一步一步来）
  面向对象：人---->衣服–>洗衣液---->洗衣机【不需要关注洗衣机是如何具体洗衣服甩干的】
  以买手机为例
  面向过程：查配置资料–>打开购物平台—>选参数—>选手机—>下单---->填地址---->取快递---->使用（一步一步来）
  面向对象：（假设现在是个老板要买手机）给秘书说要买手机-------->秘书帮你买手机（秘书完成上述面向过程的步骤）-------->使用。【你、秘书、手机】
  以大象放进冰箱为例
  面向过程：把大象怎么处理然后塞进冰箱里
  面向对象：打开冰箱、把大象放进去、关上冰箱
  故面向对象关注的是几个实体（对象）之间相互协作完成的，面向过程的时候更关注的是过程。
  我们更关注的是对象与对象之间如何去协作的，具体的过程不管。
3. 如何在Java中拿到一个对象？
  要拿到对象，必须先有类。
  什么是类？如何定义类？
  类：属性+行为
  eg：人的属性：眼睛、嘴巴、耳朵、头发；人的行为：吃饭、睡觉、打豆豆
4. 类的注意事项：
  ①类名采用大驼峰
  ②目前成员前写法统一为public
  ③类中此处写的方法不带static关键字
  ④一般一个文件中只定义一个类
  ⑤main方法所在的类一般要用public修饰
  ⑥public修饰的类必须要和文件名相同
  ⑦修改pubulic修饰的类的名称通过开发工具修改
5. 定义类的练习
  ①定义人类
```
class People {
    public String name;
    public int age;

    public void eat() {
        System.out.println(name + "吃饭");
    }

    public void swim() {
        System.out.println(age + "岁的" + name + "游泳");
    }
}

public class Test {
    //练习书写Java的类
    public static void main(String[] args) {
        People people = new People();
        people.name = "小王";
        people.age = 22;
        people.eat();
        people.swim();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
```
运行结果：

②定义洗衣机类
```
class WashMachine {
    public String name;
    public String color;
    public int power;

    public void wash(){
        System.out.println(name + "在工作洗衣服");
    }
}
    public static void main(String[] args) {
        WashMachine w = new WashMachine();
        w.name = "haie";
        w.color = "wite";
        w.power = 1000;
        w.wash();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
```
运行结果：
1. 类的实例化
  什么是实例化？
  用类类型创建对象的过程，称为类的实例化，在Java中采用new关键字配合类名来实例化对象。
  【即把类转换成对象的这个过程叫做实例化】，拿到对象的前提是有类。
  定义了一个类，就相当于在计算机中定义了一种新的类型，与int double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义的新的类型。
  由类定义的变量是引用类型变量。
  通过. 点好可以访问成员变量和方法。
2. 注意事项：
  ①new关键字用于创建一个对象的实例。
  ②使用. 来访问对象中的属性和方法。
  ③同一个类可以创建多个实例，实例化出的对象占用实际的物理存储空间。
3. 类和对象的说明
  ①类知识一个模型，用来对一个实体进行描述，限定了类有哪些成员。
  ②类是一种自定义的类型，可以用来定义变量。
  ③一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。
  ④类相当于设计图，类实例化出的对象就像现实中使用建筑设计图建造出房子。只有实例化出的对象才能实际存储数据，占用物理空间。
4. 实例化举例：
```
    public static void main(String[] args) {
        People people = new People();
        people.name = "小王";
        people.age = 22;
        people.eat();
        people.swim();
    }
1
2
3
4
5
6
7
```
通过new关键字从People类中实例化出一个people对象。类等代码都在方法区。

实例化数组对象：
```
    public static void main(String[] args) {
        People[] p = new People[2]; //创建数组
        for (int i = 0; i < p.length; i++) {
            p[i] = new People();  //实例化对象
        }
        p[0].name = "小王";
        p[0].age = 22;
        p[1].name = "小帅";
        p[1].age = 21;
        p[0].eat();
        p[1].eat();
    }
1
2
3
4
5
6
7
8
9
10
11
12
```
运行结果：

注意：
```
       People[] p = new People[2];
       p[i] = new People();
1
2
```
第一条语句是创建数组，下面一条语句是实例化对象。
1. 成员变量和局部变量
  成员变量：在类里面，方法的外面
  局部变量：在方法的里面
  成员变量随着对象的创建而产生，对象的销毁而结束（生命周期）
  局部变量进入方法创建，出方法结束（生命周期）
  成员变量可以不用赋初始值，局部变量在定义的时候必须赋初始值。
2. 引入this——为什么要有this引用
  使用setDate方法给对象赋初始值，并且形参和成员变量不重名
```
class Person {
    public String name;
    public int age;

    public void setDate(String n, int a) {
        name = n;
        age = a;
    }

    public void eat() {
        System.out.println(name + "吃饭");
    }
    public void show() {
        System.out.println("年龄：" + age + " 姓名：" + name);
    }

}


public class Test {
    //this引用
    public static void main(String[] args) {
        Person person = new Person();
        person.setDate("小王",22);
        person.show();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
```
运行结果：

分析：可以正常赋值
加入使用setDate方法给对象赋初始值，并且形参和成员变量重名
则：
```
    public void setDate(String name, int age) {
        name = name;
        age = age;
    }
1
2
3
4
```
运行结果：

分析：没能成功赋值，并且在 public void setDate(String name, int age) { name = name; age = age; }中出现的name和age都是形参局部变量的，因为局部变量优先原则，所以对象的成员变量的值还是创建对象的时候的初始值，int的初始值是0，String的初始值是null。为了避免这种情况的出现——引出this。
this的三种用法：（以下将围绕这3个方面总结）
①this访问成员变量 this.name
②this访问成员方法 this.func
③this访问构造方法 this(…)
1. this：是指向当前对象的引用，在形参和成员变量名相同的情况下，给想要赋值的成员变量加上this
```
    public void setDate(String name, int age) {
        this.name = name;
        this.age = age;
    }
1
2
3
4
```
再次运行程序，程序的运行结果：

分析：赋值成功

每个成员方法的第一个参数默认是this（隐式参数），this是“成员方法”第一个隐藏的参数。

成员变量赋值前加上this指明是给当前对象的name和age赋值，谁调用这个方法，它传过去的时候this就代表谁。
1. this引用指向当前对象，在成员方法中所有成员变量的操作都是通过该引用去访问的，this引用的是调用成员方法的对象，this代表当前对象的引用。
  this的类型与当前对象的类型是一致的，即对应类类型引用，哪个对象调用就是哪个对象的引用类型。
  person引用的地址
  
  this引用的地址（与person相同）
  
  this只能引用当前对象，不能再引用其他对象。
2. 在上述中，每次给对象初始化都要调用setDate方法，比较麻烦，那么能不能在构造对象（实例化对象）的时候就初始化？——可以！构造方法！
  什么是构造方法：构造方法是一个特殊的成员方法，①这个方法没有返回值（没有void）；②方法名和类名一样。③在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次（相当于人的出生，每个人只出生一次）。④构造方法可以方法重载（根据自己的需求提供不同参数的构造方法）。
3. 无参数构造方法
```
class Person {
    public String name;
    public int age;

    public Person() {
        System.out.println("没有参数的构造方法被被调用了");
    }

    public void setDate(Person this,String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println(name + "吃饭");
    }
    public void show() {
        System.out.println("年龄：" + age + " 姓名：" + name);
    }

}


public class Test {
    //this引用
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
```
运行结果：
1. 有参数的构造方法
```
class Person {
    public String name;
    public int age;

    public Person() {
        System.out.println("没有参数的构造方法被被调用了");
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("有参数的构造方法被调用");
    }

    public void setDate(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println(name + "吃饭");
    }
    public void show() {
        System.out.println("年龄：" + age + " 姓名：" + name);
    }

}


public class Test {
    //this引用
    public static void main(String[] args) {
        Person person = new Person("小王",21);
        person.show();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
```
运行结果：
Person person = new Person("小王",21);在实例化对象的时候，就直接给构造方法传参了
1. 当只写了有参构造方法，却调用无参构造方法时
```
//    public Person() {
//        System.out.println("没有参数的构造方法被被调用了");
//    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("有参数的构造方法被调用");
    }

        Person person = new Person();
//        Person person = new Person("小王",21);
1
2
3
4
5
6
7
8
9
10
11
```
在new对象的时候不给他传参数，Person person = new Person();，说明调用的是不带参数的构造方法，但是此时因为用户写了有参构造方法，Java不再提供默认的无参构造方法。
提示报错信息：

总结：
①如果没有写任何的构造方法，此时Java会帮我们提供一个默认的不带参数的构造方法
②如果自己写了构造方法，不管写了什么样的构造方法，Java都不会提供哪个默认的不带参数的构造方法了。
注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间，开辟空间是实例化的时候干的事。
1. 构造方法的特性：
  ①名字与类名相同
  ②没有返回值类型，设置成void也不行
  ③创建对象的时候由编译器自动调用，在对象的生命周期中只调用一次
  ④构造方法可以重载
  ⑤对对象的成员初始化，不负责给对象开辟空间
2. this访问成员方法
```
    public void eat() {
        System.out.println(name + "吃饭");
    }
    public void show() {
        this.eat();
        System.out.println("年龄：" + age + " 姓名：" + name);
    }
1
2
3
4
5
6
7
```
运行结果：

分析：可以看到eat方法也被执行了，注意this只能在成员方法中使用，在main/静态方法中不能用this

如图所示，在main方法/静态方法中使用this出现报错提示。
1. this访问构造方法，构造方法中，可以通过this调用其他构造方法来简洁代码
```
    public Person() {
        this("小王",22);
//        System.out.println("没有参数的构造方法被被调用了");
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
//        System.out.println("有参数的构造方法被调用");
    }
    
        Person person = new Person();
1
2
3
4
5
6
7
8
9
10
11
```
运行结果：

this调用当前对象的其他构造犯法，this(…)必须是构造方法中的第一条语句，必须放到第一行（否则会报错），并且只能在构造方法内部才能使用this(…)
1. this(,)不能形成循环：不能有参构造方法通过this调用无参构造方法的同时，无参构造方法又通过this调用有参构造方法。
2. 成员变量会默认初始化，局部变量在使用时必须要初始化，但是成员变量不用。
  当调用完成构造方法，那么对象就生成了。
  主要有以下两个过程：
  ①为对象分配内存：说明在调用构造方法之前，内存已经分配好了，那么当前对象的引用一定是有的，所有此时可以拿到对象的引用，因此在接下来的构造方法中可以用到this
  ②调用合适的构造方法：在调用构造方法之前还有一个初始化，初始化锁分配的空间，即对象空间被申请好之后，对象中包含的成员已经设置好了初始值。调用构造方法是为了给对象中各个成员赋值，使其值更具有意义。
3. 当一个引用赋值为null的时候，代表这个引用不指向任何对象
```
        Person person = null;
        person.show();
1
2
```
则会出现空指针异常报错，因为值为null不指向任何对象，不能调用show成员方法。
1. 引用不能指向引用，引用一定是指向对象的。
```
        Person person1 = new Person();
        Person person2 = new Person();
        person1 = person2;
1
2
3
```
person1 = person2;这个代表person1这个引用指向了person2这个引用指向的对象，而不是person1的引用指向了person2引用，引用不能指向引用，引用一定是指向对象的。
1. 一个引用不能同时指向多个对象。
```
        Person person1 = new Person();
        person1 = new Person();
        person1 = new Person();
        person1 = new Person();
1
2
3
4
```
分析：
第一条语句：person1指向的地址

第二条语句：person1指向的地址

最后一条语句：person1指向的地址

最后person1只是指向了1个对象（最后那条语句），中途创建的对象都被回收了。
相关阅读:
IT之路，从迷茫“愤青”到团队项目经理，他是如何一步步走出来的？
前端开发工具vscode
2023软件设计师上半年真题解析（上午+下午）
低代码开发那些事儿
 五子棋-牛客网
 el-input单独校验
 RabbitMQ用户管理
 【快应用】Win7系统使用华为IDE无法运行和调试项目
 画一个有6个顶点的赋权有向图
 Python - json 美化格式、保存文件
原文地址：https://blog.csdn.net/weixin_44070116/article/details/127719917