java面对对象基础

1.对象的内存布局

类实例化为对象：类实例化为对象的语句一定要加括号，否则编译不通过
//类名 生成对象名=new 类名（）

//类名 生成对象名=new 类名（）
Tool Mytool=new Tool();
class Tool{
	public boolean oddOreven(int num){
		if(num%2!=0){
			return true;
		}else{
			return false;
		}
	}
} 

（1）对象包括属性和方法；

java中对象的赋值是地址的传递（和数组传递机制类似）
置p1=Null的时候，堆区的对象内容不会被置空，只会释放p1

2.对象-方法的访问修饰符

一共四种：public,protected,默认，private;(不写明则为默认)
（1）方法使用的注意事项

方法调用时也必须要加括号

3.程序：猴子吃桃&汉诺塔&走迷宫

“猴子吃桃”
public class Recursion{

	public static void main(String[] args){
		Tool MyTool=new Tool();
		int day=1;
		int receiveNum=MyTool.peachNum(day);
		System.out.println("day "+day+" has "+receiveNum+" peaches");
	}

}


class Tool{
	public int peachNum(int day){
		/*猴子吃桃，每天吃掉前一天的一半，再多吃一个
		第10天时，还没开始吃，桃子只剩下一个，问第一天有多少个桃子
		做法：day10=day9/2-1---->day9=2*(day10+1)---->4个
		同理：day1=2*(day2+1)
		 */
		if(day==10){
			return 1;
		}else if(day>=1&&day<=9){
			return 2*(peachNum(day+1)+1);
		}else{
			System.out.println("please input num 1~10");
			return -1;
		}
	}
}

“汉诺塔”
public class HanoiTower{
	public static void main(String[] args){
		Tower myTool=new Tower();
		myTool.move(5,'A','B','C');
	}
}

class Tower{

	//将所有盘子从a柱移到c柱上
	public void move(int num,char a,char b,char c){//num:盘子总数；a,b,c:三根柱子的名字
		if(num==1){
			System.out.println(a+" --> "+c);
		}else{
			/*
			盘子数不是一个时，将盘子分成两堆，最下面一个为一堆，上面的
			所有为一堆；
			（1）需要将上面的所有先借助c挪到b上；
			（2）然后将最下面一个从a挪到c上；
			（3）最后借助a将b上面的那堆移到c上；
			 */
			//（1）需要将上面的所有先借助c挪到b上；
			move(num-1,a,c,b);	//从a开始挪，借助c,最后挪至b上；
			//（2）然后将最下面一个直接从a挪到c上；
			System.out.println(a+" --> "+c);
			//（3）最后借助a将b上面的那堆移到c上；
			move(num-1,b,a,c);	//从b开始挪，借助a，最终挪到c；
		}
	}
}

/*
小老鼠出迷宫的代码
作者:shawya
 */
public class MiGong{

	public static void main(String[] args){
		//(1)首先用一个8行7列的二维数组来表示迷宫
		//(1)数组中值为0表示：可以走；1：障碍物
		int[][] map;
		map=new int[8][7];
		//将第一行和最后一行，第一列和最后一列上的元素值全部置为1，表示边界墙
		for(int i=0;i<7;i++){
			map[0][i]=1;
			map[7][i]=1;
		}
		for(int j=0;j<8;j++){
			map[j][0]=1;
			map[j][6]=1;
		}
		//再添加地图中间的障碍物
		map[3][1]=1;
		map[3][2]=1;

		//打印原始迷宫
		System.out.println("before findway,the map is:");
		for(int i=0;i<8;i++){
			for(int j=0;j<7;j++){
				System.out.print(map[i][j]+" ");
			}
			System.out.println();
		}


		//执行走迷宫的方法
		Tool MyFind=new Tool();
		Tool.findway(map,1,1);
		//打印走完后的迷宫，2表示通路
		System.out.println("after findway,the map is:");
		for(int i=0;i<8;i++){
			for(int j=0;j<7;j++){
				System.out.print(map[i][j]+" ");
			}
			System.out.println();
		}


	}
}

class Tool{
	public static boolean findway(int[][] map,int i,int j){//传参：地图，起始点坐标
		//0:可以走但还未尝试的点；1：障碍物；2：可以走通的点；3：走不通的点
		//如果map[6][5]=2,则说明已经找到了通路
		//在每个位置的找路方向是：先右侧-下侧-左侧-上侧
		if(map[6][5]==2){//递归退出条件是当重点的元素值为2，即最后一个点通路
			return true;
		}else{
			if(map[i][j]==0){
				//假设能走通：
				map[i][j]=2;
				//按照搜索顺序进行搜索
				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 if(findway(map,i-1,j)){
					return true;
				}else{
					map[i][j]=3;
					return false;
				}

			}else{//当前元素值为1,2,3都说明它已经被处理过了，所以直接return就行
				return false;
			}
		}
	}
}

“八皇后”
public class EightQueen{

	public static void main(String[] args){
		int[] arr=new int[8];
		Queen myTool=new Queen();
		myTool.put(arr,0);
	}

}


class Queen{
	public boolean put(int[] arr,int i){
	/*
	将八皇后棋盘（8x8）当做一个一维数组arr[0~7]=val;
	数组的下标表示每一行，值表示每一行放棋子的位置;
	思考：
	递归终止条件：
	如果只有一行，那就直接放在第一个
	如果有多个：其实要对比的就是首先下标对应的位置不能存在元素，其次不能和前一个下标位置形成对角
	 */
		if(i==8){
			print(arr);
			return true;
		}else{
			for(int k=0;k<8;k++){
				arr[i]=k;
				if(judge(arr,i)){
					put(arr,i+1);
				}
			}
			return false;
		}
	}
	

	public void print(int[] arr){
		for(int m=0;m<8;m++){
			System.out.print(arr[m]);
		}
		System.out.println();
	}


	public boolean judge(int[] arr,int curRow){//判断当前行放置的是否满足条件
		for(int n=0;n<curRow;n++){//判断已经摆放的列不能和现有的列相同，并且他们不能在一条斜线上
			if(arr[n]==arr[curRow]||Math.abs(curRow-n)==Math.abs(arr[curRow]-arr[n])){
				return false;
		}
	}
		return true;
	}
}

4.方法的重载

（1）方法重载有利用接口编程，并且减少了起名记名的麻烦；
（2）方法重载的细节：
方法名必须相同，形参必须不完全相同，返回值类型无要求；

5.方法-可变形数

（1）可变形参的表达形式为

public void my_func(int… num){}//这里的…表示参数个数不确定

（2）可变形参使用注意事项

6.变量的作用域

（1）类中全局变量的有初始化默认值，初始化可以不赋值；但局部变量没有初始值，初始化必须赋值；（放在类中即为全局变量，在整个类中生效，放在方法中则为局部变量）
（2）类中的全局变量可以加修饰符(public,private等)，局部变量不能加修饰符

7.构造器

（1）构造器细节

8.对象创建流程分析

上述案例中，对象创建时内存执行流程如下：
（1）首先从方法区加载Person类的放到堆区，也就是加载编译得到的Person.class文件；
（2）然后属性age和name初始化，分别为0和Null;
（3）接下来执行age=90;
（4）然后才会进行构造器的初始化，name=n,age=a；此时“小倩”、“20”才派上用场；
（5）最后才将堆的地址传给p；
最后的p只是对象的引用，真正的对象在堆中

8.this

（1）this用来指对象本身，它存在于对象的堆中，并且值为对象的地址；

（2）this使用注意事项

9.匿名对象