面向对象---类和对象

面向对象编程

对象？

• 万物皆对象
• 面向对象指以属性和行为的观点去分析现实生活中的事物 【属性、特征】

面向对象编程的概念

• 面向对象编程指先以面向对象的思想进行分析，然后使用面向对象的编程语言进行表达的过程
• 对象主要指现实生活中客观存在的实体

面向对象的思想精髓

1. 封装
2. 继承
3. 多态

面向过程和面向对象的不同（C/C++/java）

1. C        面向过程语言  
2. c++      面向过程与面向对象语言
3. java     面向对象语言

• 面向过程与面向对象区别（以老师上课为例说明：）
  • 面向过程指的是完成某件事情的过程；
  • 面向对象是指完成某事（完成事情的具体过程在内部定义）
• 说明：以 教导主任按照课程的需要给上课老师分配上课任务 为例说明
  • 面向过程： 教导主任按照课程相关内容 逐步 进行任务的说明
    1. 9:00 讲解面向对象的概念
    2. 9:10 讲解面向对象编程的概念
    3. 9:20 讲解面向对象的语言
       ……
  • 面向对象： 教导主任按照课程的要求给老师发布任务： 面向对象的讲解
    • 老师按照自己的过程开始上课
      1. 讲解面向对象的概念
      2. 讲解面向对象编程的概念
      3. 讲解面向对象的语言
         ……

类和对象的概念

• 在java中 对象 体现为： 内存空间中的一块存储区域 【堆区】
• 类的概念【 蔬菜类、水果类、饮料类……】
  1. 简单来就是“分类”，对具有相同特征和行为的多个对象共性的抽象描述
  2. 在java中体现为一种引用数据类型，里面包含了描述 特征/属性 的成员变量以及描述 行为 的成员方法
  3. 类是用于构建 对象 的模板，对象的数据结构由定义它的类来决定

类的定义

格式

class 类名{
	数据类型 成员变量名 = 初始值;
	...
}
class Person{
    String name = "zhangsan";
    ...
}

常用的命名规则

1. 类名
   • 通常情况下，当类名由多个单词组成时，要求每个单词首字母都要大写
2. 变量名
   • 当成员变量由多个单词组成时，通常要求从第二个单词起每个单词的首字母大写
3. 成员方法名
   • 当成员方法由多个单词组成时，要求从第二个单词起每个单词的首字母大写

引用的基本概念

1. 使用引用数据类型定义的变量叫做引用数型变量，简称“引用”
2. 引用变量主要用于记录对象在堆区中的 内存地址 信息，便于下次访问

语法格式

//成员属性
类名 引用变量名
引用变量名.成员变量名

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

Person zhangSan = new Person();
zhangSan.name = "法外狂徒张三";
System.out.println(zhangSan.name);
// 法外狂徒张三

//无返回值 无形参的方法体
void Show(){
    System.out.println("没事秀一下");
}

// 有返回值 有形参的方法体
String eat(String str){
    return "吃饭" +str;
}

成员变量的初始值

• 对象创建后，其成员变量可以按照默认的方式初始化，具体规则如下：

成员变量类型	默认初始值
数值类型 byte、short、int、long、float、double、char	0
boolean	false
引用类型	null

返回值类型

1. 返回值主要指从方法体内返回到方法体外的数据内容
2. 返回值类型指返回值的数据类型，可以是基本数据类型，也可以是引用数据类型
3. 在方法体中使用return关键字返回具体的数据内容并 结束 当前方法
4. 当该方法不需要返回任何数据内容时，返回值类型用 void

形参

1. 形式参数主要用于将方法体外的数据内容带入到方法体内部
2. 形式参数列表指多个形式参数组成的列表，格式为： 数据类型 形参变量名1 , 数据类型 形参变量名2,…
3. 可变参数
   • 一个方法体的形参列表中 最多 只能声明一个可变长形参，并且需要放到参数列表的末尾

方法体

1. 成员方法体用于编写描述该方法功能的语句块
2. 成员方法可以实现代码的重用，简化代码
3. 方法体的调用
   1. 引用变量名.成员方法名(实参列表)
   2. 实际参数列表主要用于对形式参数列表进行初始化操作，因此参数的个数、类型以及顺序都要完全一致
   3. 实践参数可以传递直接量、变量、表达式、方法的调用等

对象的创建

new 类名(); 

//如：
new Person();

• 注意：
  1. 当一个类定义完毕后，可以使用new关键字来创建该类的对象，这个过程叫做类的实例化
  2. 创建对象的本质就是在内存空间的 堆区 申请一块存储区域，用于存放该对象独有特征信息 【匿名类】

实践出真理

1.定义实现Person类

• 特征/属性定义：名字、年龄
• 描述行为：
  1. 打印属性内容
  2. 修改姓名
  3. 修改年龄
  4. 同时修改名字与年龄
  5. 可变长形参
  6. 返回年龄

public class Person{
    //定义对象的属性
    String name;    //名字
    int age;        //年龄

    // 无返回值 无参数 方法体
    void show() {
        System.out.println("我的名字是： " + name + "\t年龄为： " + age);
    }

    // 有参数 无返回值 方法体
    void setName(String str) {
        //修改名字
        name = str;
    }

    //修改年龄
    void setAge(int num) {
        age = num;
    }

    //同时修改名字与年龄
    void setNameAndAge(String str, int num) {
        name = str;
        age = num;
    }

    //可变长形参列表[类型确定的]（类似于一维数组）
    void showArgument(String... args) {
        for (int i = 0; i < args.length; i++) {
            System.out.print("第" + (i + 1) + "个参数为： " + args[i] + "\t");
        }
    }
    //返回年龄
    int getAge() {
        return age;
    }

    public static void main(String[] args){
        Person p = new Person();
        System.out.println("创建的对象的名字是： " + p.name + "\t对象的年龄是： " + p.age);
            // 创建的对象的名字是： null    对象的年龄是：  0

        //修改成员变量的数值
        p.name = "张飞";
        p.age = 30;
        System.out.println("创建的对象的名字是： " + p.name + "\t对象的年龄是： " + p.age);
            // 创建的对象的名字是： 张飞    对象的年龄是：  30
        //调用成员方法
        p.show();
            // 我的名字是： 张飞    年龄为：  30

        p.setName("李四");
        p.setAge(36);
        p.show();
            //我的名字是： 李四    年龄为：  36
        p.setNameAndAge("张三", 38);
        p.show();
            //我的名字是： 张三    年龄为：  38
        p.showArgument("一", "二", "三", "四", "五");
            // 第1个参数为： 一	第2个参数为： 二	第3个参数为： 三	第4个参数为： 四	第5个参数为： 五	
        System.out.println(p.getAge());
            // 38
    }
}

运行结果：

参数传递的注意事项

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

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

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

   public class ArgumentTest {
       public static void main(String[] args) {
           ArgumentTest at = new ArgumentTest();
           int[] a = {10, 20};
           at.show(a);       // show 中 ia = 10
           System.out.println(a[0]);   //  10
           at.show_1(a);     // show_1 中 ia = 200
           System.out.println(a[0]);   //  200
       }
   
       void show(int[] ia) {
           System.out.println("show 中 ia = " + ia[0]);
       }
   
       void show_1(int[] ia) {
           ia[0] = 200;
           System.out.println("show_1 中 ia = " + ia[0]);
       }
   }
   
   

• 总结
  • 形参与实参是否发生变化，关注形参与实参之间是否存在相同的内存空间
    • 如果存在，则实参发生改变的同时形参也会发生改变
    • 如果不同，则形参与实参互不影响