Java面向对象编程（一）类与对象_面向对象程序设计java类和对象

文章内容输出来源：拉勾教育大数据高薪训练营

拉勾教育大数据高薪训练营 学习笔记

一、类与对象

1.1 对象和面向对象编程的概念

• 万物皆对象
• 面向对象：以属性和行为的观点去分析现实生活中的事物
• 面向对象编程：先以面向对象的思想进行分析，然后使用面向对象的编程语言进行表达的过程
• 精髓：封装、继承、多态

1.2 类和对象的概念

• 对象主要指现实生活中客观存在的实体，在Java中对象体现为内存空间中的一块存储区域(堆区)
• 类即分类，是对具有相同特征和行为的多个对象共性的抽象描述，在Java中体现为一种引用数据类型，里面包含了描述特征/属性的成员变量以及描述行为的成员方法
• 类是用于构建对象的模板，对象的数据结构由定义它的类来决定

1.3 类、对象、引用的定义

类的定义

class 类名 {
	类体;
}
1
2
3

注：通常情况下，当类名由多个单词组成时，要求每个单词首字母都大写，如：class StudentName

成员变量的定义

class 类名 {
	数据类型 成员变量名 = 初始值;
}
1
2
3

注：当成员变量由多个单词组成时，通常要求从第二个单词起每个单词的首字母大写，如：String studentName

成员变量 V.S. 局部变量

• 成员变量：在 类体内 方法体外 声明，有效区域从声明开始直到类体结束
• 局部变量：在 方法体内 声明，有效区域从声明开始直到方法体结束

对象的创建

new 类名();  // 不能丢掉小括号，如：new StudenName()，此对象没有名字，称为**匿名对象**
1

注：
a. 当一个类定义完毕后，可使用new关键字来创建该类的对象，这个过程叫做类的实例化
b. 创建对象的本质：在内存空间的堆区申请一块存储区，以存放该对象独有的特征信息

引用的定义

• 基本概念
  • a. 使用引用数据类型(数组、类)定义的变量称为引用型变量，简称引用
  • b. 引用变量(栈区)主要用于记录对象在堆区中的内存地址信息，便于下次访问
• 语法格式

类名 引用变量名;  // StudentName s = new StudentName();
引用变量名.成员变量名; // s.name = “LanceMai”;

1.4 案例：Person类

Person类的定义

/*
	编程实现Person类的定义
*/
public class Person {

	// 数据类型 成员变量 = 初始值;  // 其中初始值通常省略不写（与局部变量不同） 
	String name; // 用于描述姓名的成员变量（默认为null）
	int age; / 用于描述年龄的成员变量(默认为0)(局部变量没有默认值)
	
	public static void main(String[] arge) {
		
		// 1.声明person类型的引用指向Person类型的对象
		// 数据类型(类名) 引用变量名 = new 类名();
		Person p = new Person();
		// 2.打印对象中的成员变量值
		// 引用变量名.成员变量名
		System.out.println("我是" + p.name + "，今年" + p.age + "岁了！"); //null
		// 3.修改成员变量的数值
		p.name = "张飞";
		p.age = 30;
		// 4.再次打印
		System.out.println("我是" + p.name + "，今年" + p.age + "岁了！");  //张飞 30
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Person类代码的执行流程和内存分析

1.5 案例：Point类的定义

/*
	编程实现Point类的定义
*/
public class Point {
	
	// 1.定义成员变量
	int xAxis;
	int yAxis;
	
	public static void main(String[] args) {
		
		// 2.声明Point类型的引用指向Point对象并打印特征
		Point p = new Point();
		System.out.println("坐标是" + "(" + p.xAxis + " ," + p.yAxis + ")");
		
		System.out.println("---------------------------------------------");
		// 3.将横纵坐标修改为3和5，再次打印
		p.xAxis = 3;
		p.yAxis = 5;
		System.out.println("修改后坐标是" + "(" + p.xAxis + " ," + p.yAxis + ")");
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

1.6 成员方法

(1) 成员方法的定义

class 类名 {
 返回值类型 成员方法(形参列表) {
  成员方法体;
 }
}
// 当成员方法名由多个单词组成时，要求从第二个单词起每个单词的首字母大写

(2) 返回值类型的详解

• 返回值主要指从方法体内返回到方法体外的数据内容
• 返回值类型可以是基本数据类型，也可以是引用数据类型
• 在方法体中使用return关键字，可以返回具体的数据内容并结束当前方法
• 当返回的数据内容为66时，则方法体中写 return 66; 即可
• 不需要返回任何数据时，返回值类型写 void 即可

(3) 形参列表的详解

• 形参主要用于将方法体外的数据内容带入到方法体内部(方法里面的局部变量)
• 形参列表主要指多个形参组成的列表，语法格式：
  • 数据类型 形参变量1, 数据类型 形参变量2, …
• “hello” --> String s
• 66 和 “hello” --> int i, String s
• 该方法若不需要任何数据内容，则形参列表位置不写内容

(4) 成员方法体的详解

• 成员方法可以实现代码的重用，简化代码(与main方法平级，前后顺序看个人习惯)
• 成员方法体主要用于编写描述该方法功能的语句块
• 成员变量和成员方法都属于类内部的成员，因此成员方法可以直接访问成员变量，
  而不需要再加引用 . 的前缀

(5) 成员方法的调用

引用变量名.成员方法名(实参列表);

• 实参列表主要用于对形参列表进行初始化操作，因此参数的个数、类型、顺序要完全一致
• 实参可以传递直接量，变量，表达式，方法的调用等

(6) Point类中无参无返回值成员方法的定义和调用

/*
	编程实现Point类的定义
*/
public class Point {
	
	// 1.定义成员变量
	int xAxis;
	int yAxis;
	
	// 自定义成员方法实现所有成员变量的打印
	// 返回值类型 方法名称(形参列表) { 方法体; }
	void show() {
		// 成员变量和成员方法都属于类内部的成员，因此可以直接访问成员变量，不需要再加引用.的前缀
		System.out.println("坐标是" + "(" + xAxis + " ," + yAxis + ")");
	}
	
	public static void main(String[] args) {
		
		// 2.声明Point类型的引用指向Point对象并打印特征
		Point p = new Point();
		//System.out.println("坐标是" + "(" + p.xAxis + " ," + p.yAxis + ")");
		// 调用方法的本质：根据方法名跳转过去执行，然后再返回此处
		p.show();
		
		System.out.println("---------------------------------------------");
		// 3.将横纵坐标修改为3和5，再次打印
		p.xAxis = 3;
		p.yAxis = 5;
		//System.out.println("修改后坐标是" + "(" + p.xAxis + " ," + p.yAxis + ")");
		p.show();
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

(7) Point类中有参无返回值成员方法的定义和调用

/*
	编程实现Point类的定义
*/
public class Point {
	
	// 1.定义成员变量
	int xAxis;
	int yAxis;
	
	// 自定义成员方法实现所有成员变量的打印
	// 返回值类型 方法名称(形参列表) { 方法体; }
	void show() {
		// 成员变量和成员方法都属于类内部的成员，因此可以直接访问成员变量，不需要再加引用.的前缀
		System.out.println("坐标是" + "(" + xAxis + " ," + yAxis + ")");
	}
	// 自定义成员方法实现将横坐标修改为参数指定数值的行为
	void setX(int i) {
		xAxis = i;
	}
	// 自定义成员方法实现将横坐标修改为参数指定数值的行为
	void setY(int j) {
		yAxis = j;
	}
	
	public static void main(String[] args) {
		
		// 2.声明Point类型的引用指向Point对象并打印特征
		Point p = new Point();
		//System.out.println("坐标是" + "(" + p.xAxis + " ," + p.yAxis + ")");
		// 调用方法的本质：根据方法名跳转过去执行，然后再返回此处
		p.show();
		
		System.out.println("---------------------------------------------");
		// 3.将横纵坐标修改为3和5，再次打印
		p.xAxis = 3;
		p.yAxis = 5;
		//System.out.println("修改后坐标是" + "(" + p.xAxis + " ," + p.yAxis + ")");
		p.show();
		// 通过调用成员方法实现横纵坐标的修改
		p.setX(10);
		p.setY(15);
		p.show();
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

(8) Person类中无参无返回值成员方法的定义和调用

/*
    编程实现Person类的定义
 */
public class Person {

	// 数据类型 成员变量名 = 初始值;   - 其中=初始值 通常都省略不写
	String name; // 用于描述姓名的成员变量
	int age;     // 用于描述年龄的成员变量

    // 自定义成员方法实现所有成员变量的打印
    // 返回值类型 方法名称(形参列表) { 方法体; }	
	void show() {
		// 成员变量和成员方法都属于类内部的成员，因此可以直接访问成员变量不需要再加引用.的前缀
		System.out.println("我是" + name + "，今年" + age + "岁了！");
	}

    public static void main(String[] args) {
		
		// 1.声明Person类型的引用指向Person类型的对象
		// 数据类型(类名) 引用变量名 = new 类名();
		Person p = new Person();
		// 2.打印对象中的成员变量值
		// 引用变量名.成员变量名
		//System.out.println("我是" + p.name + "，今年" + p.age + "岁了！"); // null 0
		// 引用变量名.成员方法名(实参列表);
		// 调用方法的本质就是根据方法名跳转过去执行方法体后再跳转回这个位置
		p.show();
		
		System.out.println("-----------------------------------------------------");
		// 3.修改成员变量的数值
		p.name = "zhangfei";
		p.age = 30;
		// 4.再次打印修改后的数值
		//System.out.println("我是" + p.name + "，今年" + p.age + "岁了！"); // zhangfei 30
		p.show();
	}	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

(9) Person类中有参无返回值成员方法的定义和调用

/*
    编程实现Person类的定义
 */
public class Person {

	// 数据类型 成员变量名 = 初始值;   - 其中=初始值 通常都省略不写
	String name; // 用于描述姓名的成员变量
	int age;     // 用于描述年龄的成员变量

    // 自定义成员方法实现所有成员变量的打印
    // 返回值类型 方法名称(形参列表) { 方法体; }	
	void show() {
		// 成员变量和成员方法都属于类内部的成员，因此可以直接访问成员变量不需要再加引用.的前缀
		System.out.println("我是" + name + "，今年" + age + "岁了！");
	}
	// 自定义成员方法：将姓名修改为参数指定的数值
	void setName(String s) {
		name  = s;
	}
	// 自定义成员方法：将年龄修改为参数指定的数值
	void setAge(int i) {
		age = i;
	}
	
    public static void main(String[] args) {
		
		// 1.声明Person类型的引用指向Person类型的对象
		// 数据类型(类名) 引用变量名 = new 类名();
		Person p = new Person();
		// 2.打印对象中的成员变量值
		// 引用变量名.成员变量名
		//System.out.println("我是" + p.name + "，今年" + p.age + "岁了！"); // null 0
		// 引用变量名.成员方法名(实参列表);
		// 调用方法的本质就是根据方法名跳转过去执行方法体后再跳转回这个位置
		p.show();
		
		System.out.println("-----------------------------------------------------");
		// 3.修改成员变量的数值
		p.name = "zhangfei";
		p.age = 30;
		// 4.再次打印修改后的数值
		//System.out.println("我是" + p.name + "，今年" + p.age + "岁了！"); // zhangfei 30
		p.show();
		// 5.通过成员方法的调用实现成员变量的修改
		p.setName("关羽");
		p.setAge(32);
		p.show();
	}	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

(10) Person类中多个形参成员方法的使用(不推荐使用)

// 自定义成员方法实现将姓名和年龄修改为参数指定数值的行为
void setNameAge(String s, int i) {
	name = s;
	age = i;
}

// 调用
p.setNameAge("刘备", 40);
或者：
p.setNameAge("刘" + "备", 40);
1
2
3
4
5
6
7
8
9
10

(11) Person类中无参有返回值成员方法的使用

// 自定义成员方法实现姓名数值的获取并返回的行为
String getName() {
	return name; // return之后的语句不再执行
}
// 自定义成员方法实现姓名数值的获取并返回的行为
int getAge() {
	return age;
}
// 调用
String str1 = p.getName();
int int1 = p.getAge();
1
2
3
4
5
6
7
8
9
10
11

(12) Point类中无参有返回值成员方法的使用

// 自定义成员方法实现获取横坐标数值并返回的行为
int getXAxis() {
	return xAxis;
}
// 自定义成员方法实现获取横坐标数值并返回的行为
int getYAxis() {
	return yAxis;
}
// 调用
int int1 = p.getXAxis();
int int2 = p.getYAxis();
1
2
3
4
5
6
7
8
9
10
11

1.7 可变长参数(放在末尾)

返回值类型 方法名(参数类型 …  参数名)

• 方法参数部分指定类型的参数个数可变，也就是0~n个
• 一个方法的形参列表中最多只能声明一个可变长形参，并且放到参数列表的末尾
• 可变长形参里参数的数据类型要求相同，可看做一维数组来使用

// 声明
void showArgument(String... args) {
	for(int i=0; i<args.length; i++) {
		System.out.println(args[i]);
	}
}
// 调用
p.showArgument();
p.showArgument("参数1");
p.showArgument("参数1", "参数2");
// 也可以在可变长形参前面再加形参
void showArgument(int a, String... args) {
	for(int i=0; i<args.length; i++) {
		System.out.println(args[i]);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1.8 方法的传参过程

// max() 方法功能是求最大值, 以下例子省略一些细节了
int max(int ia, int ib) {... ... ...}
int a = 5; int b = 6; int res = m.max(a, b);
1
2
3

• 以上代码传参过程
  • 为main方法中的变量a、b、res分配空间并初始化
  • 调用max方法，为max方法的形参变量ia、ib分配空间
  • 将实参变量的数值赋值给形参变量的内存空间中
  • max方法运行完毕后返回，形参变量空间释放
  • main方法中的res变量得到max方法的返回值
  • main方法结束后释放相关变量的内存空间

1.9 参数传递的注意事项

• 基本数据类型的变量作为方法的参数传递时，形参变量数值的改变通常不会影响到实参变量的数值，因为两个变量有各自独立的内存空间(传值)
• 引用数据类型的变量作为方法的参数传递时，形参变量指向内容的改变会影响到实参变量指向内容的的数值，因为两个变量指向同一块内存空间(传地址)
• 当引用数据类型的变量作为方法的传递时，若形参变量改变后再改变指定的内容，则通常不会影响到实参变量指向内容的改变，因为两个变量指向不同的内存空间

/*
	编程实现类方法中参数的传递
*/

import java.util.Arrays;

public class Pass {
	
	// 定义一个方法
	void show(int[] arr) {
		arr = new int[arr.length];
		arr[0] = 111111;
		System.out.println(Arrays.toString(arr)); // [111111, 0, 0]
		System.out.println(arr);  // [I@2a33fae0
	}
	
	public static void main(String[] args) {
		
		int[] arr1 = new int[]{1,2,3};
		// 声明Pass类型的引用指向Pass类型的对象
		Pass p = new Pass();
		p.show(arr1);
		System.out.println(Arrays.toString(arr1));  // [1, 2, 3]
		System.out.println(arr1);  // [I@707f7052
	}
}
// 此时形参arr1的改变不会影响到arr2，因为arr1和arr2指向不同的内存空间
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

总结