6. 面向对象编程（基础部分）

文章目录

• 1. 类与对象
• • 1.1 类与对象的引入
  • 1.2 类与对象的关系
  • 1.3 属性 / 成员变量 / 字段
  • 1.4 创建对象
  • 1.5 访问属性
  • 1.6 类和对象的内存分配机制
• 2. 成员方法
• • 2.1 方法的定义和使用
  • 2.2 方法的调用机制
  • 2.3 方法的优势
  • 2.3 方法的使用细节
  • 2.4 方法的传参机制
  • 2.5 方法的递归调用
  • 2.6 方法的重载
  • 2.7 可变参数

1. 类与对象 1.1 类与对象的引入

  有两只猫，一只叫小白，今年 3 岁，白色；一只叫小花，今年 100 岁，花色。用代码表示上述信息。

• 单独的定义变量解决，缺点：不利于数据的管理。

  //第 1 只猫信息
  String cat1Name = "小白";
  int cat1Age = 3;
  String cat1Color = "白色";
  //第 2 只猫信息
  String cat2Name = "小花";
  int cat2Age = 100;
  String cat2Color = "花色";
  

• 使用数组解决，缺点：
  (1) 数据类型体现不出来；
  (2) 只能通过 [下标] 获取信息，造成变量名字和内容的对应关系不明确；
  (3) 不能体现猫的行为。

  //第 1 只猫信息
  String[] cat1 = {"小白", "3", "白色"};
  //第 2 只猫信息
  String[] cat2 = {"小花", "100", "花色"};
  

1.2 类与对象的关系

类是自定义的数据类型，对象是类的一个具体实例，两者的关系可以类比 int 类型与具体值：
猫类Cat：自定义的数据类型  ➡  猫对象（具体一只猫）
int：Java提供的数据类型   ➡  100， 200，300

从类到对象，目前有几种说法：（1）创建一个对象；（2）实例化一 个对象；（3）把类实例化

对于 1.1 中的问题，可以用面向对象（OOP）的方式解决：

public class test {
	public static void main(String[] args) {
		//第1只猫
		Cat cat1 = new Cat();
		cat1.name = "小白";
		cat1.age = 3;
		cat1.color = "白色";
		cat1.weight = 10;
		//第2只猫
		Cat cat2 = new Cat();
		cat2.name = "小花";
		cat2.age = 100;
		cat2.color = "花色";
		cat2.weight = 20;
		//访问对象的属性
		System.out.println("第1只猫信息：" + cat1.name
		+ "t" + cat1.age + "t" + cat1.color + "t" + cat1.weight);
		System.out.println("第2只猫信息：" + cat2.name
		+ "t" + cat2.age + "t" + cat2.color + "t" + cat2.weight);
	}	
}

class Cat {
	String name; //名字
	int age; //年龄
	String color; //颜色
	double weight; //体重
}

1.3 属性 / 成员变量 / 字段

 从概念或叫法上看： 成员变量 = 属性 = field(字段)。

• 属性可以是基本数据类型，也可以是引用类型(对象，数组)。

  class Car {
  	String name;
  	double price;
  	String color;
  	String[] master;//属性是引用类型（数组）
  }
  

• 属性的定义语法同变量，但多了“访问修饰符”。示例：private int num;
  访问修饰符的作用：控制属性的访问范围。
  4种访问修饰符：public，proctected，默认，private。

• 属性如果不赋值，有默认值，规则与数组一致。具体来说：int 0，short 0，byte 0，long 0，float 0.0，double 0.0，char u0000，boolean false，String null。

  public class test {
  	public static void main(String[] args) {
  		Person p1 = new Person();
  		System.out.println("age = " + p1.age) ;
  		System.out.println("name = " + p1.name);
  		System.out.println("salary = " + p1.salary);
  		System.out.println("isPass = " + p1.isPass);
  	}	
  }
  
  class Person {
  	int age;
  	String name;
  	double salary;
  	boolean isPass;
  }
  

  输出结果：

  age = 0
  name = null
  salary = 0.0
  isPass = false
  

1.4 创建对象

• 先声明再创建

  Cat cat ;
  cat = new Cat(); 
  

  声明对象以后，栈中的 对象名 / 对象的引用 的内容为 null，创建对象后，堆中有了对象的空间，对象名的内容才是对象的地址。

• 直接创建

  Cat cat = new Cat();
  

1.5 访问属性

访问属性的方式：对象名.属性名，如：cat.name，cat.age，cat.color。

1.6 类和对象的内存分配机制

Java 内存的结构分析：

• 栈：一般存放基本数据类型（局部变量）。
• 堆：存放对象、数组等。
• 方法区：常量池（常量，比如字符串），类加载信息。
  
  上图注解：
  ① 先加载 Cat 类信息（属性和方法信息, 只会加载一次）。
  ② 在堆中分配空间，进行默认初始化（看1.3中的规则）。再把地址赋给 cat , cat 就指向对象。
  ③ 进行指定初始化，如：cat.name = “小白”。
  
  【例】
  

2. 成员方法 2.1 方法的定义和使用

  在某些情况下，我们要需要定义成员方法（简称方法）。比如人类：除了有一些属性外（年龄，姓名……），还有一些行为比如：说话、跑步，这时就要用成员方法。现在要求对Person 类完善。

public class test {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.speak(); 
		p1.cal01(); 
		p1.cal02(5); 
		p1.cal02(10); 

		int returnRes = p1.getSum(10, 20);
		System.out.println("getSum 方法返回的值=" + returnRes);
	}
}

class Person {
	String name;
	int age;
	
	public void speak() {
		System.out.println("我是一个好人");
	}
	
	public void cal01() {
		int res = 0;
		for(int i = 1; i <= 1000; i++) {
			res += i;
		}
		System.out.println("cal01 方法 计算结果=" + res);
	}

	public void cal02(int n) {
		int res = 0;
		for(int i = 1; i <= n; i++) {
			res += i;
		}
		System.out.println("cal02 方法 计算结果=" + res);
	}

	public int getSum(int num1, int num2) {
		int res = num1 + num2;
		return res;
	}
}

2.2 方法的调用机制

2.3 方法的优势

(1) 提高代码的复用性。
(2) 将实现的细节封装起来，其他用户直接调用即可。

看一个需求：
遍历一个数组 , 输出数组的各个元素值（共3次）。

public class test {
	public static void main(String[] args) {
		int[][] map = {{0,0,1},{1,1,1},{1,1,3}};
		MyTools tool = new MyTools();
		tool.printArr(map);
		tool.printArr(map);
		tool.printArr(map);
	}
}

class MyTools {//工具类
	public void printArr(int[][] map) {
		System.out.println("=======");
		for(int i = 0; i < map.length; i++) {
			for(int j = 0; j < map[i].length; j++) {
				System.out.print(map[i][j] + "t");
			}
			System.out.println();
		}
	}
}

2.3 方法的使用细节

• 方法的访问修饰符作用是控制方法的使用范围，如果不写，就是“默认访问”，共有 4 种：public, protected, 默认, private。

• 一个方法最多有一个返回值，若想带回多个数据，可返回一个数组。

  public class test {
  	public static void main(String[] args) {
  		AA a = new AA();
  		int[] res = a.getSumAndSub(1, 4);
  		System.out.println("和 = " + res[0]);
  		System.out.println("差 = " + res[1]);
  	}
  }
  
  class AA {
  	public int[] getSumAndSub(int n1, int n2) {//返回值是数组
  		int[] resArr = new int[2]; 
  		resArr[0] = n1 + n2;
  		resArr[1] = n1 - n2;
  		return resArr;
  	}
  }
  

• 参数和返回值可以为任意类型，包含基本类型和引用类型（如：数组，对象）。

• 如果方法要求有返回值，则方法体中必须有 return ，而且要求返回值类型必须和 return 值类型一致或兼容（涉及自动类型转换的问题）。

  public double f1() {
  	double d1 = 1.1;
  	int n = 100;
  	return n; //正确 int ➡ double
  	//return d1; //错误 double ➡ int
  }
  

• 如果方法是 void，则方法体中可以没有 return 语句，或者 只写 return。

• 方法定义时的参数称为形参；方法调用时的传入参数称为实参，实参和形参的类型要一致或兼容，个数、顺序必须致。

• 方法不能嵌套定义。

  public void f4() {
  	//错误
  	public void f5() {
  	}
  }
  

• 同一个类中的方法调用：不用事先创建对象，直接调用即可。被调方法和主调方法前后顺序无妨。

  public class test {
  	public static void main(String[] args) {
  		A a = new A();
  		a.sayOk();
  	}
  }
  
  class A {
  	public void print(int n) {
  		System.out.println("print()方法被调用 n=" + n);
  	}
  	public void sayOk() {//被调用的方法在sayOk方法前后均可
  		print(10);
  	}
  }
  

• 跨类中的方法 A 类调用 B 类方法：需要先创建 B 的对象，再调用其方法，A、B类的前后顺序无妨。（实际上，主类调用其他自定义类也是一样的操作）

  class A {
  	public void m1() {
  		B b = new B();
  		b.hi();
  	}
  }
  class B {
  	public void hi() {
  		System.out.println("B 类中的 hi()被执行");
  	}
  }
  

• 特别说明一下：跨类的方法调用与方法的访问修饰符相关，后面详讲。

2.4 方法的传参机制

基本数据类型，传递的是值（值拷贝），形参的改变不影响实参。

public class test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		AA obj = new AA();
		//仅仅是将main方法中的值拷贝一份给了swap方法
		//swap方法调用完成后，相关的变量等信息就出栈，带不到main方法中来
		obj.swap(a, b);
		System.out.println("main方法中: "+a + "t" + b);//a=10 b=20
	}
}

class AA {
	public void swap(int a,int b){
		System.out.println("交换前: " + a + "t" + b);//a=10 b=20
		int tmp = a;
		a = b;
		b = tmp;
		System.out.println("交换前: " + a + "t" + b);//a=20 b=10
	}
}

引用类型，传递的是地址，可以通过形参影响实参。
（1）数组传参

public class test {
	public static void main(String[] args) {
		B b = new B();
		int[] arr = {1, 2, 3};
		b.test100(arr);
		System.out.println("main的arr数组：");
		for (int i=0; i
			System.out.print(arr[i]+"t");
		}
		System.out.println();
	}
}

class B {
	public void test100(int[] arr) {
		arr[0] = 200;
		System.out.println("test100的arr数组: ");
		for(int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "t");
		}
		System.out.println();
	}
}

分析：

输出结果：

test100的arr数组：200	2	3
mian的arr数组：200	2	3

（2）对象传参

public class test {
	public static void main(String[] args) {
		B b = new B();
		Person p = new Person();
		p.name = "jack";
		p.age = 10;
		b.test200(p);
		System.out.println("main的p.age="+p.age);
	}
}
class Person {
	String name;
	int age;
}
class B {
	public void test200(Person p) {
		p = 10000;
	}
}

分析：

输出结果：

main的p.age=10000

【例1】

public class test {
	public static void main(String[] args) {
		B b = new B();
		Person p = new Person();
		p.name = "jack";
		p.age = 10;
		b.test200(p);
		//函数返回后，test200方法的相关内容出栈，包括其中的对象p
		//且该对象p不能被带回mian函数，main函数后续使用的p仍是原对象
		System.out.println("main的p.age="+p.age);
	}
}
class Person {
	String name;
	int age;
}
class B {
	public void test200(Person p) {//传过来一个对象的地址，使p的内容为该对象的地址
		p = null;//但又马上置为空	
	}
}

输出结果：

main的p.age=10

【例2】

```java
public class test {
	public static void main(String[] args) {
		B b = new B();
		Person p = new Person();
		p.name = "jack";
		p.age = 10;
		b.test200(p);
		//函数返回后，test200方法的相关内容出栈，包括其中的对象p
		//且该对象p不能被带回mian函数，main函数后续使用的p仍是原对象
		System.out.println("main的p.age="+p.age);
	}
}
class Person {
	String name;
	int age;
}
class B {
	public void test200(Person p) {//传过来一个对象的地址，使p的内容为该对象的地址
		p = new Person();//但又马上置为另一个新对象的地址
		p.name = "tom";
		p.age = 99;
	}
}

输出结果：

main的p.age=10

【例3】编写一个方法 copyPerson，可以复制一个 Person 对象，返回复制的对象。 注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同。

public class test {
	public static void main(String[] args) {
		B b = new B();
		Person p = new Person();
		p.name = "jack";
		p.age = 10;		
		Person np = b.copyPerson(p);
		System.out.println("p.name="+p.name+"  p.age="+p.age);
		System.out.println("np.name="+np.name+"  np.age="+np.age);
		System.out.println(p == np);//判断两者是否为同一个对象
	}
}
class Person {
	String name;
	int age;
}
class B {
	public Person copyPerson(Person p) {
		Person np = new Person();
		np.name = p.name;
		np.age = p.age;
		return np;
	}
}

2.5 方法的递归调用

调用方法时，相关信息入栈；方法返回时。相关信息出栈。
【例1】

【例2】

递归的细节问题：

• 执行一个方法时，就创建一个新的受保护的独立空间（栈空间）。
• 每一层方法的局部变量是独立的，不会相互影响。
• 如果方法中使用的是引用类型变量（比如数组、对象），各个方法就会共享该引用类型的数据。
• 递归必须向退出递归的条件逼近，否则就是无限递归，出现
  StackOverflowError，栈溢出。

练习：
（1）已知斐波那契数列：1，1，2，3，5，13…使用递归的方式求出第n项。

public class test {
	public static void main(String[] args) {
		Tool tool = new Tool();
		int n = 7;
		int res = tool.fibonacci(n);
		System.out.println(res);
	}
}

class Tool {
	public int fibonacci(int n) {
		if (n == 1 || n == 2)
		{
			return 1;
		}else {
			return fibonacci(n-1) + fibonacci(n-2);
		}
	}
}

（2）有一堆桃子，猴子第一天吃了其中的一 半，并再多吃了一个。以后每天都吃其中的一半，然后再多吃一个。当到第10天时，想再吃时（还没吃）发现只有1个桃子了。问：最初共多少个桃子?

public class test {
	public static void main(String[] args) {
		Tool tool = new Tool();
		int day = 1;
		int res = tool.peachNum(day);
		if (res!=-1)
		{
			System.out.println("第"+day+"天桃子个数是: "+res);
		}else{
			System.out.println("应输入1~10的数字");
		}
		
	}
}

class Tool {
	public int peachNum(int day) {
		if (day == 10)
		{
			return 1;
		}else if(day>=1 && day<=9) {
			return (peachNum(day+1)+1) * 2;
		}else {
			return -1;
		}
	}
}

（3）老鼠出迷宫，找到一条路径，从①处走到②处。

（待补充）

2.6 方法的重载

重载：Java 允许同一个类有多个同名方法，但要求形参列表不一致（根据这里判断是否是重载就够了）。
重载的好处：
（1）减轻了起名的麻烦
（2）减轻了记名的麻烦
（3）利于接口编程

【例1】方法重载演示

public class test {
	public static void main(String[] args) {
		MyCalculator mc = new MyCalculator();
		System.out.println(mc.calculate(1, 2));
		System.out.println(mc.calculate(1.1, 2));
		System.out.println(mc.calculate(1, 2.1));
	}
}

class MyCalculator {
	//下面的四个 calculate 方法构成了重载
	public int calculate(int n1, int n2) {
		System.out.println("calculate(int n1, int n2) 被调用..");
		return n1 + n2;
	}

	public double calculate(int n1, double n2) {
		System.out.println("calculate(int n1, double n2) 被调用..");
		return n1 + n2;
	}

	public double calculate(double n1, int n2) {
		System.out.println("calculate(double n1, int n2) 被调用..");
		return n1 + n2;
	}

	public int calculate(int n1, int n2, int n3) {
		System.out.println("calculate(int n1, int n2, int n3) 被调用..");
		return n1 + n2 + n2;
	}
}

输出结果：

calculate(int n1, int n2) 被调用..
3
calculate(double n1, int n2) 被调用..
3.1
calculate(int n1, double n2) 被调用..
3.1

注意事项和细节：
（1）方法名：必须相同。
（2）形参列表：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）。
（3）返回类型：无要求。

【例2】重载对参数名称无要求，所以下面两个方法只是“方法的重复定义”，不构成方法重载，而且是错误的。

class MyCalculator {
	public int calculate(int n1, int n2) {
		System.out.println("calculate(int n1, int n2) 被调用");
		return n1 + n2;
	}
 	public int calculate(int a1, int a2) {
		System.out.println("calculate(int n1, int n2) 被调用");
		return a1 + a2;
	}
}

【例3】重载对返回类型无要求，所以下面两个方法也不构成重载。

class MyCalculator {
	public int calculate(int n1, int n2) {
		System.out.println("calculate(int n1, int n2) 被调用");
		return n1 + n2;
	}
	public void calculate(int n1, int n2) {
		 System.out.println("calculate(int n1, int n2) 被调用");
		 int res = n1 + n2;
	}
}

【例4】与void show(int a,char b,double c){}构成重载的有:

• void show(int x,char y,double z){}
• int show(int a,double c,char b){}
• void show(int a,double c,char b){}
• boolean show(int c,char b){}
• void show(double c){}
• double show(int x,char y,double z){}
• void shows(){}

【例5】重载中的优先级：如果有多个重载方法可供调用，则优先调用参数类型匹配度高的一个。如methods.max(3.2, 2.1, 5)优先调用方法2，如果没有方法2才会调用方法1。

public class test {
	public static void main(String[] args) {
		Methods methods = new Methods();
		System.out.println(methods.max(3.2, 2.1, 5));
	}
}

class Methods {
	public double max(double n1, double n2, double n3) {//方法1
		double t = n1 > n2 ? n1:n2;
		return t > n3 ? t:n3;
	}
	public double max(double n1, double n2, int n3) {//方法2
		double t = n1 > n2 ? n1:n2;
		return t > n3 ? t:n3;
	}
}

2.7 可变参数

可变参数：Java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法，可以通过可变参数实现。可变参数的本质是数组，所以与数组使用方法相同。

基本语法：

访问修饰符 返回类型 方法名(数据类型... 形参名) {
}

【例1】一般重载方法与可变参数使用的对比：

//一般重载方法,比较笨
public class test {
	public static void main(String[] args) {
		Methods m = new Methods();
		System.out.println(m.sum(1, 5, 100)); //106
		System.out.println(m.sum(1,19)); //20
	}
}
class Methods {
	 public int sum(int n1, int n2) {//2 个数的和
		return n1 + n2;
	 }
	 public int sum(int n1, int n2, int n3) {//3 个数的和
		return n1 + n2 + n3;
	 }
	 public int sum(int n1, int n2, int n3, int n4) {//4 个数的和
		return n1 + n2 + n3 + n4;
	 }
}

//可变参数，灵活
public class test {
	public static void main(String[] args) {
		Methods m = new Methods();
		System.out.println(m.sum(1, 5, 100)); //106
		System.out.println(m.sum(1,19)); //20
	}
}

class Methods {
	public int sum(int... nums) {
		int res = 0;
		//可变参数的使用与数组相同
		for(int i = 0; i < nums.length; i++) {
			res += nums[i];
		}
		return res;
	}
}

使用细节：

• 可变参数的实参可以为0个或任意多个。

• 可变参数的实参可以为数组。

  public class test {
  	public static void main(String[] args) {
  		int[] arr = {1, 2, 3};
  		Methods m = new Methods();
  		m.f1(arr);
  	}
  }
  
  class Methods {
  	public void f1(int... nums) {
  		System.out.println(nums.length);//3
  	}
  }
  

• 可变参数的本质就是数组。

• 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后（保证形参和实参的唯一对应关系）。

• 一个形参列表中只能出现一个可变参数（保证形参和实参的唯一对应关系）。

【例2】封装一个可变参数方法，同时具备返回姓名和两门课总成绩、返回姓名和三门课总成绩、返回姓名和五门课总成绩的功能。

public class test {
	public static void main(String[] args) {
		Methods m = new Methods();
		System.out.println(m.showScore("milan" , 90.1, 80.0 ));
		System.out.println(m.showScore("terry" , 90.1, 80.0,10,30.5,70 ));
	}
}

class Methods {
	public String showScore(String name ,double... scores ) {
		double totalScore = 0;
		for(int i = 0; i < scores.length; i++) {
			totalScore += scores[i];
		}
		return name + "有" +scores.length + "门课, 成绩总分为" + totalScore;
	}
}

输出结果：

milan有2门课, 成绩总分为170.1
terry有5门课, 成绩总分为280.6