Java基础系列13-面向对象简介

x33g5p2x  于2021-12-18 转载在 其他  
字(5.0k)|赞(0)|评价(0)|浏览(461)

一.面向对象概述

1.1 面向对象思想

我们回想一下,前面我们完成一个需求的步骤:首先是搞清楚我们要做什么,然后在分析怎么做,最后我们再代码体现。一步一步去实现,而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作,完成我们的需求。

在上面的每一个具体步骤中我们都是参与者,并且需要面对具体的每一个步骤和过程,这就是面向过程最直接的体现。

那么什么是面向过程开发呢? 面向过程开发,其实就是面向着具体的每一个步骤和过程,把每一个步骤和过程完成,然后由这些功能方法相互调用,完成需求。

面向过程的代表语言:C语言.

当需求单一,或者简单时,我们一步一步去操作没问题,并且效率也挺高。可随着需求的更改,功能的增多,发现需要面对每一个步骤很麻烦了,这时就开始思索,能不能把这些步骤和功能在进行封装,封装时根据不同的功能,进行不同的封装,功能类似的用一个类封装在一起,这样结构就清晰了很多。用的时候,找到对应的类就可以了。这就是面向对象的思想。

1.1.1 面向过程思想与面向对象思想

什么是面向过程?
面向过程,其实就是面向着具体的每一个步骤和过程,把每一个步骤和过程完成,然后由这些功能方法相互调用,完成需求。
例如:吃煎饼果子利用面向过程的思想:
1.学习摊煎饼的技术
2.买材料鸡蛋,油,葱等等
3.开始摊
4.吃
5.收拾

什么是面向对象?
面向对象思想就是不断的创建对象,使用对象,指挥对象做事情。(如果有对象,直接用对象,对我们直接提供服务)
例如:吃煎饼果子利用面向对象的思想:
1.找会摊煎饼的大妈(创建一个摊煎饼大妈的对象)
2.调用其摊煎饼的技能(功能),传递进去钱参数
3.返回给我们一个煎饼
4.吃

1.1.2 面向过程特点与面向对象特点

面向过程的特点:

  1. 强调的是过程,所有事情都需要自己完成

面向对象的特点:

  1. 是一种更符合我们思想习惯的思想(懒人思想,我把事情自己不做,交给别人去做)
  2. 可以将复杂的事情简单化(对使用者来说简单了,对象里面还是很复杂的)
  3. 将我们从执行者变成了指挥者角色发生了转换

1.2 类与对象概述

我们学习编程是为了什么:
1)为了把我们日常生活中实物用学习语言描述出来

我们如何描述现实世界事物:
1)属性 就是该事物的描述信息(事物身上的名词)
2)行为 就是该事物能够做什么(事物身上的动词)

Java中最基本的单位是类,Java中用class描述事物也是如此:
1)成员变量 就是事物的属性
2)成员方法 就是事物的行为

定义类其实就是定义类的成员(成员变量和成员方法):
1)成员变量 和以前定义变量是一样的,只不过位置发生了改变。在类中,方法外。
2)成员方法 和以前定义方法是一样的,只不过把static去掉,后面在详细讲解static的作用。

类和对象的概念:
1)类:是一组相关的属性和行为的集合(我们班所有的同学都具备相同的属性和行为,比如:姓名,年龄,学习,这样就把所有的学生成为学生类)
2)对象:是该类事物的具体体现(说某个同学时,他都具备自己特有的属性和行为)
3)举例:
  类 学生
  对象 具体的某个学生就是一个对象
4)比如:车是一个类,具体的开的奔驰、宝马,就是对象

代码:

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-23
  6. * @remark 学生类 案例
  7. *
  8. * 需求:定义一个学生类。
  9. *
  10. * 学生事物:
  11. * 属性:姓名,年龄...
  12. * 行为:学习,吃饭...
  13. *
  14. * 学生类:
  15. * 成员变量:姓名,年龄...
  16. * 成员方法:学习,吃饭...
  17. *
  18. */
  19. public class student {
  20. /*成员变量*/
  21. //姓名
  22. String name;
  23. //年龄
  24. int age;
  25. /*成员方法*/
  26. //学习的方法
  27. public void study() {
  28. System.out.println(name + " 好好学习,天天向上");
  29. }
  30. //吃饭的方法
  31. public void eat() {
  32. System.out.println(name + " 学习饿了要吃饭");
  33. }
  34. public static void main(String[] args) {
  35. //类型 对象名 = new 类名()
  36. student student1 = new student();
  37. // 给成员变量赋值
  38. student1.name = "杜兰特";
  39. student1.age = 32;
  40. System.out.println("姓名:" + student1.name);
  41. System.out.println("年龄:" + student1.age);
  42. //调用成员方法
  43. student1.study();
  44. student1.eat();
  45. }
  46. }

测试记录:

  1. 姓名:杜兰特
  2. 年龄:32
  3. 杜兰特 好好学习,天天向上
  4. 杜兰特学习饿了要吃饭

1.3 成员变量和局部变量区别

直接用代码来介绍成员变量和局部变量。

代码:

  1. package Java_study;
  2. /**
  3. * @author 只是甲
  4. * @date 2021-06-23
  5. * @remark 成员变量和局部变量区别
  6. *
  7. * 成员变量和局部变量的区别:
  8. * A:在类中的位置不同
  9. * 成员变量:在类中,方法外
  10. * 局部变量:在方法中或者方法声明上(形式参数)
  11. * B:在内存中的位置不同
  12. * 成员变量:在堆内存
  13. * 局部变量:在栈内存
  14. * C:生命周期不同
  15. * 成员变量:随着对象的创建而存在,随着对象的消失而消失
  16. * 局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
  17. * D:初始化值不同
  18. * 成员变量:有默认值
  19. * 局部变量:没有默认值,必须先定义,赋值,最后使用
  20. */
  21. public class chengyuanbianliang1 {
  22. /*成员变量*/
  23. int x;
  24. public void show() {
  25. // 局部变量
  26. int y = 10;
  27. System.out.println(x);
  28. System.out.println(y);
  29. }
  30. }

三.private、this关键字

3.1 private关键字的概述和特点

private关键字:

  1. 是一个权限修饰符;
  2. 可以修饰成员(成员变量和成员方法);
  3. 被private修饰的成员只在本类中才能访问。

代码1:
当前class中可以访问private的变量

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-23
  6. * @remark 学生类 private关键字的概述和特点
  7. *
  8. * 直接使用对象名访问成员变量,会存在数据的安全问题
  9. * 这个时候,我们就应该思考能不能让外界不要直接访问成员变量? 能
  10. * 如何实现呢? 用private关键字
  11. * private:
  12. * 是一个修饰符
  13. * 可以修饰成员变量,也可以修饰成员方法
  14. * 被private修饰的成员只能在本类中被访问
  15. *
  16. * 针对被private修饰的成员变量,我们会相应的给出getXxx()和setXxx()用于获取和设置成员变量的值,
  17. * 方法用public修饰
  18. *
  19. */
  20. public class private1 {
  21. String name;
  22. private int age;
  23. public int getAge() {
  24. return age;
  25. }
  26. public void setAge(int a) {
  27. if (a < 0 || a > 200) {
  28. System.out.println("输入年龄有误");
  29. } else {
  30. age = a;
  31. }
  32. }
  33. public void show() {
  34. System.out.println("[name:" + name + "] [age:" + age + "]");
  35. }
  36. // private 定义的变量,在本类中可以访问和赋值
  37. public static void main(String[] args) {
  38. // 创建对象
  39. private1 student = new private1();
  40. //给成员变量赋值
  41. student.name = "杜兰特";
  42. student.age = 32;
  43. student.show();
  44. }
  45. }

测试记录:

  1. [name:杜兰特] [age:32]

代码2:
其它class中不可以访问private的变量,需要通过主类的方法来修改。

  1. package Java_study;
  2. public class private2 {
  3. // 调用private1的方法和属性
  4. public static void main(String[] args) {
  5. //创建对象
  6. private1 student = new private1();
  7. //给成员变量赋值
  8. student.name = "杜兰特";
  9. //student.age = 32; //报错:The field private1.age is not visible
  10. // student.setAge(32);
  11. student.show();
  12. }
  13. }

测试记录:

  1. [name:杜兰特] [age:32]

3.2 this关键字的概述和使用

this:代表所在类的对象引用,方法被哪个对象调用,this就代表那个对象;

什么时候使用this呢?
局部变量和成员变量重名。

this1类:

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-23
  6. * @remark this关键字的使用
  7. */
  8. public class this1 {
  9. private String name;
  10. private int age;
  11. public String getName() {
  12. return name;
  13. }
  14. public void setName(String name) {
  15. this.name = name;
  16. }
  17. public int getAge() {
  18. return age;
  19. }
  20. public void setAge(int age) {
  21. this.age = age;
  22. }
  23. }

this2类:

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-23
  6. * @remark this关键字的使用
  7. */
  8. public class this2 {
  9. public static void main(String[] args) {
  10. //创建对象
  11. this1 student = new this1();
  12. student.setName("杜兰特");
  13. student.setAge(32);
  14. System.out.println(student.getName() + "---" + student.getAge());
  15. }
  16. }

测试记录:

  1. 杜兰特---32

四.面向对象之构造方法

4.1 构造方法的概述和使用

4.1.1 构造方法作用概述

给对象的数据进行初始化

4.1.2 给对象的数据进行初始化

方法名与类名相同
没有返回值,连void都没有
没有具体返回值

代码:
gouzao1

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-23
  6. * @remark 面向对象之构造方法
  7. *
  8. */
  9. public class gouzao1 {
  10. private String name;
  11. public gouzao1() {
  12. System.out.println("这是构造方法");
  13. }
  14. public gouzao1(String name) {
  15. this.name = name;
  16. System.out.println("这是带参构造方法");
  17. }
  18. }

gouzao2

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-23
  6. * @remark 面向对象之构造方法
  7. *
  8. */
  9. public class gouzao2 {
  10. public static void main(String[] args) {
  11. //如何调用构造方法呢?
  12. //通过new关键字调用
  13. //无参格式: 类名 对象名 = new 构造方法(...);
  14. gouzao1 student1 = new gouzao1();
  15. //带参格式: 类型 对象名 = new 构造方法(参数1,参数2,...)
  16. gouzao1 student2 = new gouzao1("张三");
  17. }
  18. }

测试记录:

  1. 这是构造方法
  2. 这是带参构造方法

4.2 构造方法的注意事项

如果你不提供构造方法,系统会给出默认构造方法.
如果你提供了构造方法,系统将不再提供.
构造方法也是可以重载的,重载条件和普通方法相同.

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/115209147
上一篇:方法

相关文章