从零学Java - 面向对象详解

Java 面向对象详解

1.面向对象思想

1.1 引言

世界是由什么组成的

• 有人说：“世界是由无数原子组成的”。
• 有人说：“世界是由无数事物组成的”。
• 有人说：“世界是由无数物体组成的”。
• 有人说：“世界是由一切有生命的和一切没有生命的组成的”。
• 有人说：“你、我、他、大家组成的”。

所有回答都很抽象，没有特别明确的答案。在程序员的眼里，世界的组成最为明确：“世界是由无数个对象组成的”。

1.2 什么是面向对象思想?

面向对象思想是由面向过程思想发展过来的

面向过程（Procedure Oriented）:

• 就是分析出解决问题所需要的步骤，然后用函数（方法）把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向对象（Object Oriented）:

• 先去找具有所需功能的对象来用。如果该对象不存在，那么创建一个具有所需功能的对象。
• 简化开发并提高重用性。
• 程序员从执行者转化成了指挥者。

**eg: **

小明和小红坐飞机去泰国旅游

面向过程(细节):
	1.办签证	2.买机票	3.打车去机场
	4.坐飞机	5.下飞机	6.旅游
     ......
面向对象(高角度):
	1.对象: 小明 小红, 飞机
	2.对象的功能: 
		1) 小明/红 1.办签证	2.买机票	3.打车去机场	  4.旅游...
		2) 飞机 1.起飞 2.着陆...
		...

2.什么是对象? 什么是类?

2.1 什么是对象?

对象：一切客观存在的事物都是对象，万物皆对象，每个对象都有自己的特征和行为。

• 特征：称为属性，一般为名词，代表对象有什么
• 行为：称为方法，一般为动词，代表对象能做什么。

生活中的对象:

• 手机:
  • 特征：品牌：apple; 颜色：银色; 价格：5988.0; 重量：138克 …
  • 行为(功能)：收发短信; 接打电话 …
• 汽车:
  • 特征：品牌：保时捷; 颜色：白色; 型号：911; 产地：德国 …
  • 行为(功能)：前进; 后退 …

程序中的对象:

如何使用程序模拟现实世界，解决现实问题？

• 首先，在程序当中，必须具有和现实中相同的对象，用以模拟现实世界。
• 然后，使用程序中的对象代表现实中的对象，并执行操作，进而解决现实问题。

现实中的对象多数来自于“模板”，程序中的对象也应该具有“模板”。

2.2 什么是类?

现实中的对象多数来自于“模板”

• 例如汽车设计图纸规定了该款汽车所有的组成部分，包括外观形状、内部结构、发动机型号、安全参数等具体的信息。称为汽车模板。程序中的模板也有相同作用，称之为“类”。
• 按照设计图纸创造出来的汽车，才是真实存在、切实可用的实体。在程序中使用类创建“对象”。

类(类别/类型)：是具有相同属性（特征）和行为的一类事物的描述，是抽象的、概念上的定义。

eg: 类的定义

package StageOne.day08.oop;

/**
 * @author 胡昊龙
 * @version 1.0
 * @description: Dog 类
 * @date 2023/12/28 11:50
 */
public class Dog {
    //属性
    //名字
    String name;
    //品种
    String breed;
    //年龄
    int age;
    //性别
    String gender;
    //颜色
    String color;

    //行为
    //吃
    void cat() {
        System.out.println("狗狗啃骨头......");
    }
    //睡
    void sleep() {
        System.out.println("狗狗睡觉......");
    }
}

eg: 对象的创建

package StageOne.day08.oop;

/**
 * @author 胡昊龙
 * @version 1.0
 * @description: 测试 Dog 类	实例
 * @date 2023/12/28 11:54
 */
public class TestDog {
    public static void main(String[] args) {
        //使用 Dog 类创建对象并初始化
        Dog myDog = new Dog();
        myDog.name = "哈总";
        myDog.breed = "哈士奇";
        myDog.age = 2;
        myDog.gender = "公";
        myDog.color = "蓝银";
        //获取属性
        System.out.println(myDog.name+" "+myDog.breed+" "+myDog.age+" "+myDog.gender+" "+myDog.color+" ");
        //调用方法
        myDog.cat();
        myDog.sleep();
    }
}

编写类就是在一组相同或类似对象中，抽取出共性的属性和方法，保留所关注部分。

2.3 类与对象的关系

类：定义了对象应具有的特征和行为，类是对象的模板。对象：拥有多个特征和行为的实体，对象是类的实例。

3.类的组成

3.1 成员变量

成员变量包含：实例变量（非静态变量）和类变量（静态变量）。

思考：之前学习局部变量时，要求必须先赋值再使用，否则编译错误。对于成员变量而言，未赋值并不会编译错误，能否直接访问？

成员变量的默认值： 整数：0; 小数：0.0; 字符：‘\u0000’; 布尔：false; 引用类型：null

---

重点:成员变量与局部变量的区别

	局部变量	成员变量
定义位置	方法或方法内的结构当中	类的内部，方法的外部
默认值	无默认值	默认值（与数组相同）
使用范围	从定义行到包含其结构结束	本类有效
命名冲突	在重合作用范围内，不允许局部变量重名	不允许成员变量重名可与局部变量重名，局部变量优先

3.2 方法

方法：包含 实例方法（非静态方法）和 类方法（静态方法）, 包含两部分：方法的声明和方法的实现。

• 方法的声明：代表对象能做什么。
  • 组成：修饰符 返回值类型 方法名(形参列表)
• 方法的实现【方法体】：代表对象怎么做：即如何实现对应的功能。
  • 组成：{ 逻辑代码 }

---

eg:

package StageOne.day08.oop;

/**
 * @author 胡昊龙
 * @version 1.0
 * @description: Student 类
 * 1.定义学生类：
 * 属性：姓名(name)、年龄(age)、性别(gender)、分数(score)
 * 方法：打招呼(sayHi) //打印学生所有信息
 * @date 2023/12/28 14:36
 */
public class Student {
    String name;
    int age;
    String gender;
    double score;

    public void sayHi() {
        System.out.println("大家好,我是"+name+"年龄: "+age+"性别: "+gender+"成绩: "+score);
    }
}

package StageOne.day08.oop;

/**
 * @author 胡昊龙
 * @version 1.0
 * @description:  测试 Student 类
 * 2.创建多个学生对象，为其各个属性赋值，并调用方法。
 * 3.把学生对象放入数组中并进行遍历。
 * @date 2023/12/28 14:44
 */
public class TestStu {
    public static void main(String[] args) {
        //使用 Student 创建对象
        Student stu1 = new Student();
        //属性赋值
        stu1.name = "张三";
        stu1.age = 18;
        stu1.gender = "男";
        stu1.score = 93.5;
        //调用方法
        stu1.sayHi();

        //使用 Student 创建对象
        Student stu2 = new Student();
        //属性赋值
        stu2.name = "李四";
        stu2.age = 20;
        stu2.gender = "男";
        stu2.score = 97.5;
        //调用方法
        stu2.sayHi();

        //使用 Student 创建对象
        Student stu3 = new Student();
        //属性赋值
        stu3.name = "小红";
        stu3.age = 22;
        stu3.gender = "女";
        stu3.score = 100;
        //调用方法
        stu3.sayHi();

        System.out.println("=============================================================");

        //把学生对象放入数组中并进行遍历。
        int[] nums = {10,20,30};
        String[] names = {"张三","李四","王五"};
        Student[] students = {stu1,stu2,stu3};

        //遍历数组
        for (int num : nums) {
            System.out.println(num);
        }
        for (String name : names) {
            System.out.println(name);
        }
        for (Student student : students) {
            student.sayHi();
        }
    }
}

res:

大家好,我是张三年龄: 18性别: 男成绩: 93.5
大家好,我是李四年龄: 20性别: 男成绩: 97.5
大家好,我是小红年龄: 22性别: 女成绩: 100.0
=============================================================
10
20
30
张三
李四
王五
大家好,我是张三年龄: 18性别: 男成绩: 93.5
大家好,我是李四年龄: 20性别: 男成绩: 97.5
大家好,我是小红年龄: 22性别: 女成绩: 100.0

---

eg:

package StageOne.day08.oop;

/**
 * @author 胡昊龙
 * @version 1.0
 * @description: 定义宠物类Pet
 *  属性：昵称：nickname, 年龄：age, 性别：sex, 品种：breed
 *  方法：打印信息 show()，吃 eat()
 * @date 2023/12/28 15:18
 */
public class Pet {
    String nickname;
    int age;
    String sex;
    String breed;

    public void show() {
        System.out.println("昵称: "+nickname+" 年龄: "+age+" 性别: "+sex+" 品种: "+breed);
    }
    public void eat() {
        System.out.println(nickname+"开始吃东西了......");
    }
}

package StageOne.day08.oop;

/**
 * @author 胡昊龙
 * @version 1.0
 * @description: 创建5个宠物对象，并把宠物放入数组中进行遍历。
 * @date 2023/12/28 15:18
 */
public class TestPet {
    public static void main(String[] args) {
        Pet pet_1 = new Pet();
        pet_1.nickname = "小黑1";
        pet_1.age = 1;
        pet_1.sex = "公";
        pet_1.breed = "哈士奇";

        Pet pet_2 = new Pet();
        pet_2.nickname = "小黑2";
        pet_2.age = 2;
        pet_2.sex = "公";
        pet_2.breed = "哈士奇";

        Pet pet_3 = new Pet();
        pet_3.nickname = "小黑3";
        pet_3.age = 2;
        pet_3.sex = "公";
        pet_3.breed = "哈士奇";

        Pet pet_4 = new Pet();
        pet_4.nickname = "小黑4";
        pet_4.age = 4;
        pet_4.sex = "母";
        pet_4.breed = "哈士奇";

        Pet pet_5 = new Pet();
        pet_5.nickname = "小黑5";
        pet_5.age = 4;
        pet_5.sex = "公";
        pet_5.breed = "哈士奇";

        Pet[] pets = {pet_1,pet_2,pet_3,pet_4,pet_5};
        for (Pet pet : pets) {
            pet.show();
            pet.eat();
        }
    }
}

res:

昵称: 小黑1 年龄: 1 性别: 公 品种: 哈士奇
小黑1开始吃东西了......
昵称: 小黑2 年龄: 2 性别: 公 品种: 哈士奇
小黑2开始吃东西了......
昵称: 小黑3 年龄: 2 性别: 公 品种: 哈士奇
小黑3开始吃东西了......
昵称: 小黑4 年龄: 4 性别: 母 品种: 哈士奇
小黑4开始吃东西了......
昵称: 小黑5 年龄: 4 性别: 公 品种: 哈士奇
小黑5开始吃东西了......

复习: 方法重载

方法重载（Overload）：同一个类中定义多个名称相同的方法，参数列表不同。

重载规则

• 方法名称相同，参数列表不同。(类型、个数、顺序)。

• 与方法修饰符、返回值类型无关。

调用带有重载的方法时，需要根据传入的实参去找到与之匹配的方法。

好处：减少给多个功能相同的方法命名、方便开发人员使用。

注意：只是参数名称不同，并不能构成方法重载。

有些情况下，对象的同一种行为可能存在多种实现过程。

• 例如：人对象的“吃”行为，吃饭和吃药的过程就存在差异。

//到底采用哪种实现过程，需要取决于调用者给定的参数。
public class Person {
public void eat(食物 a) {
        //食物放入口中
        //咀嚼
        //咽下
    }
    public void eat(药物 b) {
        //药物放入口中
        //喝水
        //咽下
    }
    public void eat(口香糖 c) {
        //口香糖放入口中
        //咀嚼
        //吐出
    }
}

4.构造方法

构造方法：类中的特殊方法，主要用于创建对象，初始化属性。

特点：

• 构造方法名称与类名完全相同，没有返回值类型。
• 创建对象时，自动触发构造方法的调用。

注意：如果没有在类中显示定义构造方法，则编译器默认提供无参构造方法。

4.1 构造方法重载

构造方法也可重载，遵循重载规则。

在类中，如果没有显示定义构造方法，则编译器默认提供无参构造方法。

eg:

package StageOne.day08.oop.demo;

/**
 * @author 胡昊龙
 * @version 1.0
 * @description: 构造方法
 * > 构造方法：类中的特殊方法，主要用于 创建对象，初始化属性。
 * 特点：
 * - 构造方法名称与类名完全相同，没有返回值类型。
 * - 创建对象时，自动触发构造方法的调用。
 * 注意：如果没有在类中显示定义构造方法，则编译器默认提供无参构造方法。
 * @date 2023/12/28 16:15
 */
public class Student {
    String name;
    int age;
    String gender;
    double score;

    //如已手动添加有参构造方法，则无参构造方法不再默认提供，可根据需求自行添加。
    public Student() {
        System.out.println("无参构造方法执行了......");
    }
	//由构造方法为各个属性赋值 
    public Student(String n, int a, String g, double s) {
        System.out.println("有参构造方法执行了......");
        name = n;
        age = a;
        gender = g;
        score = s;
    }

    public void sayHi() {
        System.out.println("大家好,我是"+name+" 年龄: "+age+" 性别: "+gender+" 成绩: "+score);
    }
}

package StageOne.day08.oop.demo;

/**
 * @author 胡昊龙
 * @version 1.0
 * @description: 有参构造
 * @date 2023/12/28 16:39
 */
public class TestStudent {
    public static void main(String[] args) {

        //无参构造
        Student stu = new Student();

        stu.sayHi();

        //有参构造
        //创建对象的同时，将值传入构造方法
        Student stu1 = new Student("张三",18,"男",100);

        stu1.sayHi();
    }
}

res:

无参构造方法执行了......
大家好,我是null 年龄: 0 性别: null 成绩: 0.0
有参构造方法执行了......
大家好,我是张三 年龄: 18 性别: 男 成绩: 100.0

5. 内存中的对象

5.1 对象的创建过程

步骤：

1. 在内存中开辟对象内存空间，属性值为默认值；
2. 执行构造方法中的代码
3. 把对象的地址赋值给局部变量

//无参构造
Student stu1 = new Student();
//有参构造
Student stu2 = new Student("张三", 20, "男", 100);
public Student(String n, int a, String g, double s) {
    name = n;
    age = a;
    gender = g;
    score = s;
}

5.2 对象的内存分配

内存图：

6. this 关键字

this是类中的默认引用，代表当前对象（实例）；当类服务于某个对象时，this则指向这个对象。

内存图：

this 第一种用法：调用实例属性。如：this.name、this.age

• 解决成员成员变量和局部变量同名问题。

eg：

public Student(String name, int age, String gender, double score) {
    //this第一种用法：调用实例属性。如：this.name、this.age
    //解决成员成员变量和局部变量同名问题。
    System.out.println("有参构造方法执行了......");
    this.name = name;
    this.age = age;
    this.gender = gender;
    this.score = score;
}

this 第二种用法：调用实例方法。如：this.study()

eg：

public void sayHi() {
    //this第一种用法：调用实例属性。如：this.name、this.age
    System.out.println("大家好,我是"+this.name+" 年龄: "+this.age+" " +
                       "性别: "+this.gender+" 成绩: "+this.score);

    //this第二种用法：调用实例方法。如：this.study()
    this.study();
}

public void study() {
    System.out.println(this.name + " 好好学习");
}

this 第三种用法：调用本类中的其他构造方法，减少代码冗余; 如：this()、this(实参)

eg：

public Student() {
	//this.name = "xxx";
    //this.age = 18;
    //this.gender = "男";
    //this.score = 60;
   
    //this 调用本类中的其他构造方法
    //注意: this(实参) 必须是构造方法的首行, 且不能同时相互调用。
    this("xxx", 18, "男", 60);
    
    System.out.println("无参构造方法执行了......");
}

public Student(String name, int age, String gender, double score) {
    //this第一种用法：调用实例属性。如：this.name、this.age
    //解决成员成员变量和局部变量同名问题。
    this.name = name;
    this.age = age;
    this.gender = gender;
    this.score = score;
    System.out.println("有参构造方法执行了......");
}

7. 使用IDEA生成帮助文档

7.1 文档注释

当开发一个大型软件时，需要定义成千上万个类，而且需要很多人参与开发。每个人都会开发一些类，并在类里定义一些方法和属性提供给其他人使用，但其他人怎么知道如何使用这些类和方法呢？

API文档就是用来说明这些应用程序接口的文档。

//文档注释语法
/**开始       结束*/

文档注释常用标签:

标签	含义
@author	标识一个类的作者，例如 @author wgy
@version	指定类的版本
@see	指定参考的链接或内容
@param	说明一个方法的参数
@since	指定从哪个JDK版本开始提供支持
@return	说明返回值类型

eg:

package StageOne.day09.demo02;

/**
 * @author 胡昊龙
 * @version 1.0
 * @description: TODO 需求1:定义一个汽车类：Car 
 *                    属性：color、brand、price 
 *                    方法：前进 run()、显示信息 show()
 *                    需求2：在汽车类中添加多个构造方法
 * @date 2023/12/29 11:19
 */

public class Car {
    /**
     * 颜色
     */
    String color;
    /**
     * 品牌
     */
    String brand;
    /**
     * 价格
     */
    double price;

    //alt + insert  快捷生成构造方法


    /**
     * 无参构造
     */
    public Car() {
        System.out.println("无参构造");
    }

    /**
     * 单参数构造
     * @param brand 汽车品牌
     */
    public Car(String brand) {
        this.brand = brand;
    }

    /**
     * 有参构造
     * @param color 汽车颜色
     * @param brand 汽车品牌
     * @param price 汽车价格
     */
    public Car(String color, String brand, double price) {
        this.color = color;
        this.brand = brand;
        this.price = price;
    }


    /**
     * 前进
     */
    public void run() {
        System.out.println(this.brand+"汽车在高速前进!");
    }

    /**
     * 展示信息
     */
    public void show() {
        System.out.println("颜色：" + this.color + " 品牌：" + this.brand
        + " 价格：" + this.price);
        this.run();
    }
}

7.2 命令行生成帮助文档

使用javadoc命令生成文档:

• javadoc -d doc *.java
• 编码设置：-encoding utf-8 -charset utf-8

7.3 使用IDEA生成帮助文档

1. 寻找IDEA工具栏中的Tools选项；

2. 选择 Generate JavaDoc 选型；

3. 进入如图的选项页面；

4. 进入你存放Doc的位置，打开index.html，这便是你所生成的帮助文档；