【Java】面向对象编程基础

参考书籍资料：《零基础学Java》——明日科技 编著

代码编辑器：Eclipse

1. 面向对象概述

1.1 对象

对象（Object）是一个抽象概念，表示任意存在的事物。世间万物皆对象！

通常将对象划分为两个部分，即静态部分和动态部分。静态部分即客观存在的特性，称为属性，动态部分即对象所能执行的动作，称为方法。

1.2 类

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

Java 语言中，类包括对象的属性和方法。类中对象的属性是以成员变量的形式定义的，对象的行为是以方法的形式定义的。

1.3 面向对象程序设计的特点

面向对象程序设计共有三个特点：

1. 封装性
2. 继承性
3. 多态性

1.3.1 封装

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

采用封装的思想保证了类内部数据结构的完整性，使用该类的用户不能轻易地直接操作此数据类型，只能操作类允许公开的数据。这样就避免了外部操作对内部数据的影响，提高了程序的可维护性。

1.3.2 继承

继承是实现重复利用的手段，子类通过继承，复用父类属性和行为的同时又添加了子类特有的属性和行为。

1.3.3 多态

将父类对象应用于子类的特征就是多态。

2. 类与对象

在 Java 语言中，对象的属性以成员变量的形式存在，对象的方法以成员方法的形式存在。

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

class ClassName{
    //类的成员变量
    //类的成员方法
}

2.1 成员变量

这里，为了了解成员变量，先给出一个类——Bird类：

public class Bird{
    String wing;		//翅膀
    String claw;		//爪子
    String beak;		//喙
    String feather;		//羽毛
}

定义成员变量的方法与定义普通变量的方法一样，可以选择默认初始化，也可以不为其赋值。

2.2 成员方法

成员方法对应于类对象的行为，它主要用来定义类可执行的操作，它是包含一系列语句的代码块。

2.2.1 成员方法的定义

定义成员方法的语法格式：

[权限修饰符] [返回值类型] 方法名([参数类型 参数名]) [throws 异常类型]{
    ...//方法体
    return 返回值;
}

其中，权限修饰符可以是private，public，protected中的任意一个，也可以不写（不指定则只能在本类及同一个包中的类中进行访问），主要用来控制方法的访问权限；返回值类型用来指定方法返回数据的类型，可以是任何类型，如果方法不需要返回值，则使用void关键字；一个成员方法既可以有参数，也可以没有参数，参数可以是对象，也可以是基本数据类型的常量。

如果定义的方法有返回值，则必须使用return关键字返回一个指定类型的数据，并且返回值类型要与方法返回值的类型一致。

2.2.2 成员方法的参数

调用方法时可以给该方法传递一个或多个值，传给方法的值叫作实参，在方法内部，接收实参的变量叫作形参，形参的声明语法与变量的声明语法一样。形参只在方法内部有效。Java 中的方法参数主要有三种，分别为值参数、引用参数、不定长参数。

（1）值参数

当使用只参数的方法被调用时，编译器为形参分配存储单元，然后将对应的实参的值复制到形参中，由于是值类型的传递方式，所以，在方法中对值类型的形参的修改并不会影响实参。

下面给出一个例子：

public class MemberVariables {
	public static void main(String[] args) {
		MemberVariables test = new MemberVariables();	//创建对象
		int x = 10, y = 11;
		System.out.println(x + " " + y);
		test.swap(x, y);		//调用成员方法
		System.out.println(x + " " + y);
	}
	//定义一个交换两个数字的值的方法
	public void swap(int a, int b) {
		int swap = a;
		a = b;
		b = swap;
	}
}

运行之后，输出结果：

10 11
10 11

说明swap方法并没有改变x和y的值，因为我们定义的方法参数是值参数。

（2）引用参数

如果在给方法传递参数时，参数的类型是数组或者其他引用类型，那么，在方法中对参数的修改会反映到原有的数组或者其他引用类型上，这种类型的方法参数称之为引用参数。

下面给出一个例子：

public class MemberVariables {
	public static void main(String[] args) {
		MemberVariables test = new MemberVariables();	//创建对象
		int[] x = {10}, y = {11};		//这里 x, y 都是数组类型
		System.out.println(x[0] + " " + y[0]);
		test.swap(x, y);		//注意这里传入的是数组名，调用成员方法
		System.out.println(x[0] + " " + y[0]);
	}
	//定义一个交换两个数字的值的方法
	public void swap(int[] a, int[] b) {//使用的是引用参数
		int swap = a[0];
		a[0] = b[0];
		b[0] = swap;
	}
}

运行之后，输出结果：

10 11
11 10

说明这里的swap方法改变了x[0]和y[0]的值，因为我们定义的方法参数是引用参数。

（3）不定长参数

声明方法时，如果有若干个相同类型的参数，可以定义为不定长参数，该类型的参数声明如下：

权限修饰符 返回值类型 方法名(参数类型... 参数名)

参数类型后面紧跟着的是三个句点...，并不是省略号。

下面给出一个例子：

public class Computing {
	public static void main(String[] args) {
		Computing test = new Computing();	//创建对象
		int result = test.add(1, 3, 5, 7, 9, 11, 13, 15);//调用方法
		System.out.println(result);
	}
	//定义一个计算若干个数字的和的方法
	public int add(int... arr) {
		int result = 0;
		for(int i = 0; i < arr.length; i++) {
			result += arr[i];
		}
		return result;
	}
}

输出结果：

64

2.3 构造方法

类中除了成员方法之外，还存在一种特殊类型的方法，那就是构造方法。构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。每当类实例化一个对象时，类都会自动调用构造方法。

构造方法的特点如下：

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

构造方法的定义语法如下：

class Book{
    public Book(){		//构造方法，名称要与类名保持一致
        
    }
}

在构造方法中可以为成员变量复制，这样当实例化，一个本类的对象是相应的成员变量，也将被初始化，如果类中没有明确定义故的方法，则编译器会自动创建一个不带参数的默认构造方法。

除此之外，在类中定义构造方法时，还可以为其添加一个或者多个参数，即有参构造方法，语法如下：

class Book{
    public Book(int args){		//有参数构造方法。
        //对成员变量进行初始化
    }
}

注意：如果在类中定义的构造方法都是有参构造方法，则编译器不会为类自动生成一个默认的无参构造方法，当试图调用无参构造方法实例化一个对象时，编译器会报错。所以只有在类中没有定义任何构造方法时，编译器才会在该类中自动创建一个不带参数的构造方法。

这个比较好理解，就不再举例子了。

2.4 局部变量

如果在成员方法内定义一个变量，那么这个变量被称为局部变量。

局部变量在方法执行时被创建，在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译失误。

注意：类成员变量和成员方法可以统称为类成员。如果一个方法中含有与成员变量同名的局部变量，则方法中对这个变量的访问以局部变量的值为基准。

2.5 this 关键字

当类中的成员变量与成员方法中的参数重时，方法中如何使用成员变量呢？

在 Java 语言中规定使用this关键字来代表本类对象的引用，this关键字被隐式地用于引用对象的成员变量和方法。

先给出下面的例子：

public class Dog {
	String name;
	public Dog(String name) {//构造函数
		this.name = name;
	}
	public static void main(String[] args) {
		Dog myDog = new Dog("Le Le");
		System.out.println(myDog.name);
	}
}

运行之后，输出结果：

Le Le

下面解释this关键字与对象之间具有的关系。

事实上，this关键字引用的就是本类的一个对象，在局部变量或方法参数覆盖了成员变量时，如上面代码的情况就要添加this关键字明确引用的是类成员还是局部变量或方法参数。

如果省略this关键字直接写成name = name，那只是把参数name赋值给参数变量本身而已，成员变量name的值其实并没有改变，因为参数name在方法的作用域中覆盖了成员变量name。

其实this关键字除了可以调用成员变量和成员方法之外，还可以作为方法的返回值。

例如：

public class Book{
    public Book getBook(){
        return this;		//返回 book 类引用
    }
}

this关键字除了可以调用类的成员变量和成员方法之外，还可以调用类中的构造方法。

例如：

//创建一个鸡蛋灌饼类，并创建有参数和无参数构造方法
public class EggCake {
	int eggCount;	//属性：鸡蛋灌饼里鸡蛋的个数
	//创建有参数构造方法
	public EggCake(int eggCount) {
		this.eggCount = eggCount;
	}
	//创建无参数构造方法
	public EggCake() {
		//调用上面的有参构造方法
		this(1);	//设置蛋的个数为1
        //注意：上一行中，this(1)前面不准出现其他代码
	}
	public static void main(String[] args) {
		EggCake cake1 = new EggCake();	//调用无参构造方法
		EggCake cake2 = new EggCake(5);	//调用有参构造方法，传入参数5
		System.out.println("第1个鸡蛋灌饼中蛋的个数为" + cake1.eggCount);
		System.out.println("第2个鸡蛋灌饼中蛋的个数为" + cake2.eggCount);
	}
}

运行之后，输出结果：

第1个鸡蛋灌饼中蛋的个数为1
第2个鸡蛋灌饼中蛋的个数为5

3. static 关键字

由static修饰的变量、常量和方法被称作静态变量、静态常量和静态方法，也被称作类的静态成员。

3.1 静态变量

很多时候，不同的类之间需要对同一个变量进行操作，比如一个水池同时打开入水口和出水口，进水和出水这两个动作会同时影响水池中的水量，此时水池中的水量就可以认为是一个共享的变量。在 Java 程序中，如果把共享的变量用static修饰，那么该变量就是静态变量。

调用静态变量的语法如下：

类名.静态类成员

这里就要注意和普通变量的区别，普通变量是对象.类成员变量。

3.2 静态方法

如果想要使用类中的成员方法，需要先将这个类进行实例化，但有些时候不想或者无法创建类的对象的时，还要调用类中的方法才能完成业务逻辑，这种情况下就可以使用静态方法（简言之，静态方法在不创建对象的情况下也可以调用）。

调用类的静态方法语法如下：

类名.静态方法();

例子：

public class Pool {
	public static int water = 0;	//初始化静态变量
	public static void outlet() {	//创建放水的静态方法
		if(water >= 2) {
			water -= 2;
		}else {
			water = 0;
		}
	}
	public static void inlet() {	//创建注水的静态方法
		water += 3;
	}
	public static void main(String[] args) {
		System.out.println("初始时，水池的水量：" + Pool.water);	//输出当前水量
		System.out.print("注水两次后，");
		Pool.inlet();
		Pool.inlet();
		System.out.println("水池的水量：" + Pool.water);	//输出当前水量
		System.out.print("放水一次后，");
		Pool.outlet();
		System.out.println("水池的水量：" + Pool.water);	//输出当前水量
	}

}

3.3 静态代码块

在类的成员方法之外，用static修饰代码区域可以称之为静态代码块。定义一块静态代码块。定义一块静态代码块，可以完成类的初始化操作，在类声明时就会运行。

语法如下：

public calss StaticTest {
    static {
        	//此处编辑执行语句
    }
}

下面给出一个程序来查看代码调用顺序：

public class StaticTest {
	static String name;
	{
		System.out.println(name + "非静态代码块");
	}
	static {
		System.out.println(name + "静态代码块");
	}
	public StaticTest(String a) {
		name = a;
		System.out.println(name + "构造方法");
	}
	public void method() {
		System.out.println(name + "成员方法");
	}
	public static void main(String[] args) {
		StaticTest test1;	//语句1
        //声明的时候就已经运行静态代码块了
        
		StaticTest test2 = new StaticTest("test2");	//语句2
        //new 的时候才会运行构造方法和非静态代码块
        
		test2.method();	//语句3
        //成员方法只有调用的时候才会运行
	}

}

运行之后，输出结果：

//只执行语句1，输出：
null静态代码块

//只执行语句2，输出：
null非静态代码块
test2构造方法

//只执行语句3，输出：
test2成员方法

4. 类的主方法

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

主方法语法如下：

public static void main(String[] args){
    //方法体
}

在主方法的定义中可以看到主方法有以下特性：

• 主方法是静态的，所以如要直接在主方法中调用其他方法，则该方法必须也是静态的。
• 主方法没有返回值
• 主方法的形参为数组。其中args[0]~args[n]分别代表程序的第 1 个参数到第 n+1 个参数，可以使用args.length获取参数的个数。

下面介绍在命令行中执行.java文件的方法：

先给出一个TestMain.java文件：

import java.util.Scanner;

public class TestMain {
	public static void main(String[] args) {
		System.out.println("Please enter the username: ");
		Scanner sc = new Scanner(System.in);
		String name = sc.nextLine();
		System.out.println("Please enter the password: ");
		String password = sc.nextLine();
		if(name.equals(args[0]) && password.equals(args[1])) {
            //用户名和密码正确才执行这个语句
			System.out.println("Start to perform...");
		}else {
            //否则，执行下面的语句
			System.out.println("You don't have permission to run the program.");
		}
		sc.close();
	}
}

打开cmd，来到该.java文件所在目录，然后依次执行以下命令：

javac TestMain.java
java TestMain Alice 123456

第一行命令执行完毕后，当前文件夹便会出现一个TestMain.class文件。

第二行命令便是执行这个.class文件，后面的Alice 123456是传给main函数的两个参数，即设定用户名为Alice，密码为123456，但要注意不能带.class后缀。

下面是运行过程：

---

Java 面向对象编程基础部分的内容到这里就结束了。

下一篇：【Java】面向对象核心技术

链接指路：
上一篇：【Java】字符串