文章36 | 阅读 16076 | 点赞0
我们回想一下，前面我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。
在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。
那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
面向过程的代表语言：C语言.
当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的用一个类封装在一起，这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。
什么是面向过程？
面向过程，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
例如:吃煎饼果子利用面向过程的思想:
1.学习摊煎饼的技术
2.买材料鸡蛋,油,葱等等
3.开始摊
4.吃
5.收拾
什么是面向对象?
面向对象思想就是不断的创建对象，使用对象，指挥对象做事情。（如果有对象，直接用对象，对我们直接提供服务）
例如:吃煎饼果子利用面向对象的思想:
1.找会摊煎饼的大妈(创建一个摊煎饼大妈的对象)
2.调用其摊煎饼的技能(功能),传递进去钱参数
3.返回给我们一个煎饼
4.吃
面向过程的特点:
面向对象的特点:
我们学习编程是为了什么：
1)为了把我们日常生活中实物用学习语言描述出来
我们如何描述现实世界事物:
1)属性 就是该事物的描述信息(事物身上的名词)
2)行为 就是该事物能够做什么(事物身上的动词)
Java中最基本的单位是类,Java中用class描述事物也是如此：
1)成员变量 就是事物的属性
2)成员方法 就是事物的行为
定义类其实就是定义类的成员(成员变量和成员方法):
1)成员变量 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
2)成员方法 和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
类和对象的概念：
1)类：是一组相关的属性和行为的集合（我们班所有的同学都具备相同的属性和行为，比如：姓名，年龄，学习，这样就把所有的学生成为学生类）
2)对象：是该类事物的具体体现（说某个同学时，他都具备自己特有的属性和行为）
3)举例：
类 学生
对象 具体的某个学生就是一个对象
4)比如：车是一个类，具体的开的奔驰、宝马，就是对象
代码:
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-23
* @remark 学生类 案例
*
* 需求：定义一个学生类。
*
* 学生事物：
* 属性：姓名，年龄...
* 行为：学习，吃饭...
*
* 学生类：
* 成员变量：姓名，年龄...
* 成员方法：学习，吃饭...
*
*/
public class student {
/*成员变量*/
//姓名
String name;
//年龄
int age;
/*成员方法*/
//学习的方法
public void study() {
System.out.println(name + " 好好学习，天天向上");
}
//吃饭的方法
public void eat() {
System.out.println(name + " 学习饿了要吃饭");
}
public static void main(String[] args) {
//类型 对象名 = new 类名()
student student1 = new student();
// 给成员变量赋值
student1.name = "杜兰特";
student1.age = 32;
System.out.println("姓名:" + student1.name);
System.out.println("年龄:" + student1.age);
//调用成员方法
student1.study();
student1.eat();
}
}测试记录:
姓名:杜兰特
年龄:32
杜兰特 好好学习，天天向上
杜兰特学习饿了要吃饭直接用代码来介绍成员变量和局部变量。
代码:
package Java_study;
/**
* @author 只是甲
* @date 2021-06-23
* @remark 成员变量和局部变量区别
*
* 成员变量和局部变量的区别：
* A:在类中的位置不同
* 成员变量：在类中，方法外
* 局部变量：在方法中或者方法声明上(形式参数)
* B:在内存中的位置不同
* 成员变量：在堆内存
* 局部变量：在栈内存
* C:生命周期不同
* 成员变量：随着对象的创建而存在，随着对象的消失而消失
* 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
* D:初始化值不同
* 成员变量：有默认值
* 局部变量：没有默认值，必须先定义，赋值，最后使用
*/
public class chengyuanbianliang1 {
/*成员变量*/
int x;
public void show() {
// 局部变量
int y = 10;
System.out.println(x);
System.out.println(y);
}
}private关键字：
代码1:
当前class中可以访问private的变量
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-23
* @remark 学生类 private关键字的概述和特点
*
* 直接使用对象名访问成员变量，会存在数据的安全问题
* 这个时候，我们就应该思考能不能让外界不要直接访问成员变量? 能
* 如何实现呢? 用private关键字
* private:
* 是一个修饰符
* 可以修饰成员变量，也可以修饰成员方法
* 被private修饰的成员只能在本类中被访问
*
* 针对被private修饰的成员变量，我们会相应的给出getXxx()和setXxx()用于获取和设置成员变量的值，
* 方法用public修饰
*
*/
public class private1 {
String name;
private int age;
public int getAge() {
return age;
}
public void setAge(int a) {
if (a < 0 || a > 200) {
System.out.println("输入年龄有误");
} else {
age = a;
}
}
public void show() {
System.out.println("[name:" + name + "] [age:" + age + "]");
}
// private 定义的变量，在本类中可以访问和赋值
public static void main(String[] args) {
// 创建对象
private1 student = new private1();
//给成员变量赋值
student.name = "杜兰特";
student.age = 32;
student.show();
}
}测试记录:
[name:杜兰特] [age:32]代码2:
其它class中不可以访问private的变量，需要通过主类的方法来修改。
package Java_study;
public class private2 {
// 调用private1的方法和属性
public static void main(String[] args) {
//创建对象
private1 student = new private1();
//给成员变量赋值
student.name = "杜兰特";
//student.age = 32; //报错:The field private1.age is not visible
// student.setAge(32);
student.show();
}
}测试记录:
[name:杜兰特] [age:32]this:代表所在类的对象引用，方法被哪个对象调用，this就代表那个对象；
什么时候使用this呢?
局部变量和成员变量重名。
this1类:
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-23
* @remark this关键字的使用
*/
public class this1 {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}this2类:
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-23
* @remark this关键字的使用
*/
public class this2 {
public static void main(String[] args) {
//创建对象
this1 student = new this1();
student.setName("杜兰特");
student.setAge(32);
System.out.println(student.getName() + "---" + student.getAge());
}
}测试记录:
杜兰特---32给对象的数据进行初始化
方法名与类名相同
没有返回值，连void都没有
没有具体返回值
代码:
gouzao1
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-23
* @remark 面向对象之构造方法
*
*/
public class gouzao1 {
private String name;
public gouzao1() {
System.out.println("这是构造方法");
}
public gouzao1(String name) {
this.name = name;
System.out.println("这是带参构造方法");
}
}gouzao2
package Java_study;
/**
*
* @author 只是甲
* @date 2021-06-23
* @remark 面向对象之构造方法
*
*/
public class gouzao2 {
public static void main(String[] args) {
//如何调用构造方法呢?
//通过new关键字调用
//无参格式: 类名 对象名 = new 构造方法(...);
gouzao1 student1 = new gouzao1();
//带参格式: 类型 对象名 = new 构造方法(参数1,参数2,...)
gouzao1 student2 = new gouzao1("张三");
}
}测试记录:
这是构造方法
这是带参构造方法如果你不提供构造方法，系统会给出默认构造方法.
如果你提供了构造方法，系统将不再提供.
构造方法也是可以重载的,重载条件和普通方法相同.
版权说明 : 本文为转载文章, 版权归原作者所有 版权申明
原文链接 : https://blog.csdn.net/u010520724/article/details/119737466
内容来源于网络，如有侵权，请联系作者删除！