【Java】类和对象

博主： Fivk
发布时间：2021 年 10 月 01 日
2196 次浏览
6773字数
分类： Java

### 类的定义

定义一个类，用来模拟“学生”事务。其中就有两个组成部分：

属性（是什么）：

> 姓名
>
> 年龄

行为（能做什么）：

> 吃饭
>
> 睡觉
>
> 学习

**对应Java当中：**

成员变量（属性）：

> String name;    // 姓名
>
> int age;            // 年龄

成员方法（行为）：

> public void eat() {}	// 吃饭
>
> public void sleep {} // 睡觉
>
> public void stydy {} // 学习

注意事项：

1. 成员变量是直接定义再类当中，再方法外边。
2. 成员方法不要写static关键字。

</div>

```java
public class Student {
    // 成员变量
    String name;    // 姓名
    int age;        // 年龄

// 成员方法
    public void eat() {
        System.out.println("吃饭饭！！");
    }

public void sleep() {
        System.out.println("睡觉觉！！");
    }

public void study() {
        System.out.println("学习！！！");
    }

}
```

### 类的使用

通常情况下，类并不能直接使用，需要根据类创建一个对象才能使用。

**1. 导包**

导包：就也是指出需要使用的类，再什么位置。

```java
import 包名称.类名称;
import cn.com.wkcto.Student;
```

对于和当前属于同一个包的情况，可以省略导包语句不写。

**2. 创建**

```java
类名称 对象名 = new 类名称();
Student stu = new Student();
```

**3. 使用**

使用分为两种情况：

* 使用成员变量：对象名.成员变量名
* 使用成员方法：对象名.成员方法名（）

注意事项：

如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

> 整数默认初始化为0
>
> 小数默认初始化为0.0
>
> 字符是\u000
>
> Boolean为false
>
> 引用值为null

</div>

### 案例

```java
package com.wkcto;
//import cn.com.wkcto.Student;

public class Demo01Student {
    public static void main(String[] args) {
        // 1.导包
        // 我需要使用的Student类，和我自己Demo01Student位于同一个包下，所以省略语句不写

// 2.创建
        // 类名称 对象名 = new 类名称()；
        // 根据Student类创建了一个名为stu的对象
        Student stu = new Student();

// 3. 使用其中的成员变量
        // 对象名.成员变量名
        stu.age = 19;
        stu.name = "Fivk";
        System.out.println(stu.name);
        System.out.println(stu.age);

// 4. 使用成员变量的成员方法
        // 对象名.方法名()
        stu.eat();
        stu.sleep();
        stu.study();
    }
}

```

![运行结果](https://blog.fivk.cn/usr/uploads/2021/10/1147934759.png)

### 使用类作为方法的返回值

依旧采用了Phone类

```java
package com.wkcto.demo02;

public class Demo05PhoneReturn {
    public static void main(String[] args) {
        Phone two = getPhone();
        putPhone(two);
    }
    public static Phone getPhone() {
        Phone one = new Phone();
        one.brand = "小米 10";
        one.price = 3999.00;
        one.color = "海洋蓝";
        return one;
    }
    public static void putPhone(Phone param) {
        System.out.println("品牌: " + param.brand);
        System.out.println("价格: " + param.price);
        System.out.println("颜色: " + param.color);
    }
}
```

有CPP基础毫无压力呀是吧哈哈哈哈哈。

### 成员变量和局部变量的区别

* 定义的位置不一样

局部变量：在方法内部定义

成员变量：在方法外部定义（直接写在类当中）

</div>

- 作用范围不一样

局部变量：只有被定义的方法当中才能使用

成员变量：在整个类当中都能使用（不能在其他类使用）

</div>

- 默认值不一样

局部变量：没有默认值，想要使用必须先赋值

成员变量：会有默认值，规则和数组一样。

</div>

- 内存的位置不一样

局部变量：位于栈内存

成员变量：位于堆内存

</div>

- 生命周期不一样

局部变量：随着方法进栈而诞生，随着方法出栈而消失。

成员变量：随着对象创建而诞生，随着对象释放而回收。

</div>

```java
package com.wkcto.demo03;

public class Demo01ValiableDifferennce {
    String name;    // 成员变量

public static void main(String[] args) {
        int num = 20;    // 局部变量
        int num1;
        System.out.println(num);
        System.out.println(num1);   // Error
    }

public void method01(int param) {
        System.out.println(name);
        System.out.println(num);  // Error
        System.out.println(param);  // 参数就是局部变量
        // 参数在方法调用时，必然会被赋值
    }
}
```

### 面向对象的三大特性之封装性

**面向对象三大特征：** 封装、继承、多态。

封装是什么？
</div>

封装就是将一些细节信息隐藏起来，对外界不可见。

</div>

**封装性在java当中的体现：**

1. 方法就是一种封装
2. 关键字private也是一种封装

### private 关键字的作用

```java
package com.wkcto.demo03;

public class Person {
    String name;    // 姓名
    int age;        // 年龄
    public void show() {
        System.out.println("我叫" + name);
        System.out.println("今年" + age + "岁");
    }
}
```

```java
package com.wkcto.demo03;

public class Demo03Person {
    public static void main(String[] args) {
        Person  person = new Person();
        person.name = "Fivk";
        person.age = -18;
        person.show();
    }
}
```

![输出-18](https://blog.fivk.cn/usr/uploads/2021/10/1868615004.png)

输出显然不合理。

问题描述：定义Person的年龄时，无法阻止不合理的数值被设置。

</div>

解决方案：用private关键字将需要保护的成员变量进行修饰。

</div>

一旦使用private进行修饰，那么本类当中仍然可以随意访问。但是，超出了本类范围之外就不能再直接访问了。（只能间接访问）

</div>

设置方法：新增一个类，set+被privet修饰的变量名（第一个要大写），用来修改数据；或者定义一个get+被privet修饰的变量名（第一个要大写），用来获取数据。

**间接访问privte成员变量，就是定义一对getter/setter方法**

setTer(auto) 有参数无返回 参数类型和成员变量对应

getTer(void) 无参数有返回 返回类型和成员变量对应

Boolean 不是getTer()，而是isTer()
</div>

```java
package com.wkcto.demo03;

public class Person {
    String name;    // 姓名
    private int age;        // 年龄
    public void show() {
        System.out.println("我叫" + name);
        System.out.println("今年" + age + "岁");
    }

// 这个成员方法专门用来向age设置数据
    public void setAge(int num) {
        if (num < 100 && num >= 0) {
            age = num;
        } else {
            System.out.println("数据不合理");
        }
    }

// 这个成员方法专门用来获取age的数据
    public int getAge() {
        return age;
    }
}
```

```java
package com.wkcto.demo03;

public class Demo03Person {
    public static void main(String[] args) {
        Person  person = new Person();
        person.name = "Fivk";
        // person.age = -18;  [Error]
        person.setAge(-18); // 不合理
        person.setAge(18);
        person.show();
    }
}
```

### this 关键字的作用

```java
package demo01;

public class Person {
    String name;    // 自己名字

// who是对方的名字,name是自己的名字
    public void sayHello(String who) {
        System.out.println(who + "你好。我是" + name);
    }
}
```

```java
package demo01;

public class Demo01Person {
    public static void main(String[] args) {
        Person person = new Person();
        // 设置自己的名字
        person.name = "马云";
        person.sayHello("马化腾");
    }
}
```

这两行代码运行结果

![](https://blog.fivk.cn/usr/uploads/2021/10/1175314302.png)

当方法局部变量和类的成员变量重名时候，根据“就近原则”，优先使用局部变量。

如果需要访问本类当中的变量，需要使用格式：

this.成员变量名

</div>

```java
public class Person {
    String name;    // 自己名字

// who是对方的名字,name是自己的名字
    public void sayHello(String name) {
        System.out.println(name + "你好。我是" + this.name);
    }
}
```

“通过谁调用的方法，谁就是this。”

// 我们这个代码里面 this 和 person 地址一样

</div>

最后修改：2021 年 10 月 04 日

如果觉得我的文章对你有用，请随意赞赏

【Java】类和对象

Fivk • 2021 年 10 月 01 日

### 类的定义

定义一个类，用来模拟“学生”事务。其中就有两个组成部分：

属性（是什么）：

> 姓名
>
> 年龄

行为（能做什么）：

> 吃饭
>
> 睡觉
>
> 学习

**对应Java当中：**

成员变量（属性）：

> String name;    // 姓名
>
> int age;            // 年龄

成员方法（行为）：

> public void eat() {}	// 吃饭
>
> public void sleep {} // 睡觉
>
> public void stydy {} // 学习

注意事项：

1. 成员变量是直接定义再类当中，再方法外边。
2. 成员方法不要写static关键字。

</div>

```java
public class Student {
    // 成员变量
    String name;    // 姓名
    int age;        // 年龄

// 成员方法
    public void eat() {
        System.out.println("吃饭饭！！");
    }

public void sleep() {
        System.out.println("睡觉觉！！");
    }

public void study() {
        System.out.println("学习！！！");
    }

}
```

### 类的使用

通常情况下，类并不能直接使用，需要根据类创建一个对象才能使用。

**1. 导包**

导包：就也是指出需要使用的类，再什么位置。

```java
import 包名称.类名称;
import cn.com.wkcto.Student;
```

对于和当前属于同一个包的情况，可以省略导包语句不写。

**2. 创建**

```java
类名称 对象名 = new 类名称();
Student stu = new Student();
```

**3. 使用**

使用分为两种情况：

* 使用成员变量：对象名.成员变量名
* 使用成员方法：对象名.成员方法名（）

注意事项：

如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

> 整数默认初始化为0
>
> 小数默认初始化为0.0
>
> 字符是\u000
>
> Boolean为false
>
> 引用值为null

</div>

### 案例

```java
package com.wkcto;
//import cn.com.wkcto.Student;

// 2.创建
        // 类名称 对象名 = new 类名称()；
        // 根据Student类创建了一个名为stu的对象
        Student stu = new Student();

// 3. 使用其中的成员变量
        // 对象名.成员变量名
        stu.age = 19;
        stu.name = "Fivk";
        System.out.println(stu.name);
        System.out.println(stu.age);

// 4. 使用成员变量的成员方法
        // 对象名.方法名()
        stu.eat();
        stu.sleep();
        stu.study();
    }
}

```

![运行结果](https://blog.fivk.cn/usr/uploads/2021/10/1147934759.png)

### 使用类作为方法的返回值

依旧采用了Phone类

```java
package com.wkcto.demo02;

有CPP基础毫无压力呀是吧哈哈哈哈哈。

### 成员变量和局部变量的区别

* 定义的位置不一样

局部变量：在方法内部定义

成员变量：在方法外部定义（直接写在类当中）

</div>

- 作用范围不一样

局部变量：只有被定义的方法当中才能使用

成员变量：在整个类当中都能使用（不能在其他类使用）

</div>

- 默认值不一样

局部变量：没有默认值，想要使用必须先赋值

成员变量：会有默认值，规则和数组一样。

</div>

- 内存的位置不一样

局部变量：位于栈内存

成员变量：位于堆内存

</div>

- 生命周期不一样

局部变量：随着方法进栈而诞生，随着方法出栈而消失。

成员变量：随着对象创建而诞生，随着对象释放而回收。

</div>

```java
package com.wkcto.demo03;

public class Demo01ValiableDifferennce {
    String name;    // 成员变量

public static void main(String[] args) {
        int num = 20;    // 局部变量
        int num1;
        System.out.println(num);
        System.out.println(num1);   // Error
    }

### 面向对象的三大特性之封装性

**面向对象三大特征：** 封装、继承、多态。

封装是什么？
</div>

封装就是将一些细节信息隐藏起来，对外界不可见。

</div>

**封装性在java当中的体现：**

1. 方法就是一种封装
2. 关键字private也是一种封装

### private 关键字的作用

```java
package com.wkcto.demo03;

![输出-18](https://blog.fivk.cn/usr/uploads/2021/10/1868615004.png)

输出显然不合理。

问题描述：定义Person的年龄时，无法阻止不合理的数值被设置。

</div>

解决方案：用private关键字将需要保护的成员变量进行修饰。

</div>

一旦使用private进行修饰，那么本类当中仍然可以随意访问。但是，超出了本类范围之外就不能再直接访问了。（只能间接访问）

</div>

**间接访问privte成员变量，就是定义一对getter/setter方法**

setTer(auto) 有参数无返回 参数类型和成员变量对应

getTer(void) 无参数有返回 返回类型和成员变量对应

Boolean 不是getTer()，而是isTer()
</div>

```java
package com.wkcto.demo03;

// 这个成员方法专门用来获取age的数据
    public int getAge() {
        return age;
    }
}
```

```java
package com.wkcto.demo03;

### this 关键字的作用

```java
package demo01;

public class Person {
    String name;    // 自己名字

// who是对方的名字,name是自己的名字
    public void sayHello(String who) {
        System.out.println(who + "你好。我是" + name);
    }
}
```

```java
package demo01;

这两行代码运行结果

![](https://blog.fivk.cn/usr/uploads/2021/10/1175314302.png)

当方法局部变量和类的成员变量重名时候，根据“就近原则”，优先使用局部变量。

如果需要访问本类当中的变量，需要使用格式：

this.成员变量名

</div>

```java
public class Person {
    String name;    // 自己名字

// who是对方的名字,name是自己的名字
    public void sayHello(String name) {
        System.out.println(name + "你好。我是" + this.name);
    }
}
```

“通过谁调用的方法，谁就是this。”

// 我们这个代码里面 this 和 person 地址一样

</div>

【Java】类和对象

【踩坑日志】SpringBoot项目启动提示This primary key of "id" is primitive !不建议如此请使用包装类 in Class:

【C】极域电子教室学生端解除控制

【开发技巧】@CrossOrigin注解解决跨域问题

这是好东西

【Fivk】文章归档

大一教材

【数据结构】图论算法_图的连通性问题

【C】链表_链表的逆序

【知识总结】动态规划合集

【SpringCloud】Nacos 安装指南

【Java】类和对象