Java基础教程

文章36 |   阅读 18614 |   点赞0

来源：https://blog.csdn.net/u010520724/category_11240199.html

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

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

一.面向对象概述

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

测试记录:

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

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

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

代码:

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

三.private、this关键字

3.1 private关键字的概述和特点

private关键字：

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

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

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

测试记录:

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

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

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

测试记录:

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

3.2 this关键字的概述和使用

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

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

this1类:

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

this2类:

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

测试记录:

  1. 杜兰特---32

四.面向对象之构造方法

4.1 构造方法的概述和使用

4.1.1 构造方法作用概述

给对象的数据进行初始化

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

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

代码:
gouzao1

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

gouzao2

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

测试记录:

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

4.2 构造方法的注意事项

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

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/115209147

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/u010520724/article/details/119737466

内容来源于网络，如有侵权，请联系作者删除！

上一篇：方法
Javajava面向对象java构造方法

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com