第 7 章 面向对象编程(基础部分)

• 韩顺平 2021零基础学Java的笔记，可在Bilibili同步观看
• 韩顺平-视频观看地址 (opens new window)

7.1 类与对象

7.1.5 类与对象的关系示意图

理解： 1. 类是面向对象的重要内容，可以把类当做一种自定义类型 2. 可以使用类来定义变量，这种类型的建立统称为引用变量 3. 所有类是引用类型

7.1.6 类与对象的关系示意图

7.1.8 类和对象的区别和联系

7.1.9 对象在内存中存在形式（重要，必须搞清楚）

7.1.10 属性/成员变量/字段

注意事项和细节说明：

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

看一个练习题，并分析画出内存布局图，进行分析

最后一句会报 NullPointerException 异常。

7.2 成员方法

7.2.3 方法的调用机制原理：(重要!-示意图!!!)

7.2.5 成员方法的好处

7.2.7 注意事项和使用细节

    public class MethodDetail02 { 
    	
    	public static void main(String[] args) { 
    		A a = new A(); 
    		
    		a.m1(); 
    	} 
    }
    class A { 
    	
    	public void print(int n) { 
    		System.out.println("print()方法被调用 n=" + n);
    	}
    	public void sayOk() { 
    		print(10); 
    		System.out.println("继续执行 sayOK()~~~"); 
    	}
    	
    	public void m1() { 
    		
    		System.out.println("m1() 方法被调用"); 
    		B b = new B(); 
    		b.hi(); 
    		System.out.println("m1() 继续执行:)"); 
    	} 
    }
    class B { 
    	public void hi() { 
    		System.out.println("B 类中的 hi()被执行"); 
    	} 
    }

7.3 成员方法传参机制(非常非常重要)

    public class MethodParameter01 { 
    	
    	public static void main(String[] args) { 
    		int a = 10; 
    		int b = 20; 
    		AA obj = new AA(); 
    		obj.swap(a, b); 
    		System.out.println("main 方法 a=" + a + " b=" + b);
    	} 
    }
    class AA { 
    	public void swap(int a,int b){ 
    		System.out.println("\na 和 b 交换前的值\na=" + a + "\tb=" + b);
    		
    		int tmp = a; 
    		a = b; 
    		b = tmp; 
    		System.out.println("\na 和 b 交换后的值\na=" + a + "\tb=" + b);
    	} 
    }

7.3.2 引用数据类型的传参机制

在看一个案例，下面的方法会对原来的对象有影响吗？
p=null 和 p = new Person(); 对应示意图

7.4 方法递归调用(非常非常重要，比较难)

7.4.4 递归重要规则

7.4.5 课堂练习

    public class RecursionExercise01 { 
    	
    	public static void main(String[] args) { 
    		T t1 = new T(); 
    		int n = 7; 
    		int res = t1.fibonacci(n); 
    		if(res != -1) { 
    			System.out.println("当 n="+ n +" 对应的斐波那契数=" + res); 
    		} 
    		
    		int day = 0; 
    		int peachNum = t1.peach(day); 
    		if(peachNum != -1) { 
    			System.out.println("第 " + day + "天有" + peachNum + "个桃子"); 
    		}
    	} 
    }
    class T {
    	 
    	public int fibonacci(int n) { 
    		if( n >= 1) { 
    			if( n == 1 || n == 2) { 
    				return 1; 
    			} else { 
    				return fibonacci(n-1) + fibonacci(n-2); 
    			} 
    		} else { 
    			System.out.println("要求输入的 n>=1 的整数"); 
    			return -1; 
    		} 
    	}
    	 
    	 public int peach(int day) { 
    	 	if(day == 10) {
    	 		return 1; 
    	 	} else if ( day >= 1 && day <=9 ) { 
    	 		return (peach(day + 1) + 1) * 2;
    	 	} else { 
    	 		System.out.println("day 在 1-10"); return -1; 
    	 	} 
    	 } 
    }

7.4.6 递归调用应用实例-迷宫问题

public class MiGong { 
	
	public static void main(String[] args) { 
        int[][] map = new int[8][7]; 
        for(int i = 0; i < 7; i++) { 
            map[0][i] = 1; 
            map[7][i] = 1; 
		}
		
		for(int i = 0; i < 8; i++) {
			map[i][0] = 1; 
			map[i][6] = 1; 
		}
        
		map[3][1] = 1; 
		map[3][2] = 1; 
		map[2][2] = 1; 
        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] + " ");
            }
            System.out.println(); 
        }
		T t1 = new T(); 
		
		t1.findWay(map, 1, 1); 
		System.out.println("\n====找路的情况如下=====");
		for(int i = 0; i < map.length; i++) { 
			for(int j = 0; j < map[i].length; j++) { 
				System.out.print(map[i][j] + " ");
			}
			System.out.println(); 
		} 
	} 
}

class T {     	
	public boolean findWay(int[][] map , int i, int j) { 
		if(map[6][5] == 2) {
			return true; 
		} else { 
			if(map[i][j] == 0) {
				
				map[i][j] = 2; 
				if(findWay(map, i + 1, j)) {
					return true; 
				} else if(findWay(map, i, j + 1)){
					return true; 
				} else if(findWay(map, i-1, j)) {
					return true; 
				} else if(findWay(map, i, j-1)){
					return true; 
				} else { 
					map[i][j] = 3; 
					return false; 
				} 
			} else { 
				return false; 
			} 
		}
	}
}

7.4.7 递归调用应用实例-汉诺塔

HanoiTower.java

public class HanoiTower { 
	
	public static void main(String[] args) { 
		Tower tower = new Tower(); 
		tower.move(64, 'A', 'B', 'C'); 
	} 
}
class Tower { 
	public void move(int num , char a, char b ,char c) { 
        if(num == 1) { 
                System.out.println(a + "->" + c); 
            } else { 
            	move(num - 1 , a, c, b); 
            	System.out.println(a + "->" + c); 
			
			move(num - 1, b, a, c); 
		} 
	} 
}

7.4.8 递归调用应用实例-八皇后问题[同学们先尝试做，后面老师评讲.]

7.5 方法重载(OverLoad)

7.5.1 基本介绍

java 中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致！
比如：System.out.println(); 其中 out 是 PrintStream 类型

7.5.2 重载的好处

1. 减轻了起名的麻烦
2. 减轻了记名的麻烦

7.5.4 注意事项和使用细节

7.6 可变参数

7.6.1 基本概念

java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。
就可以通过可变参数实现

7.6.2 基本语法

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

7.6.3 快速入门案例(VarParameter01.java)

看一个案例：类 HspMethod，方法 sum 【可以计算 2 个数的和，3 个数的和 ， 4、5， 。。】

public class VarParameter01 { 
	
	public static void main(String[] args) { 
		HspMethod m = new HspMethod(); 
		System.out.println(m.sum(1, 5, 100)); 
		System.out.println(m.sum(1,19)); 
	} 
}
class HspMethod { 
  	public int sum(int... nums) { 
  		int res = 0; 
		for(int i = 0; i < nums.length; i++) { 
			res += nums[i]; 
		}
		return res; 
	} 
}

7.6.4 注意事项和使用细节

public class VarParameterDetail { 
	
	public static void main(String[] args) {
		
		int[] arr = {1, 2, 3}; 
		T t1 = new T(); 
		t1.f1(arr); 
	} 
}
class T { 
	public void f1(int... nums) { 
		System.out.println("长度=" + nums.length); 
	}
	
	public void f2(String str, double... nums) { 
	}
	
}

7.7 作用域

7.7.1 基本使用

7.7.2 注意事项和细节使用

7.8 构造方法/构造器

7.8.2 基本语法

7.8.3 基本介绍

7.8.5 注意事项和使用细节

7.9 对象创建的流程分析

7.9.1 看一个案例

7.10 this 关键字

7.10.2 深入理解 this

7.10.3 this 的注意事项和使用细节

7.11 本章作业

    public class Homework01 { 
    	
    	public static void main(String[] args) {
    		A01 a01 = new A01();
    		double[] arr = {1, 1.4, -1.3, 89.8, 123.8 , 66}; 
    		Double res = a01.max(arr);
    		if(res != null) {
    			System.out.println("arr的最大值=" + res);
    		} else {
    			System.out.println("arr的输入有误, 数组不能为null, 或者{}");
    		}
    	}
    }
    
    class A01 {
    	public Double max(double[] arr) {
    		
    		if( arr!= null && arr.length > 0 ) {
    			
    			double max = arr[0];
    			for(int i = 1; i < arr.length; i++) {
    				if(max < arr[i]) {
    					max = arr[i];
    				}
    			}
    			return max;
    		} else {
    			return null;
    		}
    	}
    }

    public class Homework06 { 
    	
    	public static void main(String[] args) {
    		Cale cale = new Cale(2, 10);
    		System.out.println("和=" + cale.sum());
    		System.out.println("差=" + cale.minus());
    		System.out.println("乘=" + cale.mul());
    		Double divRes = cale.div();
    		if(divRes != null) {
    			System.out.println("除=" + divRes);
    		} 
    	}
    }
    
    class Cale {
    	double num1;
    	double num2;
    	public Cale(double num1, double num2) {
    		this.num1 = num1;
    		this.num2 = num2;
    	}
    	
    	public double sum() {
    		return num1 + num2;
    	}
    	
    	public double minus() {
    		return num1 - num2;
    	}
    	
    	public double mul() {
    		return num1 * num2;
    	}
    	
    	public Double div() {
    		
    		if(num2 == 0) {
    			System.out.println("num2 不能为0");
    			return null;
    		} else {
    			return num1 / num2;
    		}
    	}
    }