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

目录

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

一、面向对象概述

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 stub
		Book book = new Book();//创建Book对象
		int x = 30;//定义实参变量x
		int y = 40;//定义实参变量y
		System.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 stub
		RefTest2 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;//情况1
    i[1] = 200;//情况2
    i[2] = 300;//情况3
	}

}

 运行结果：

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

代码如下：

package d6z;

public class MultiTest {//创建类

	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		MultiTest 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) {// 凝视。目标是参数target
		System.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 stub
		Leopard 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 stub
		new 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 stub
		TransferProperty 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";//声明name
	public void showName(String name) {//主方法
		System.out.println(name);//输出name
	}
	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		Book3 book = new Book3();//赋值
		book.showName("123");//输出信息
	}

}

运行结果：

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

代码如下：

package d6z;

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

 运行结果：

 

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

代码如下：

package d6z;

public class EggCake {//创建类
	int eggCount;// 鸡蛋灌饼里有几个蛋
	 
	// 有参数构造方法，参数是给饼加蛋的个数
	public EggCake(int eggCount) {//方法
		this.eggCount = eggCount;//设置eggCount
		System.out.println("这个鸡蛋灌饼里有" + eggCount + "个蛋。");//输出信息
	}
 
	// 无参数构造方法，默认给饼加一个蛋
	public EggCake() {//创建类
		this(1);//设置
	}
	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		EggCake 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 stub
		Pool 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;//将类成员对象赋值为x
		this.y = y;//将类成员对象赋值为y
	}
	public static void main(String[] args) {//主方法
		// TODO Auto-generated method stub
		StaticVariable 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;//将类成员变量赋值为radius
		this.area = area;//将类成员变量赋值为area
		System.out.println("圆的半径是：" + radius + ",圆的面积是：" + area);
		//输出结果
	}
}
class Spherical {//创建类
	double radius;// 半径
	double volume;// 体积
	public Spherical(double radius, double volume) {//方法
		this.radius = radius;//将类成员变量赋值为radius
		this.volume = volume;//将类成员变量赋值为volume
		System.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 stub
		StaticMethod.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 stub
		StaticTest 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 stub
		for (int i = 0; i < args.length; i++) { // 根据参数个数做循环操作
			System.out.println(args[i]); // 循环打印参数内容
		}

	}
}

运行结果：

五、小结 

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

THE END!