【Java】面向对象编程基础

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

代码编辑器:Eclipse

文章目录

    • 1. 面向对象概述
      • 1.1 对象
      • 1.2 类
      • 1.3 面向对象程序设计的特点
        • 1.3.1 封装
        • 1.3.2 继承
        • 1.3.3 多态
    • 2. 类与对象
      • 2.1 成员变量
      • 2.2 成员方法
        • 2.2.1 成员方法的定义
        • 2.2.2 成员方法的参数
          • (1)值参数
          • (2)引用参数
          • (3)不定长参数
      • 2.3 构造方法
      • 2.4 局部变量
      • 2.5 this 关键字
    • 3. static 关键字
      • 3.1 静态变量
      • 3.2 静态方法
      • 3.3 静态代码块
    • 4. 类的主方法

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 返回值;
}

其中,权限修饰符可以是privatepublicprotected中的任意一个,也可以不写(不指定则只能在本类及同一个包中的类中进行访问),主要用来控制方法的访问权限;返回值类型用来指定方法返回数据的类型,可以是任何类型,如果方法不需要返回值,则使用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方法并没有改变xy的值,因为我们定义的方法参数是值参数。

(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】面向对象编程基础_第1张图片


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

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

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

你可能感兴趣的:(Java学习笔记,java,类,面向对象编程)