参考书籍资料:《零基础学Java》——明日科技 编著
代码编辑器:Eclipse
文章目录
1. 面向对象概述
1.1 对象
对象(Object)是一个抽象概念,表示任意存在的事物。世间万物皆对象!
通常将对象划分为两个部分,即静态部分和动态部分。静态部分即客观存在的特性,称为属性,动态部分即对象所能执行的动作,称为方法。
1.2 类
类是封装对象的属性和方法的载体,反过来说具有相同属性和行为的一类实体被称为类。
Java 语言中,类包括对象的属性和方法。类中对象的属性是以成员变量的形式定义的,对象的行为是以方法的形式定义的。
1.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】字符串