（1） 类是抽象的，概念的，代表一类事物， 比如人类、 猫类 … 即它是数据类型。
（2） 对象是具体的，实际的，代表一个具体事物 , 即实例 。
（3） 类是对象的模板，对象是类的一个个体，对应一个实例。
属性是类的一个组成部分，一般是基本数据类型，也可以是引用类型 ( 对象，数组 )。属性如果不赋值，有默认值。
（1）当程序执行到方法时，就会开辟一个独立的空间（栈空间）。
（2）当方法执行完毕，或者执行到 return 语句时，就会返回。
（3）返回到调用方法的地方。
（4）返回后，继续执行方法后面的代码。
（5）当 main 方法（栈）执行完毕，整个程序退出。
成员方法的定义：
访问修饰符 返回数据类型 方法名 （形参列表 .. ） {// 方法体
语句；
return 返回值 ;
}
递归重要规则
（1）执行一个方法时，就创建一个新的受保护的独立空间（栈空间）。
（2）方法的局部变量是独立的，不会相互影响，比如 n 变量。
（3）如果方法中使用的是引用类型变量（比如数组，对象），就会共享该引用类型的数据。
（4）递归必须向退出递归的条件逼近，否则就是无限递归，出现 StackOverflowError。
（5）当一个方法执行完毕，或者遇到 return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。
public class Demo {
public static void main(String[] args) {
int res = factorial(5);
System.out.println("5 的阶乘 res =" + res);
}
//factorial 阶乘
public static int factorial(int n) {
if (n == 1) {
return 1;
} else {
return factorial(n - 1) * n;
}
}
}
public class Demo {
public static void main(String[] args) {
int n = 7;
System.out.println("当 n=" + n + " 对应的斐波那契数=" + fibonacci(n));
}
/**
* 请使用递归的方式求出斐波那契数 1,1,2,3,5,8,13...给你一个整数 n，求出它的值是多
*/
public static int fibonacci(int n) {
if (n == 1 || n == 2) {
return 1;
} else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
}
public class Demo {
public static void main(String[] args) {
//桃子问题
int day = 1;
int peachNum = peach(day);
if (peachNum != -1) {
System.out.println("第 " + day + "天有" + peachNum + "个桃子");
}
}
/**
* 猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！
* 以后每天猴子都吃其中的一半，然后再多吃一个。当到第 10 天时，
* 想再吃时（即还没吃），发现只有 1 个桃子了。问题：最初共多少个桃子？
*/
public static int peach(int day) {
if (day == 10) {//第 10 天，只有 1 个桃
return 1;
} else if (day >= 1 && day <= 9) {
return (peach(day + 1) + 1) * 2;//规则，自己要想
} else {
System.out.println("day 在 1-10");
return -1;
}
}
}
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;
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 t = new T();
boolean way = t.findWay(map, 1, 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();
}
}
}
class T{
// 0:可以走 1:障碍物 2:可以走 3:走过但是走不通
// (6,5) = 2 说明成功
// 策略 下 > 右 > 上 > 左
public boolean findWay(int[][] map,int i ,int j){
if (map[6][5] == 2){
return true;
}else {
if (map[i][j] == 0){ // 当前位置为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 { // map[i][j] == 1,2,3
return false;
}
}
}
}
java 中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！
注意事项和使用细节：
（1）方法名：必须相同
（2）形参列表：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）。
（3）返回类型：无要求
java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。 就可以通过可变参数实现。
基本语法
访问修饰符 返回类型 方法名（数据类型... 形参名）{
}
public class Demo {
public static void main(String[] args) {
System.out.println(sum(1, 5, 100)); //106
System.out.println(sum(1, 19)); //20
}
//1. int... 表示接受的是可变参数，类型是 int ,即可以接收多个 int(0-多)
//2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
//3. 遍历 nums 求和即可
public static int sum(int... nums) {
int res = 0;
for (int i = 0; i < nums.length; i++) {
res += nums[i];
}
return res;
}
}
注意事项和使用细节
（1）可变参数的实参可以为 0 个或任意多个。
（2）可变参数的实参可以为数组。
（3）可变参数的本质就是数组。
（4）可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后。
（5）一个形参列表中只能出现一个可变参数。
[ 修饰符 ] 方法名 ( 形参列表 ){
方法体;
}
（1） 构造器的修饰符可以默认， 也可以是 public protected private。
（2） 构造器没有返回值。
（3） 方法名和类名字必须一样。
（4） 参数列表和成员方法一样的规则。
（5） 造器的调用， 由系统完成。
构造方法又叫构造器 (constructor) ，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：
（1） 方法名和类名相同
（2） 没有返回值
（3） 在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。
（1）一个类可以定义多个不同的构造器，即构造器重载。
（2）构造器名和类名要相同。
（3）构造器没有返回值。
（4）构造器是完成对象的初始化，并不是创建对象。
（5）在创建对象时，系统自动的调用该类的构造方法。
（6）如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器（也叫默认构造器）。
（7）一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下。
Java 虚拟机会给每个对象分配 this，代表当前对象。
this 的注意事项和使用细节：
（1） this 关键字可以用来访问本类的属性、方法、构造器。
（2） this 用于区分当前类的属性和局部变量。
（3） 访问成员方法的语法：【this. 方法名 ( 参数列表 );】。
（4） 访问构造器语法：【 this( 参数列表 );】 注意只能在构造器中使用（即只能在构造器中访问另外一个构造器, 必须放在第一条语句）。
（5） this 不能在类定义的外部使用，只能在类定义的方法中使用。