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 对象的创建过程
步骤：
- 在内存中开辟对象内存空间，属性值为默认值；
- 执行构造方法中的代码
- 把对象的地址赋值给局部变量
//无参构造
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生成帮助文档
-
寻找IDEA工具栏中的Tools选项；
-
选择 Generate JavaDoc 选型；
-
进入如图的选项页面；
-
进入你存放Doc的位置，打开index.html，这便是你所生成的帮助文档；
扫一扫
1034
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
