大数据开发基础入门与项目实战（一）Java SE之3.类和对象

Dear 丶 2022-09-06 04:47 47阅读 0赞

### 文章目录 ###

*  前言
 *  1.面向对象编程
 *   *  （1）对象和面向对象的概念
     *  （2）面向对象编程的概念
     *  （3）类和对象的概念
 *  2.类和对象以及引用
 *   *  （1）类、对象和引用的定义
     *  （2）Person类的定义
     *  （3）Point类的定义
 *  3.成员方法
 *   *  （1）成员方法的概念和定义
     *  （2）类中参数和返回值的多种情况下成员方法的定义和调用
     *   *  Ⅰ 无参无返回值成员方法的定义与调用
         *  Ⅱ 有参无返回值成员方法的使用
         *  Ⅲ 多个形参成员方法的使用
         *  Ⅳ 可变长参数的使用
         *  Ⅴ 无参有返回值方法的使用
     *  （3）方法的传参过程
     *  （4）参数传递的注意事项
 *  总结

# 前言 #

本文主要介绍了Java中的类和对象，主要包括面向对象编程（对象和面向对象的概念、面向对象编程的概念等）、类和对象以及引用（类、对象和引用的定义、举例实现类的定义等）和成员方法（成员方法的概念和定义、类中参数和返回值的多种情况下成员方法的定义和调用等）。

# 1.面向对象编程 #

## （1）对象和面向对象的概念 ##

**万物皆对象** ，即在面向对象编程的概念中，现实生活中的一切事物都可以称为对象，包括人、物等。

面向对象是以**属性** （特征）和**行为** （动作）的观点去分析现实生活中的事物。

## （2）面向对象编程的概念 ##

面向对象编程是指以面向对象的思想进行分析，然后使用面向对象的编程语言进行表达的过程，即分为两个步骤：

1.  使用面向对象的思想分析；
2.  使用面向对象的语言实现。

除了面向对象，还有面向过程：

面向过程是实现任务时分成具体的步骤，关注的是整个过程；

面向对象只关注对象的特征以及是否能完成过程，而不关注具体怎么实现。

其中：

*  C语言是面向过程的语言；
 *  C++既面向对象、又面向过程；
 *  Java是面向对象的语言。

显然，面向对象编程更加高效，是软件产业化发展的需求。

面向对象的思想精髓包括：

*  封装
 *  继承
 *  多态

## （3）类和对象的概念 ##

对象是现实生活中存在的实体，在Java语言中体现为内存空间中的一块**存储单元** ，并存在于**堆区** 。

类就是将具有**相同属性和行为** 的多个对象的**共性** 进行**抽象描述** ，相当于是对对象进行分类，在Java语言中体现为一种**引用数据类型** ，包含了描述属性的**成员变量** 和描述行为的**成员方法** 。

类与对象之间的关系：

*  类是构建对象的模板；
 *  对象的数据结构由定义它的类来决定。

# 2.类和对象以及引用 #

## （1）类、对象和引用的定义 ##

定义类名的格式为：

class 类名 { 
      类体
    }

例如：

class Person { 
      ...
    }

可以看到，其实之前在写Java程序时已经定义了类。

定义成员变量格式如下：

class 类名 { 
      数据类型 成员变量 = 初始值;
    }

例如：

class Person { 
      String name;
    }

类名和成员变量的命名规范如下：

类名需要满足驼峰命名法，即当类名由多个单词组成时，要求每个单词首字母都要大写；

成员变量由多个单词组成时，要求从第二个单词开始，每个单词首字母大写。

创建对象的格式为：

new 类名();

例如：

new Person();

这是通过类来创建对象。

当一个类定义完成后，可以使用new关键字来创建这个类的对象，这个过程称为**类的实例化** ；

创建对象的本质是在内存空间的堆区申请一块存储区域，用于存放对象独有的特征信息；

已经创建但是没有赋值给一个变量的对象称为**匿名对象** ，下次使用可能找不到，此时就需要引用。

使用引用数据类型定义的变量称为引用型变量，简称为“引用”；

引用变量主要用于记录对象在堆区中的内存地址信息，便于下次访问。

声明引用变量的格式为：

类名 引用变量名;
    // 获取成员变量
    引用变量名.成员变量名

例如：

Person p = new Person();
    p.name = "Corley";
    System.out.println(p.name);

## （2）Person类的定义 ##

定义成员变量和局部变量类似，但是存在一定的区别：

定义局部变量时一般需要赋初始值；

定义成员变量时一般不需要赋初始值。

定义Person类如下：

/* Person类的定义 */
    
    public class Person { 
      
      // 1.定义成员变量
      String name; // 描述姓名的成员变量
      int age;   // 描述年龄的成员变量
      
      public static void main(String[] args) { 
        
        // 2.声明Person类型的引用指向Person类型的对象
        Person p = new Person();
        
        // 3.打印对象中的成员变量值
        System.out.println("我是" + p.name + "， 今年" + p.age + "岁了");
        
        System.out.println("--------------------------------------");
        // 4.修改成员变量值
        p.name = "Corley";
        p.age = 18;
        // 5.打印修改后的值
        System.out.println("我是" + p.name + "， 今年" + p.age + "岁了");
      }
    }

输出：

我是null， 今年0岁了
    --------------------------------------
    我是Corley， 今年18岁了

可以看到，在没有对成员变量赋值时，创建对象时也会给成员变量默认值。

默认值规则如下：

<table> 
 <thead> 
  <tr> 
   <th>成员变量类型</th> 
   <th>默认初始值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>数值类型byte、short、int、long、float、double、char</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>boolean型</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td>引用类型</td> 
   <td>null</td> 
  </tr> 
 </tbody> 
</table>

代码文件保存在硬盘中，但是CPU只能从内存中读取数据并计算，在编写完代码后首先编译生成字节码文件，在Java解释器解释字节码时，即执行`java classname` 时才会加载到内存，并且位于内存中的**方法区** ；

运行时，首先会寻找main方法，然后再逐行执行。

## （3）Point类的定义 ##

/* Point类的定义 */
    
    public class Point { 
      
      int x; // 描述横坐标的成员变量
      int y; // 描述纵坐标的成员变量
      
      public static void main(String[] args) { 
        
        // 1.声明Point类型引用指向Point类型变量
        Point po = new Point();
        
        // 2.打印成员变量
        System.out.println("横坐标是" + po.x + "，纵坐标是" + po.y);
        
        System.out.println("------------------------------------");
        // 3.横纵坐标修改为3、5后再打印
        po.x = 3;
        po.y = 5;
        System.out.println("横坐标是" + po.x + "，纵坐标是" + po.y);
      }
    }

输出：

横坐标是0，纵坐标是0
    ------------------------------------
    横坐标是3，纵坐标是5

# 3.成员方法 #

## （1）成员方法的概念和定义 ##

格式如下：

返回值类型 成员方法名(形参列表) { 
      成员方法体;
    }

例如：

class Person { 
      void show() { 
        System.out.println("Showing");
      }
    }

对成员方法的说明：

返回值是方法体内返回方法体外的数据内容；

返回值类型是指返回值的数据类型，可以是基本数据类型或引用数据类型；

在方法体中使用`return` 关键字可以返回具体的数据内容并结束当前方法，所以return后面的代码就不会再执行；

如果方法不需要返回数据，则返回值类型为`void` 。

对形参列表的说明：

形参即形式参数，主要用于将方法外的数据内容带入到方法体内部；

形参列表就是多个形参组成的列表，语法格式为`数据类型 形参名1, 数据类型 形参名2, ...` ；

如果不需要带入任何数据内容，则可以省略不写。

对方法体的说明：

方法体主要用于编写描述该方法功能的语句块。

方法的功能：

实现代码重用、简化代码。

可以实现成员方法对Person类进行简化，如下：

/* Person类的定义 */
    
    public class Person { 
      
      // 1.定义成员变量
      String name; // 描述姓名的成员变量
      int age;   // 描述年龄的成员变量
      
      // 2.定义成员方法，实现成员变量的打印
      void printVariable() { 
        System.out.println("我是" + name + "， 年龄是" + age + "岁了");
      }
      
      public static void main(String[] args) { 
        
        // 3.声明Person类型的引用指向Person类型的对象
        Person p = new Person();
        
        // 4.打印对象中的成员变量值
        
        
        System.out.println("--------------------------------------");
        // 5.修改成员变量值
        p.name = "Corley";
        p.age = 18;
        // 6.打印修改后的值
      }
      
    }

可以看到，实现了成员方法的定义；

因为成员变量和成员方法都是类内部的成员，因此成员方法中可以直接访问成员变量而不需要加`引用.` 的前缀。

## （2）类中参数和返回值的多种情况下成员方法的定义和调用 ##

### Ⅰ 无参无返回值成员方法的定义与调用 ###

调用格式为：

引用变量名.成员方法名(实参列表);

调用方法时的参数列表为实参列表，主要用于对形参列表进行初始化操作，因此两者参数的个数、类型和顺序都要完全一致。

实参可以是直接量、变量、表达式和方法的调用等。

代码示意如下：

/* Person类的定义 */
    
    public class Person { 
      
      // 1.定义成员变量
      String name; // 描述姓名的成员变量
      int age;   // 描述年龄的成员变量
      
      // 2.定义成员方法，实现成员变量的打印
      void printVariable() { 
        System.out.println("我是" + name + "， 年龄是" + age + "岁了");
      }
      
      public static void main(String[] args) { 
        
        // 3.声明Person类型的引用指向Person类型的对象
        Person p = new Person();
        
        // 4.打印对象中的成员变量值
        p.printVariable();
        
        System.out.println("--------------------------------------");
        // 5.修改成员变量值
        p.name = "Corley";
        p.age = 18;
        // 6.打印修改后的值
        p.printVariable();
      }
      
    }

输出如下：

我是null， 年龄是0岁了
    --------------------------------------
    我是Corley， 年龄是18岁了

调用方法的本质是根据方法名跳转到到方法中执行方法体再跳转回调用该方法的位置。

Point类中也实现无参无返回值成员方法的定义和调用，如下：

/* Point类的定义 */
    
    public class Point { 
      
      int x; // 描述横坐标的成员变量
      int y; // 描述纵坐标的成员变量
      
      // 自定义成员方法实现成员变量数值的打印
      void printVariable() { 
        System.out.println("横坐标是" + x + "，纵坐标是" + y);
      }
      
      public static void main(String[] args) { 
        
        // 1.声明Point类型引用指向Point类型变量
        Point po = new Point();
        
        // 2.打印成员变量
        po.printVariable();
        
        System.out.println("------------------------------------");
        // 3.横纵坐标修改为3、5后再打印
        po.x = 3;
        po.y = 5;
        po.printVariable();
      }
    }

运行效果与之前相同。

### Ⅱ 有参无返回值成员方法的使用 ###

输出：

我是null， 年龄是0岁了
    --------------------------------------
    我是Corley， 年龄是18岁了
    --------------------------------------
    我是Jack， 年龄是15岁了

### Ⅲ 多个形参成员方法的使用 ###

输出：

其中，`setName()` 方法和`setAgeName()` 方法中的形参列表都包括变量s，但是不会冲突，因为都属于局部变量，只在当前方法的范围内有效；

参数除了是直接量，还可以是表达式和变量等；

以后的开发中，`setAgeName()` 方法不推荐，因为这个方法不符合**高内聚、低耦合** 的要求。

Point类中实现有参数无返回值方法的使用，如下：

输出：

横坐标是0，纵坐标是0
    ------------------------------------
    横坐标是3，纵坐标是5
    ------------------------------------
    横坐标是6，纵坐标是8

### Ⅳ 可变长参数的使用 ###

当不确定参数的个数时，就需要用到可变长参数。

格式为：

返回值类型 方法名(参数的类型...参数名)

此时可以传入的实参的个数是可变的，即为0-n个；

可变长参数中参数的类型是相同的，方法内部使用可变长参数时可以当成一维数组使用；

一个方法的形参列表中只能声明一个可变长参数，并且需要放到参数列表的末尾。

如下：

/* Person类的定义 */
    
    public class Person { 
      
      // 定义成员变量
      String name; // 描述姓名的成员变量
      int age;   // 描述年龄的成员变量
      
      // 定义成员方法，实现成员变量的打印
      void printVariable() { 
        System.out.println("我是" + name + "， 年龄是" + age + "岁了");
      }
      
      // 自定义成员方法修改姓名为参数指定数值
      void setName(String s) { 
        name = s;
      }
      
      // 自定义成员方法修改年龄为参数指定数值
      void setAge(int i) { 
        age = i;
      }
      
      // 自定义成员方法修改姓名和年龄分别为指定的参数值
      void setAgeName(String s, int i) { 
        name = s;
        age = i;
      }
      
      // 使用可变长参数
      void showArgument(int num, String...args) { 
        System.out.println("num为" + num);
        for (int i = 0; i < args.length; i++) { 
          System.out.println("第" + (i + 1) + "个参数为" + args[i]);
        }
      }
      
      public static void main(String[] args) { 
        
        // 1.声明Person类型的引用指向Person类型的对象
        Person p = new Person();
        
        // 2.打印对象中的成员变量值
        p.printVariable();
        
        System.out.println("--------------------------------------");
        // 3.修改成员变量值
        p.name = "Corley";
        p.age = 18;
        // 4.打印修改后的值
        p.printVariable();
        
        System.out.println("--------------------------------------");
        // 5.调用成员方法修改成员变量
        p.setName("Jack");
        p.setAge(15);
        // 6.打印修改后的值
        p.printVariable();
        
        System.out.println("--------------------------------------");
        // 7.调用成员方法修改多个成员变量
        int ag = 10;
        p.setAgeName("Bill " + "Clinton", ag);
        // 8.打印修改后的值
        p.printVariable();
        
        System.out.println("--------------------------------------");
        // 7.调用成员方法实现可变长参数
        p.showArgument(111);
        System.out.println("--------------------------------------");
        p.showArgument(222, "arg1");
        System.out.println("--------------------------------------");
        p.showArgument(333, "arg1", "arg2");
      }
      
    }

输出：

我是null， 年龄是0岁了
    --------------------------------------
    我是Corley， 年龄是18岁了
    --------------------------------------
    我是Jack， 年龄是15岁了
    --------------------------------------
    我是Bill Clinton， 年龄是10岁了
    --------------------------------------
    num为111
    --------------------------------------
    num为222
    第1个参数为arg1
    --------------------------------------
    num为333
    第1个参数为arg1
    第2个参数为arg2

Point类中也实现可变参数的使用，如下：

/* Point类的定义 */
    
    public class Point { 
      
      int x; // 描述横坐标的成员变量
      int y; // 描述纵坐标的成员变量
      
      // 自定义成员方法实现成员变量数值的打印
      void printVariable() { 
        System.out.println("横坐标是" + x + "，纵坐标是" + y);
      }
      
      // 自定义成员方法实现将横坐标修改为指定参数值
      void setX(int i){ 
        x = i;
      }
      
      // 自定义成员方法实现将纵坐标修改为指定参数值
      void setY(int j){ 
        y = j;
      }
      
      // 自定义成员方法实现可变长参数的使用
      void showArgument(int...args) { 
        for (int i = 0; i < args.length; i++) { 
          System.out.println("第" + (i + 1) + "个参数为" + args[i]);
        }
      }
      
      public static void main(String[] args) { 
        
        // 1.声明Point类型引用指向Point类型变量
        Point po = new Point();
        
        // 2.打印成员变量
        po.printVariable();
        
        System.out.println("------------------------------------");
        // 3.横纵坐标修改为3、5后再打印
        po.x = 3;
        po.y = 5;
        po.printVariable();
        
        System.out.println("------------------------------------");
        // 4.调用成员方法修改成员变量
        po.setX(6);
        po.setY(8);
        po.printVariable();
        
        System.out.println("------------------------------------");
        // 5.调用成员方法实现可变长参数
        po.showArgument();
        System.out.println("------------------------------------");
        po.showArgument(1);
        System.out.println("------------------------------------");
        po.showArgument(1, 2, 3);
        System.out.println("------------------------------------");
        po.showArgument(1, 2, 3, 4, 5);
      }
    }

输出：

横坐标是0，纵坐标是0
    ------------------------------------
    横坐标是3，纵坐标是5
    ------------------------------------
    横坐标是6，纵坐标是8
    ------------------------------------
    ------------------------------------
    第1个参数为1
    ------------------------------------
    第1个参数为1
    第2个参数为2
    第3个参数为3
    ------------------------------------
    第1个参数为1
    第2个参数为2
    第3个参数为3
    第4个参数为4
    第5个参数为5

### Ⅴ 无参有返回值方法的使用 ###

如下：

/* Person类的定义 */
    
    public class Person { 
      
      // 定义成员变量
      String name; // 描述姓名的成员变量
      int age;   // 描述年龄的成员变量
      
      // 定义成员方法，实现成员变量的打印
      void printVariable() { 
        System.out.println("我是" + name + "， 年龄是" + age + "岁了");
      }
      
      // 自定义成员方法修改姓名为参数指定数值
      void setName(String s) { 
        name = s;
      }
      
      // 自定义成员方法修改年龄为参数指定数值
      void setAge(int i) { 
        age = i;
      }
      
      // 自定义成员方法修改姓名和年龄分别为指定的参数值
      void setAgeName(String s, int i) { 
        name = s;
        age = i;
      }
      
      // 使用可变长参数
      void showArgument(int num, String...args) { 
        System.out.println("num为" + num);
        for (int i = 0; i < args.length; i++) { 
          System.out.println("第" + (i + 1) + "个参数为" + args[i]);
        }
      }
      
      // 自定义成员方法获取姓名并返回
      String getName() { 
        return name;
      }
      
      // 自定义成员方法获取年龄并返回
      int getAge() { 
        return age;
      }
      
      public static void main(String[] args) { 
        
        // 1.声明Person类型的引用指向Person类型的对象
        Person p = new Person();
        
        // 2.打印对象中的成员变量值
        p.printVariable();
        
        System.out.println("--------------------------------------");
        // 3.修改成员变量值
        p.name = "Corley";
        p.age = 18;
        // 4.打印修改后的值
        p.printVariable();
        
        System.out.println("--------------------------------------");
        // 5.调用成员方法修改成员变量
        p.setName("Jack");
        p.setAge(15);
        // 6.打印修改后的值
        p.printVariable();
        
        System.out.println("--------------------------------------");
        // 7.调用成员方法修改多个成员变量
        int ag = 10;
        p.setAgeName("Bill " + "Clinton", ag);
        // 8.打印修改后的值
        p.printVariable();
        
        System.out.println("--------------------------------------");
        // 7.调用成员方法实现可变长参数
        p.showArgument(111);
        System.out.println("--------------------------------------");
        p.showArgument(222, "arg1");
        System.out.println("--------------------------------------");
        p.showArgument(333, "arg1", "arg2");
        
        System.out.println("--------------------------------------");
        // 8.通过调用成员方法实现成员变量值的获取
        String n = p.getName();
        System.out.println("获取到的姓名是" + n);
        int a = p.getAge();
        System.out.println("获取到的年龄是" + a);
      }
      
    }

输出：

局部变量与成员变量的区别：

1.  声明的位置不同
2.  作用域不同

局部变量的作用范围是方法体内部从声明该变量开始到该方法体结束；

成员变量的作用范围是类体从定义到结束。

再在Point类中实现，如下：

/* Point类的定义 */
    
    public class Point { 
      
      int x; // 描述横坐标的成员变量
      int y; // 描述纵坐标的成员变量
      
      // 自定义成员方法实现成员变量数值的打印
      void printVariable() { 
        System.out.println("横坐标是" + x + "，纵坐标是" + y);
      }
      
      // 自定义成员方法实现将横坐标修改为指定参数值
      void setX(int i){ 
        x = i;
      }
      
      // 自定义成员方法实现将纵坐标修改为指定参数值
      void setY(int j){ 
        y = j;
      }
      
      // 自定义成员方法实现可变长参数的使用
      void showArgument(int...args) { 
        for (int i = 0; i < args.length; i++) { 
          System.out.println("第" + (i + 1) + "个参数为" + args[i]);
        }
      }
      
      // 自定义成员方法获取横坐标并返回
      int getX() { 
        return x;
      }
      
      // 自定义成员方法获取纵坐标并返回
      int getY() { 
        return y;
      }
      
      public static void main(String[] args) { 
        
        // 1.声明Point类型引用指向Point类型变量
        Point po = new Point();
        
        // 2.打印成员变量
        po.printVariable();
        
        System.out.println("------------------------------------");
        // 3.横纵坐标修改为3、5后再打印
        po.x = 3;
        po.y = 5;
        po.printVariable();
        
        System.out.println("------------------------------------");
        // 4.调用成员方法修改成员变量
        po.setX(6);
        po.setY(8);
        po.printVariable();
        
        System.out.println("------------------------------------");
        // 5.调用成员方法实现可变长参数
        po.showArgument();
        System.out.println("------------------------------------");
        po.showArgument(1);
        System.out.println("------------------------------------");
        po.showArgument(1, 2, 3);
        System.out.println("------------------------------------");
        po.showArgument(1, 2, 3, 4, 5);
        
        System.out.println("------------------------------------");
        // 6.通过调用成员方法实现成员变量值的获取
        int newX = po.getX();
        int newY = po.getY();
        System.out.println("获取到的横坐标是" + newX + "，纵坐标是" + newY);
      }
    }

输出：

## （3）方法的传参过程 ##

例如，定义了一个方法`int max(int ia, int ib) {... ... ...}` ，在main方法中进行调用`int a = 5;int b = 6; int res = m.max(a, b);` ，过程如下：

1.  为main方法中的变量a、b、res分配空间并初始化；
2.  调用max方法，为max方法的形参变量ia、ib分配空间；
3.  将实参变量的数值赋值到形参变量的内存空间中；
4.  max方法运行完毕后返回，形参变量空间释放；
5.  main方法中的res变量得到max方法的返回值；
6.  main方法结束后释放相关变量的内存空间。

## （4）参数传递的注意事项 ##

/* 参数传递 */
    
    public class ArgumentTest { 
      
      // 自定义成员方法打印传入的整型数据
      void printVariable1(int i) { 
        i = 200;
        System.out.println("printVariable1方法中i=" + i);
      }
      
      // 自定义成员方法打印传入的数组
      void printVariable2(int[] arr) { 
        arr[0] = 100;
        System.out.println("printVariable2方法中arr[0]=" + arr[0]);
      }
      
      void printVariable3(int[] arr) { 
        arr = new int[2];
        arr[0] = 100;
        System.out.println("printVariable3方法中arr[0]=" + arr[0]);
      }
      
      public static void main(String[] args) { 
        
        // 1.声明ArgumentTest类型的引用指向该类型的对象
        ArgumentTest at = new ArgumentTest();
        
        // 2.调用printVariable1方法
        int i = 10;
        at.printVariable1(i);
        System.out.println("main方法中i=" + i);
        
        System.out.println("------------------------------------");
        // 3.调用printVariable2方法
        int[] arr = new int[]{ 10, 20};
        at.printVariable2(arr);
        System.out.println("main方法中arr[0]=" + arr[0]);
        
        System.out.println("------------------------------------");
        // 4.调用printVariable3方法
        arr = new int[]{ 10, 20};
        at.printVariable3(arr);
        System.out.println("main方法中arr[0]=" + arr[0]);
      }
    }

输出：

printVariable1方法中i=200
    main方法中i=10
    ------------------------------------
    printVariable2方法中arr[0]=100
    main方法中arr[0]=100
    ------------------------------------
    printVariable3方法中arr[0]=100
    main方法中arr[0]=10

其中，在`printVariable3()` 方法相对于`printVariable2()` 方法增加一行代码即20行代码后，相当于在堆区中又重新申请一块内存空间。

可以总结如下：

基本数据类型的变量作为方法的参数传递时，形参变量数值的改变通常不会影响到实参变量的数值，因为两个变量有各自独立的内存空间；

引用数据类型的变量作为方法的参数传递时，形参变量指向内容的改变会影响到实参变量指向内容的数值，因为两个变量指向同一块内存空间；

当引用数据类型的变量作为方法的参数传递时，若形参变量改变指向后再改变指定的内容，则通常不会影响到实参变量指向内容的改变，因为两个变量指向不同的内存空间。

# 总结 #

面向对象是Java中最核心的思想，也是Java作为面向对象编程语言的重要基础，类和对象就是Java面向对象的体现，面向的三大特性（封装、继承和多态）也在很大基础上决定了Java的编程模式。