目录：
方法
递归方法：
方法重载：
变量
方法
方法的所属性
从语法定义的角度来看，方法必须定义在类中。
方法到底是属于类？还是属于对象
有 static 修饰的方法，属于类本身。而不是属于实例的。
没有 static 修饰的方法，属于实例。
调用方法时
调用方法时，必须要有主调对象（主语，调用者）
Java方法的参数传递机制：
只有一种：值传递。（副本传递）
形参个数可变的方法：
定义形参时，用法 type... 形参名
本质是数组
注意点：
A. 每个方法最多【只能有一个】形参个数可变的参数
B. 形参个数可变的参数必须【位于最后】
VarArgs 程序 及 运行结果：
public class VarArgs
{
public void test(int age)
{
System.out.println("age参数值为：" + age);
}
// int...代表可以传入0~N个int类型参数值
public void info(int...nums)
{
// 在方法中，nums本质相当于一个数组。
for(int num:nums)
{
System.out.println("----" + num);
}
}
public static void main(String[] args)
{
// 定义一个va变量，va变量指向VarArgs实例
VarArgs va = new VarArgs();
va.test(3);
va.info(30,40,50,60,61);
va.info();
}
}
递归方法：
它里面包含了一个隐式循环：递归就是在方法中再次调用自己
递归，一定要保证：在合适的时候结束调用自身。
注意：递归，一定要【向 “结束” 的】那一端递归
RecursiveTest 程序 及 运行结果：
public class RecursiveTest
{
//该方法属于类
public static int fn(int n)
{
/**
如果 f(0) = 2,f(1) = 3,f(n) = f(n + 2) - 2*f(n + 1);
令 N = n + 2；
f(N-2) = f(N) - 2*f(N-1)
f(N) = f(N-2) + 2*f(N-1)
f(n) = f(n - 2) + 2*f(n - 1)
问：f(20) = ?
*/
if(n == 0)
{
return 2;
}
if(n == 1)
{
return 3;
}
// 在方法体内调用自身
return fn(n - 2) + 2*fn(n - 1);
}
public static void main(String[] args)
{
System.out.println(RecursiveTest.fn(20));
}
}
方法重载：
归纳： 两同、一个不同
两同：同一个类，方法名相同。
一不同：形参列表不同
注意点： A. 方法重载与【返回值类型】没有任何关系
B. 方法重载与【是否有static】没有任何关系
怎么才能确定唯一确定所调用的方法？
A。主调者。 // 谁调用方法。
B。方法名字 // 调用哪个方法？
C。匹配实参所对应的类型。
变量
Java 里没有全局变量的说法
成员变量（Field，在类里定义）两种
A. 实例变量。属于实例 没 static
B. 类变量。属于类本身 有static
局部变量： 三种
A. 方法里的局部变量。仅在该方法内有效
B. 代码块里的局部变量。仅在代码块内有效
C. 形参。在整个方法内有效
************************成员变量***********************
实例变量：
从有实例开始，实例变量就存在了。
实例被销毁，实例变量就不存在了。
0~N 个，程序每创建一个实例，系统就为该实例分配一块内存
类变量：
从有类开始，类变量就存在了。
一个 JVM 里，类信息只有一个。
每个 JVM 最多只加载一个类一次，系统就为该实例分配一块内存
规则：
系统会为成员变量执行【默认的初始化】
初始值的规则是：基本类型就是 0 / 0.0 / \u0000 / false
引用类型就是 null
当程序通过实例来访问类变量时，由于类变量本身不属于实例，因此底层实际上委托为通过类来访问的。
***********************局部变量***********************
局部变量是存在相应的方法栈中的。
局部变量必须由程序员来赋值，系统【不会】对局部变量执行默认的初始化。
规则：【局部变量不允许同名！】
即使一个是【代码块】内局部变量，一个是【方法内】局部变量，也是不允许的。
两个代码块中允许出现同名的局部变量
DemoTest （内存具体的分配）程序 及 运行结果：
class Demo
{
String name; // 实例变量，刚开始并不存在，因为没有分配内存
int age; // 实例变量，刚开始并不存在，因为没有分配内存
static int num; // 成员变量里的【类变量】，从有类开始，类变量就存在了。
}
public class DemoTest
{
public static void main(String[] args)
{
Demo d = null; // 局部变量 赋初始值值 此时还没有name 和 age
System.out.println("~~~~~" + d.num); // 实际是Demo.num
d = new Demo(); // name 和 age 出现
Demo d2 = new Demo(); // d2 指向的 name 和 age 出现
d.age = 20; // d.age的值变成了20
System.out.println("~~~~~" + d2.age); // d2.age 的值为0
d.num = 12; // 实际上是 Demo.num = 12
System.out.println(d2.num);// 实际上是 Demo.num
}
}
/*
成员变量：
A：在类方法外
B:在堆内存中
C:随着对象的创建而存在，随着对象的消失而销毁
D:有默认的初始化值
局部变量：
A:在方法定义中
B:在栈内存中
C:随着方法的调用而存在，随着方法的调用完毕而销毁
D:没有初始化的值，使用前必须定义和赋值
*/
以上
写在最后：
记录几个遇到的生疏词汇：
Permanent :永生代 （存放类信息）
VarArgs: 可变参数
LocalVar： 局部变量
今天发现简书还有另外一种编辑模式，真是打开了新世界的大门，它叫做 Markdown，很强大，但是目前不打算使用，虽然学习一下会比较方便好用，但是我觉得它有些限制了，就比如空格不能随心所欲的打~附一个链接，方便取用：Markdown 新手指南
今天很幸运，收到了apollo体验的机会，就在明天，哈哈。其实觉得看多了，写多了确实会提高点文采啊~
昨天今天两天没有去健身了，虽然觉得现在需要加大力度的赶，但是也想去健身啊啊啊啊啊~
