面向对象是Java最重要的特性。Java是彻底的、纯粹的面向对象语言,在Java中“一切都是对象”。本章将介绍面向对象基础知识。
1.面向对象概述
面向对象的编程思想:按照真实世界客观事物的自然规律进行分析,客观世界中存在什么样的实体,构建的软件系统就存在什么样的实体。
在现实世界有类和对象,面向对象软件世界也会有,只不过它们会以某种计算机语言编写的程序代码形式存在,这就是面向对象编程(Object Oriented Programming,OOP)。作为面向对象的计算机语言——Java,具有定义类和创建对象等面向对象能力。
2.面向对象三个基本特性
面向对象思想有三个基本特性:封装性、继承性和多态性。
2.1 封装性
在现实世界中封装的例子到处都是。例如:一台计算机内部极其复杂,有主板、CPU、硬盘和内存,而一般用户不需要了解它的内部细节,不需要知道主板的型号、CPU主频、硬盘和内存的大小,于是计算机制造商将用机箱把计算机封装起来,对外提供了一些接口,如鼠标、键盘和显示器等,这样当用户使用计算机就变非常方便。
那么,面向对象的封装与真实世界的目的是一样的。封装能够使外部访问者不能随意存取对象的内部数据,隐藏了对象的内部细节,只保留有限的对外接口。外部访问者不用关心对象的内部细节,使得操作对象变得简单。
2.2 继承性
在现实世界中继承也是无处不在。例如:轮船与客轮之间的关系,客轮是一种特殊轮船,拥有轮船的全部特征和行为,即数据和操作。在面向对象中轮船是一般类,客轮是特殊类,特殊类拥有一般类的全部数据和操作,称为特殊类继承一般类。在Java语言中一般类称为“父类”,特殊类称为“子类”。
提示:在有些语言如C++支持多继承,多继承就是一个子类可有多个父类,例如,客轮是轮船也是交通工具,客轮的父类是轮船和交通工具。多继承会引起很多冲突问题,因此现在很多面向对象的语言都不支持多继承。Java语言是单继承的,即只能有一个父类,但Java可以实现多个接口,可以防止多继承所引起的冲突问题。
2.3 多态性
多态性是指在父类中成员变量和成员方法被子类继承之后,可以具有不同的状态或表现行为。
3.类
类是Java中的一种重要的引用数据类型,是组成Java程序的基本要素。它封装了一类对象的数据和操作。
3.1 类声明
Java语言中一个类的实现包括:类声明和类体。类声明语法格式如下。
[public][abstract|final] class className [extends superclassName] [implements interfaceNameList] {
//类体
}
其中,class是声明类的关键字,className是自定义的类名;class前面的修饰符public、abstract、final用来声明类,它们可以省略;superclassName为父类名,可以省略,如果省略则该类继承Object类,Object类所有类的根类,所有类都直接或间接继承Object;interfaceNameList是该类实现的接口列表,可以省略,接口列表中的多个接口之间用逗号分隔。
提示:在语法说明中,括号([])部分表示可以省略;竖线(|)表示“或关系”,例如abstract|final,说明可以使用abstract或final关键字,两个关键字不能同时出现。
类体是类的主体,包括数据和操作,即成员变量和成员方法。
3.2 成员变量
声明类体中成员变量语法格式如下:
class className {
[public | protected | private ] [static] [final] type variableName; //成员变量
}
其中type是成员变量数据类型,variableName是成员变量名。type前的关键字都是成员变量修饰符,它们说明如下:
public、protected和private修饰符用于封装成员变量。
static修饰符用于声明静态变量,所以静态变量也称为“类变量”。
final修饰符用于声明变量,该变量不能被修改。
3.3 成员方法
声明类体中成员方法语法格式如下:
class className {
[public | protected | private ] [static] [final | abstract] [native] [synchronized]
type methodName([paramList]) [throws exceptionList] {
//方法体
}
}
其中type是方法返回值数据类型,methodName是方法名。type前的关键字都是方法修饰符,它们说明如下:
public、protected和private修饰符用于封装方法。
static修饰符用于声明静态方法,所以静态方法也称为“类方法”。
final | abstract不能同时修饰方法,final修饰的方法不能在子类中被覆盖;abstract用来修饰抽象方法,抽象方法必须在子类中被实现。
native修饰的方法,称为“本地方法”,本地方法调用平台本地代码(如:C或C++编写的代码),不能实现跨平台。
synchronized修饰的方法是同步的,当多线程方式同步方法时,只能串行地执行,保证是线程安全的。
方法声明中还有([paramList])部分,它是方法的参数列表。throws exceptionList是声明抛出异常列表。
提示:通常return语句通常用在一个方法体的最后,否则会产生编译错误,除非用在if-else语句中。
4.包
在程序代码中给类起一个名字是非常重要的,但是有时候会出现非常尴尬的事情,名字会发生冲突,例如:项目中自定义了一个日期类,我为它取名为Date,但是会发现Java SE核心库中还有两个Date,它们分别位于java.util包和java.sql包中。
4.1 包作用
在Java中为了防止类、接口、枚举和注释等命名冲突引用了包(package)概念,包本质上命名空间(namespace)。在包中可以定义一组相关的类型(类、接口、枚举和注释),并为它们提供访问保护和命名空间管理。
4.2 包定义
Java中使用package语句定义包,package语句应该放在源文件的第一行,在每个源文件中只能有一个包定义语句,并且package语句适用于所有类型(类、接口、枚举和注释)的文件。定义包语法格式如下:
package pkg1[.pkg2[.pkg3…]];
pkg1~ pkg3都是组成包名一部分,之间用点(.)连接,它们命名应该是合法的标识符,其次应该遵守Java包命名规范,即全部小写字母。
如果在源文件中没有定义包,那么类、接口、枚举和注释类型文件将会被放进一个无名的包中,也称为默认包。
定义好包后,包采用层次结构管理这些类型(类、接口、枚举和注释)。
Eclipse包资源视图中查看包:
文件系统目录与包:
4.3 包引入
为了能够使用一个包中类型(类、接口、枚举和注释),需要在Java程序中明确引入该包。使用import语句实现引入包,import语句应位于package语句之后,所有类的定义之前,可以有0~n条import语句,其语法格式为:
import package1[.package2…].(类型名|*);
“包名.类型名”形式只引入具体类型,“包名.*”采用通配符,表示引入这个包下所有的类型。但从编程规范的角度提倡明确引入类型名,即“包名.类型名”形式可以提高程序的可读性。
注意:当前源文件与要使用的类型(类、接口、枚举和注释)在同一个包中,可以不用引入包。
4.4 常用包
Java SE提供一些常用包,其中包含了Java开发中常用的基础类。这些包有:java.lang、java.io、java.net、java.util、java.text、java.awt和javax.swing。
java.lang包
java.lang包含中包含了Java语言的核心类,如Object、Class、String、包装类和Math等,还有包装类Boolean、Character、Integer、Long、Float和Double。使用java.lang包中的类型,不需要显示使用import语句引入,它是由解释器自动引入。
java.io包
java.io包含中提供多种输入/输出流类,如InputStream、OutputStream、Reader和Writer。还有文件管理相关类和接口,如File和FileDescriptor类以及FileFilter接口。
java.net包
java.net包含进行网络相关的操作的类,如URL、Socket和ServerSocket等。
java.util包
java.util包含一些实用工具类和接口,如集合、日期和日历相关类和接口。
java.text包
java.text包中提供文本处理、日期式化和数字格式化等相关类和接口。
java.awt和javax.swing包
java.awt和javax.swing包提供了Java图形用户界面开发所需要的各种类和接口。java.awt提供是一些基础类和接口,javax.swing提供了一些高级组件。
5.方法重载(Overload)
出于使用方便等原因,在设计一个类时将具有相似功能的方法起相同的名字。例如String字符串查找方法indexOf有很多不同版本,ndexOf方法重载如图所示:
这些相同名字的方法之所以能够在一个类中同时存在,是因为它们的方法参数列表,调用时根据参数列表调用相应重载方法。
提示:方法重载中参数列表不同的含义是:参数的个数不同或者是参数类型不同。另外,返回类型不能用来区分方法重载。
方法重载示例MethodOverloading.java代码如下:
// MethodOverloading.java文件
package com.fumumu;
class MethodOverloading {
void receive(int i) {
System.out.println("接收一个int参数");
System.out.println("i = " + i);
}
void receive(int x, int y) {
System.out.println("接收两个int参数");
System.out.printf("x = %d, y = %d \r", x, y);
}
int receive(double x, double y) {
System.out.println("接收两个double参数");
System.out.printf("x = %f, y = %f \r", x, y);
return 0;
}
}
// HelloWorld.java文件调用MethodOverloading
package com.fumumu;
public class HelloWorld {
public static void main(String[] args) {
MethodOverloading mo = new MethodOverloading();
//调用void receive(int i)
mo.receive(1);
//调用void receive(int x, int y)
mo.receive(2, 3);
//调用void receive(double x, double y)
mo.receive(2.0, 3.3);
}
}
运行结果如下:
接收一个int参数
i = 1
接收两个int参数
x = 2, y = 3
接收两个double参数
x = 2.000000, y = 3.300000
调用哪一个receive方法是根据参数列表决定的。如果参数类型不一致,编译器会进行自动类型转换寻找适合版本的方法,如果没有适合方法,则会发生编译错误。
6.封装性与访问控制
Java面向对象的封装性是通过对成员变量和方法进行访问控制实现的,访问控制分为4个等级:私有、默认、保护和公有。
Java类成员的访问控制:
6.1 私有级别
私有级别的关键字是private,私有级别的成员变量和方法只能在其所在类的内部自由使用,在其他的类中则不允许直接访问。私有级别限制性最高。
6.2 默认级别
默认级别没有关键字,也就是没有访问修饰符,默认级别的成员变量和方法,可以在其所在类内部和同一个包的其他类中被直接访问,但在不同包的类中则不允许直接访问。
6.3 公有级别
公有级别的关键字是public,公有级别的成员变量和方法可以在任何场合被直接访问,是最宽松的一种访问控制等级。
6.4 保护级别
保护级别的关键字是protected,保护级别在同一包中完全与默认访问级别一样,但是不同包中子类能够继承父类中的protected变量和方法,这就是所谓的保护级别,“保护”就是保护某个类的子类都能继承该类的变量和方法。
提示:访问成员有两种方式:一种是调用,即通过类或对象调用它的成员,如p.printX()语句;另一种是继承,即子类继承父类的成员变量和方法。
公有访问级别任何情况下两种方式都可以;
默认访问级别在同一包中两种访问方式都可以,不能在包之外访问;
保护访问级别在同一包中与默认访问级别一样,两种访问方式都可以。但是在不同包之外只能继承访问;
私有访问级别只能在本类中通过调用方法访问,不能继承访问。
提示:访问类成员时,在能满足使用的前提下,应尽量限制类中成员的可见性,访问级别顺序是:私有级别→默认级别→保护级别→公有级别。
7.静态变量和静态方法
有一个Account(银行账户)类,假设它有三个成员变量:amount(账户金额)、interestRate(利率)和owner(账户名)。在这三个成员变量中,amount和owner会因人而异,对于不同的账户这些内容是不同的,而所有账户的interestRate都是相同的。
amount和owner成员变量与账户个体有关,称为“实例变量”,interestRate成员变量与个体无关,或者说是所有账户个体共享的,这种变量称为“静态变量”或“类变量”。
静态变量和静态方法示例代码如下:
// Account.java文件
package com.fumumu;
public class Account {
// 实例变量账户金额
double amount = 0.0;
// 实例变量账户名
String owner;
// 静态变量利率
static double interestRate = 0.0668;
// 静态方法
public static double interestBy(double amt) {
//静态方法可以访问静态变量和其他静态方法
return interestRate * amt;
}
// 实例方法
public String messageWith(double amt) {
//实例方法可以访问实例变量、实例方法、静态变量和静态方法
double interest = Account.interestBy(amt);
StringBuilder sb = new StringBuilder();
// 拼接字符串
sb.append(owner).append("的利息是").append(interest);
// 返回字符串
return sb.toString();
}
}
static修饰的成员变量是静态变量。staitc修饰的方法是静态方法。相反,没有static修饰的成员变量是实例变量;没有staitc修饰的方法是实例方法。
注意:静态方法可以访问静态变量和其他静态方法。实例方法可以访问实例变量、其他实例方法、静态变量和静态方法。
调用Account代码如下:
// HelloWorld.java文件
package com.fumumu;
public class HelloWorld {
public static void main(String[] args) {
// 访问静态变量
System.out.println(Account.interestRate);
// 访问静态方法
System.out.println(Account.interestBy(1000));
Account myAccount = new Account();
// 访问实例变量
myAccount.amount = 1000000;
myAccount.owner = "Tony";
// 访问实例方法
System.out.println(myAccount.messageWith(1000));
// 通过实例访问静态变量
System.out.println(myAccount.interestRate);
}
}
调用静态变量或静态方法时,可以通过类名或实例名调用。
8.静态代码块
静态变量interestRate,可以在声明同时初始化,如下代码所示。
public class Account {
// 静态变量利率
static double interestRate = 0.0668;
...
}
如果初始化静态变量不是简单常量,需要进行计算才能初始化,可以使用静态(static)代码块,静态代码块在类第一次加载时执行,并只执行一次。示例代码如下:
// Account.java文件
package com.fumumu;
public class Account {
// 实例变量账户金额
double amount = 0.0;
// 实例变量账户名
String owner;
// 静态变量利率
static double interestRate;
// 静态方法
public static double interestBy(double amt) {
// 静态方法可以访问静态变量和其他静态方法
return interestRate * amt;
}
// 静态代码块
static {
System.out.println("静态代码块被调用...");
// 初始化静态变量
interestRate = 0.0668;
}
}
在静态代码块中可以初始化静态变量,也可以调用静态方法。
调用Account代码如下:
// HelloWorld.java文件
package com.fumumu;
public class HelloWorld {
public static void main(String[] args) {
Account myAccount = new Account();
// 访问静态变量
System.out.println(Account.interestRate);
// 访问静态方法
System.out.println(Account.interestBy(1000));
}
}