面向过程与面向对象的区别

一、面向对象概述

1、对象

2、类

3、面向对象程序设计的特点

（1）、封装

（2）、继承

（3）、多态

二、类与对象

1、成员变量

2、成员方法

3、构造方法

4、局部变量

5、局部变量的有效范围

6、对象的创建

7、访问对象的属性和行为

8、对象的销毁

9、this关键字

三、static 关键字

1、静态变量

2、静态常量

3、静态方法

4、静态代码块

四、类的主方法

五、小结

面向过程与面向对象的区别

面向过程是直接将解决问题的步骤分析出来，然后用函数把步骤一步一步实现，然后再依次调用就可以了；而面向对象是将构成问题的事物，分解成若干个对象，建立对象的目的不是为了完成一个步骤，而是为了描述某个事物在解决问题过程中的行为。

面向过程思想偏向于我们做一件事的流程，首先做什么，其次做什么，最后做什么。

面向对象思想偏向于了解一个人，这个人的性格、特长是怎么样的，有没有遗传到什么能力，有没有家族病史。

一、面向对象概述

1、对象

通常都会将对象分为两个部分：既静态部分和动态部分。

静态部分，顾名思义，就是不能动的部分，这个部分被称之为“属性”，任何对象都具备其自身属性，如一个人，其属性包括高矮、胖瘦、性别、年龄等。然而具有这些属性的人会执行哪些动作也是一个值得探讨的部分，这个人可以哭泣、微笑、说话、行走，这些是这个人具备的行为（动态部分），人类通过探讨对象的属性和观察对象的行为了解对象。

2、类

不能将所谓的一个事物描述成一类事物，有一只鸟不能称为鸟类，如果需要对同一类事物统称，就不得不说明类这个概念.

类是封装对象属性和行为的载体。反过来说，具有相同属性和行为的一类实体被称为类。

3、面向对象程序设计的特点

面向对象程序设计具有以下特点:封装性。继承性。多态性。

（1）、封装

封装是面向对象编程的核心思想。将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想。

（2）、继承

类与类之间同样具有关系，如一个百货公司类与销售员类相联系，类之间的这种关系被称为关联。

（3）、多态

上面介绍了继承，了解了父类和子类，其实将父类对象应用于子类的特征就是多态，多态的实现并不依赖具体类，而是依赖于抽象类和接口。

二、类与对象

java中定义类使用class关键字，语法如下：

class 类名称{

//类的成员变量

//类的成员方法

}

1、成员变量

在Java中对象的属性也称为成员变量，成员变量的定义与普通变量的定义一样，语法如下：

数据类型变量名称 [ =值] ；

2、成员方法

定义成员方法的语法格式如下：
[权限修饰符][返回值类型]方法名([参数类型参数名])[throws 异常类型]{
…//方法体
return 返回值;

定义一个add方法，用来计算两个数的和，该方法中有两个形参，但在方法体中，对其中的一个形参x执行加y操作，并返回x;在main方法中调用该方法，为该方法传入定义好的实参;最后分别显示调用 add 方法计算之后的x值和实参x的值。
代码如下：

package d6z;public class Book {//创建类public static void main(String[] args) {//主方法// TODO Auto-generated method stubBook book = new Book();//创建Book对象int x = 30;//定义实参变量xint y = 40;//定义实参变量ySystem.out.println("运算结果:" + book.add(x, y));//输出运算结果System.out.println("实参x的值:" + x);//输出实参x的值}private int add(int x,int y)//计算两个数的和{x = x + y;//对x进行加y操作return x;//返回x}}

运行结果：

定义一个change方法，该方法中有一个形参，类型为数组类型，在方法体中，改变数组的索引0、1、2这3处的值;在main方法中定义一个一维数组并初始化，然后将该数组作为参数传递给 change 方法，最后输出一维数组的元素。

代码如下：

package d6z;public class RefTest2 {//创建类public static void main(String[] args) {//主方法// TODO Auto-generated method stubRefTest2 refTest = new RefTest2();//创建对象int[] i = { 0, 1, 2 }; //定义一维数组，作为方法的实参//输出一维数组的原始元素值System.out.print("原始数据：");//输出信息for (int j = 0; j < i.length; j++)//for循环{System.out.print(i[j]+" ");//输出信息}refTest.change(i);//调用方法改变数组元素的值System.out.print("\n修改后的数据：");//输出信息for (int j = 0; j < i.length; j++)//for循环{System.out.print(i[j]+" ");//输出信息}
}
//定义一个方法，方法的参数为一维数组（形参）
public void change(int [] i)
{i[0] = 100;//情况1i[1] = 200;//情况2i[2] = 300;//情况3}}

运行结果：

定义一个add方法,用来计算多个int类型数据的和，在具体定义时，将参数定义为int类型的不定长参数;在main方法中调用该方法，为该方法传入多个int类型的数据，并输出计算结果。

代码如下：

package d6z;public class MultiTest {//创建类public static void main(String[] args) {//主方法// TODO Auto-generated method stubMultiTest multi = new MultiTest();//创建MultiTest对象System.out.print("运算结果：" + multi.add(20, 30, 40, 50, 60));//输出结果}int add(int... x)//定义add方法，并指定不定长参数的类型为int{int result = 0;//记录运算结果for (int i = 0; i < x.length; i++)//遍历参数{result += x[i];//执行相加操作}return result;//返回运算结果}}

运行结果：

创建猎豹类，用成员方法实现猎豹的行为。

代码如下：

package d6z;public class Leopard {//创建类public void gaze(String target) {// 凝视。目标是参数targetSystem.out.println("猎豹凝视：" + target);//输出结果}public void run() {// 奔跑System.out.println("猎豹开始奔跑");//输出结果}public boolean catchPrey(String prey) {// 捕捉猎物，返回捕捉是否成功System.out.println("猎豹开始捕捉" + prey);//输出结果return true;// 返回成功}public void eat(String meat) {// 吃肉，参数是肉System.out.println("猎豹吃" + meat);//输出结果}public void sleep() {// 睡觉System.out.println("猎豹睡觉");//输出结果}public static void main(String[] args) {//主方法// TODO Auto-generated method stubLeopard liebao = new Leopard();//创建一个liebao对象，通过new实例化liebao.gaze("羚羊");//输出liebao.run();//输出liebao.catchPrey("羚羊");//输出liebao.eat("羚羊肉");//输出liebao.sleep();//输出}}

运行结果：

3、构造方法

构造方法的特点如下:
(1)构造方法没有返回类型，也不能定义为 void。
(2)构造方法的名称要与本类的名称相同。
(3)构造方法的主要作用是完成对象的初始化工作，它能把定义对象的参数传给对象成员。

创建一个图书类，将构造方法设为私有，这时如果需要创建图书类的对象，只能通过定义一个static方法，并调用该静态方法生成图书类的对象。

代码如下：

package d6z;public class BookTest {//创建类private BookTest() {//私有构造方法}//静态公开方法，向图书馆借书static public BookTest libraryBorrow(){//创建静态方法，返回本类实例对象System.out.println("通过调用静态方法创建对象");//输出结果return new BookTest();//返回新的BookTest_5}public static void main(String[] args) {// TODO Auto-generated method stub//创建一个书的对象，不是new实例化的，而是通过方法从图书馆借来的BookTest book = BookTest.libraryBorrow();}}

运行结果：

4、局部变量

如果在成员方法内定义一个变量，那么这个变量被称为局部变量。
局部变量在方法被执行时创建，在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误。

5、局部变量的有效范围

可以将局部变量的有效范围称为变量的作用域局部变量的有效范围从该变量的声明开始到该变量的结束为止。

6、对象的创建

对象可以认为是在一类事物中抽象出某一个特例，可以通过这个特例来处理这类事物出现的问题。在Java语言中通过new操作符来创建对象。前文在讲解构造法时介绍过，每实例化一个对象就会自动调用一次构造方法，实质上这个过程就是创建对象的过程准确地说，可以在Java 语言中使用 new 操作符调用构造方法创建对象。
语法如下:
Test test=new Test();
Test test=new Test("a"); y
Test:类名。test:创建 Test类对象。 new:创建对象操作符。 a:构造方法的参数。

test 对象被创建出来时，就是一个对象的引用，这个引用在内存中为对象分配了存储空间，

可以在构造方法中初始化成员变量，当创建对象时，自动调用构造方法，也就是说在 Java 语言中初始化与创建是被捆绑在一起的。

在项目中创建CreateObject类，在该类中创建对象并在主方法中创建对象。

代码如下：

package d6z;public class CreateObject {//创建类public CreateObject() { // 构造方法System.out.println("创建对象");//输出信息}public static void main(String[] args) {//主方法// TODO Auto-generated method stubnew CreateObject(); // 创建对象}}

运行结果：

7、访问对象的属性和行为

用户使用 new 操作符创建一个对象后，可以使用“对象.类成员”来获取对象的属性和行为。前文已经提到过，对象的属性和行为在类中是通过类成员变量和成员方法的形式来表示的，所以当对象获取类成员时，也相应地获取了对象的属性和行为。

在项目中创建TransferProperty类，在该类中说明对象是如何调用类成员的。
代码如下：

package d6z;public class TransferProperty {//创建类int i = 47; // 定义成员变量public void call() { // 定义成员方法System.out.println("调用call()方法");//输出信息for (i = 0; i < 3; i++) {//for循环System.out.print(i + " ");//输出信息if (i == 2) {//if语句System.out.println("\n");//换行}}}public TransferProperty() { // 定义构造方法}public static void main(String[] args) {//主方法// TODO Auto-generated method stubTransferProperty t1 = new TransferProperty(); // 创建一个对象TransferProperty t2 = new  TransferProperty(); // 创建另一个对象t2.i = 60; // 将类成员变量赋值为60// 使用第一个对象调用类成员变量System.out.println("第一个实例对象调用变量i的结果：" + t1.i);//输出信息t1.call(); // 使用第一个对象调用类成员方法// 使用第二个对象调用类成员变量System.out.println("第二个实例对象调用变量i的结果：" + t2.i);//输出信息t2.call(); // 使用第二个对象调用类成员方法}}

运行结果：

8、对象的销毁

每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址会被回收。在其他语言中需要手动回收废弃的对象，但是Java拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器将回收无用的但占用内存的资源。
在谈到垃圾回收机制之前，首先需要了解何种对象会被 Java 虚拟机视为垃圾。主要包括以下两种情况:
(1)对象引用超过其作用范围，这个对象将被视为垃圾。
(2)将对象赋值为null。

9、this关键字

创建Book3类，定义一个成员变量name并赋值，在定义一个成员方法showName(String name)，输出方法中name的值。

代码如下：

package d6z;public class Book3 {//创建类String name="abc";//声明namepublic void showName(String name) {//主方法System.out.println(name);//输出name}public static void main(String[] args) {//主方法// TODO Auto-generated method stubBook3 book = new Book3();//赋值book.showName("123");//输出信息}}

运行结果：

在Book4类的showName()方法中，使用this关键字。

代码如下：

package d6z;public class Book4 {//创建类String name = "abc";//声明namepublic void showName(String name) {//方法System.out.println(this.name);//输出信息}public static void main(String[] args) {//主方法// TODO Auto-generated method stubBook4 book = new Book4();//赋值book.showName("123");//输出信息}
}

运行结果：

我去买鸡蛋灌饼，我要求加几个蛋时，烙饼大妈就给饼加几个蛋，不要求的时候就只一个蛋。创建鸡蛋灌饼 EggCake类，创建有参数和无参数构造方法，无参数构造方法调用有参数实现初始化。

代码如下：

package d6z;public class EggCake {//创建类int eggCount;// 鸡蛋灌饼里有几个蛋// 有参数构造方法，参数是给饼加蛋的个数public EggCake(int eggCount) {//方法this.eggCount = eggCount;//设置eggCountSystem.out.println("这个鸡蛋灌饼里有" + eggCount + "个蛋。");//输出信息}// 无参数构造方法，默认给饼加一个蛋public EggCake() {//创建类this(1);//设置}public static void main(String[] args) {//主方法// TODO Auto-generated method stubEggCake cake1 = new EggCake();//输出信息并赋值EggCake cake2 = new EggCake(5);//输出信息并赋值}}

运行结果：

三、static 关键字

1、静态变量

很多时候，不同的类之间需要对同一个变量进行操作，比如一个水池，同时打开入水口和出水，进水和出水这两个动作会同时影响到池中的水量，此时池中的水量就可以认为是一个共享的变量。在Java 程序中，把共享的变量用 static 修饰，该变量就是静态变量。
可以在本类或其他类使用类名和“.”运算符调用静态变量。
语法如下:

类名.静态类成员

创建一个水池类，创建注水方法和放水方法，同时控制水池中的水量。

代码如下：

package d6z;public class Pool {//创建类static public int water = 0;//定义初始值public void outlet() {// 放水，一次放出2个单位if (water >= 2) {//if语句water = water - 2;//定义water的值} else {water = 0;//初始值}}public void inlet() {// 注水，一次注入3个单位water = water + 3;//定义water的值}public static void main(String[] args) {//主方法// TODO Auto-generated method stubPool out = new Pool();//创建一个对象Pool in = new Pool();//创建另一个对象System.out.println("水池的水量：" + Pool.water);//输出结果System.out.println("水池注水两次。");//输出结果in.inlet();//放水1次in.inlet();//放水2次System.out.println("水池的水量：" + Pool.water);//输出结果System.out.println("水池放水一次。");//输出结果out.outlet();//出水1次System.out.println("水池的水量：" + Pool.water);//输出结果}}

运行结果：

创建StaticVariable类，包含一个静态成员变量和普通成员变量，在构造方法中给两个变量赋初值，然后分别实例化两个不同的对象。

代码如下：

package d6z;public class StaticVariable {//创建类static int x;// 静态变量int y;// 普通成员变量public StaticVariable(int x, int y) {// 构造函数this.x = x;//将类成员对象赋值为xthis.y = y;//将类成员对象赋值为y}public static void main(String[] args) {//主方法// TODO Auto-generated method stubStaticVariable a = new StaticVariable(1, 2);//创建一个对象StaticVariable b = new StaticVariable(13, 17);//创建另一个对象System.out.println("a.x的值是 = " + a.x);//输出结果System.out.println("a.y的值是 = " + a.y);//输出结果System.out.println("b.x的值是 = " + b.x);//输出结果System.out.println("b.y的值是 = " + b.y);//输出结果}}

运行结果：

2、静态常量

有时，在处理问题时会需要两个类共享一个数据常量。例如，在球类中使用PI这个常量，可能除了本类需要这个常量之外，在另外一个圆类中也需要使用这个常量。这时没有必要在两个类中同对创建PI这个常量，因为这样系统会将这两个不在同一个类中的常量分配到不同的内存空间中，浪了系统资源。为了解决这个问题，可以将这个常量设置为静态的。PI常量在内存中被共享的布局。

将π的值赋给静态常量PI，使用PI计算圆类的面积和球类的体积。
代码如下：

package d6z;public class Graphical {//创建类final static double PI = 3.1415926;// 创建静态常量πpublic static void main(String[] args) {//主方法double radius = 3.0;// 半径double area = Graphical.PI * radius * radius;// 计算面积double volume = 4 / 3 * Graphical.PI * radius * radius * radius;// 计算体积Circular yuan = new Circular(radius, area);//创建一个对象Spherical qiu = new Spherical(radius, volume);//创建另一个对象}
}
class Circular {//创建类double radius;// 半径double area;// 面积public Circular(double radius, double area) {//方法this.radius = radius;//将类成员变量赋值为radiusthis.area = area;//将类成员变量赋值为areaSystem.out.println("圆的半径是：" + radius + ",圆的面积是：" + area);//输出结果}
}
class Spherical {//创建类double radius;// 半径double volume;// 体积public Spherical(double radius, double volume) {//方法this.radius = radius;//将类成员变量赋值为radiusthis.volume = volume;//将类成员变量赋值为volumeSystem.out.println("球的半径是：" + radius + ",球的体积是：" + volume);//输出结果}
}

运行结果：

3、静态方法

如果想要使用类中的成员方法，需要先将这个类进行实例化，但有些时候不想或者无法创建类的对象时，还要调用类中的方法才能够完成业务逻辑，此时就可以使用静态方法。调用类的静态方法，无需创建类的对象。
语法如下:
类名.静态方法（）

不创建类对象，直接使用静态方法。

代码如下：

package d6z;public class StaticMethod {//创建类static public void show() {//定义静态方法System.out.println("静态方法无需实例化就可以调用");//输出结果}public static void main(String[] args) {//主方法// TODO Auto-generated method stubStaticMethod.show();//使用类名调用静态方法}}

运行结果：

4、静态代码块

在类中除成员方法之外，用static 修饰代码区域可以称之为静态代码块。定义一块静态代码块,可以完成类的初始化操作，在类声明时就会运行。
语法如下:
public class StaticTest { static {
//此处编辑执行语句
}}

创建静态代码块、非静态代码块、构造方法、成员方法，查看这几处代码的调用顺序。
代码如下：

package d6z;public class StaticTest {//创建类static String name;//声明//静态代码块static {System.out.println(name + "静态代码块");//输出结果}//非静态代码块{System.out.println(name+"非静态代码块");//输出结果}public StaticTest(String a) {//创建类name = a;//定义name的值System.out.println(name + "构造方法");//输出结果}public void method() {//创建类System.out.println(name + "成员方法");//输出结果}public static void main(String[] args) {//主方法// TODO Auto-generated method stubStaticTest s1;// 声明的时候就已经运行静态代码块了StaticTest s2 = new StaticTest("s2");// new的时候才会运行构造方法StaticTest s3 = new StaticTest("s3");//new的时候才会运行构造方法s3.method();//只有调用的时候才会运行}}

运行结果：

四、类的主方法

主方法是类的入口点，它定义了程序从何处开始住方法提供对程序流向的控制，Java编译器通过主方法来执行程序。

在项目中创建TestMain类，在主方法中编写以下代码，并在Eclipse中设置程序参数

代码如下：

package d6z;public class TestMain {//创建类public static void main(String[] args) {//主方法// TODO Auto-generated method stubfor (int i = 0; i < args.length; i++) { // 根据参数个数做循环操作System.out.println(args[i]); // 循环打印参数内容}}
}

运行结果：

五、小结

本章学习了面向对象的概念、类的定义、成员方法、类的构造方法、主方法以及对象的应用通过对本章的学习，读者应该掌握面向对象的编程思想，这对 Java 的学习十分有帮助，同时此基础上读者可以编写类，定义类成员、构造方法、主方法以解决一些实际问题。由于在 Javal过对象来处理问题，所以对象的创建、比较、销毁的应用就显得非常重要。初学者应该反复揣摩这些基本概念和面向对象的编程思想，为 Java 语言的学习打下坚实的基础。

THE END!

第六章面向对象编程基础总结相关推荐

Java基础学习——第六章面向对象编程(下)
Java基础学习--第六章面向对象编程(下) 一.关键词:static 1. static关键字的引入当我们编写一个类时,其实就是在描述其对象的属性和行为,而并没有产生实质上的对象,只有通过new ...
Java基础编程\第四-六章(面向对象编程)
Java面向对象学习的三条主线: (第4-6章) 文章目录面向对象的举例属性(成员变量)和局部变量类中方法的声明和使用 Train(圆面积) ==Train(对象数组)== ==对象数组的内存解 ...
kmeans python interation flag_Python自学笔记-第六章面向对象编程（下）
3.魔法方法 Python的对象天生拥有一些神奇的方法,它们总被双下划线所包围,他们是面向对象的 Python 的一切.他们是可以给你的类增加魔力的特殊方法,如果你的对象实现(重载)了这些方法中的某一 ...
Java基础-第7章-面向对象编程(基础部分)
文章目录 7.1 类与对象 7.1.1看一个养猫猫问题 7.1.2使用现有技术解决 7.1.3现有技术解决的缺点分析 7.1.4 一个程序就是一个世界,有很多事物(对象[属性, 行为]) 7.1.5 ...
《编程机制探析》第六章面向对象
<编程机制探析>第六章面向对象面向对象(Object Oriented)是命令式编程的主流编程模型,其概念极其重要.可以说,命令式编程几乎就是面向对象的天下. 面向对象(Object ...
非零基础自学Java (老师：韩顺平) 第10章面向对象编程(高级部分) 10.6 抽象类
非零基础自学Java (老师:韩顺平) ✈[[零基础快速学Java]韩顺平零基础30天学会Java] 第10章面向对象编程(高级部分) 文章目录非零基础自学Java (老师:韩顺平) 第10章 ...
java面向对象编程基础
java面向对象编程基础前言:什么是java 是咖啡飘香的清晨 - 是斯坦福校园意浓情深 - 是James的思想睿智是剁手党双十一挥舞的利刃是大数据云计算驰骋的平台 - 是ATM上吐出的钞票 - ...
Day08 - 面向对象编程基础
面向对象编程基础活在当下的程序员应该都听过"面向对象编程"一词,也经常有人问能不能用一句话解释下什么是"面向对象编程",我们先来看看比较正式的说法. 把一组数 ...
java 168转换成861_java实验-java语言面向对象编程基础
java实验-java语言面向对象编程基础 (12页) 本资源提供全文预览,点击全文预览即可全文预览,如果喜欢文档就下载吧,查找使用更方便哦! 8.90 积分广州大学学生实验报告广州大学学生实验报告 ...

第六章面向对象编程基础总结

面向过程与面向对象的区别

一、面向对象概述

1、对象

2、类

3、面向对象程序设计的特点

（1）、封装

（2）、继承

（3）、多态

二、类与对象

1、成员变量

2、成员方法

3、构造方法

4、局部变量

5、局部变量的有效范围

6、对象的创建

7、访问对象的属性和行为

8、对象的销毁

9、this关键字

三、static 关键字

1、静态变量

2、静态常量

3、静态方法

4、静态代码块

四、类的主方法

五、小结

第六章面向对象编程基础总结相关推荐

最新文章

热门文章

第六章 面向对象编程基础总结

面向过程与面向对象的区别

一、面向对象概述

1、对象

2、类

3、面向对象程序设计的特点

（1）、封装

（2）、继承

（3）、多态

二、类与对象

1、成员变量

2、成员方法

3、构造方法

4、局部变量

5、局部变量的有效范围

6、对象的创建

7、访问对象的属性和行为

8、对象的销毁

9、this关键字

三、static 关键字

1、静态变量

2、静态常量

3、静态方法

4、静态代码块

四、类的主方法

五、小结

第六章 面向对象编程基础总结相关推荐

最新文章

热门文章

第六章面向对象编程基础总结

第六章面向对象编程基础总结相关推荐