目录结构
⭕1. 方法概述
⭕2. 方法分类（实例方法和类方法）
⭕3. 值传递方法
⭕4. 实参与形参
⭕5. 传递方法
⭕6. 返回值方法
⭕7. 实例变量和类变量传递方法
⭕8. 构造方法
======================================
⭕#1.方法概述
- 一定条件下，同一类中，不同的方法之间可以相互调用。
- 方法是类的
。
- 对象的行为是由其方法来实现。
- 在方法声明时，通过修饰符可以对方法访问实施控制。在方法中，可以对类的成员变量进行访问，但
。
⭕2.方法分类（实例方法和类方法）
- 实例方法能对类变量和实例变量操作，而类方法
进行操作；
- 对方法不仅可以有对象调用而且还可以直接由类名调用，
。
⭕3.值传递方法
- 将调用方法的实参的值计算出来赋予被调用方法对应形参的一种数据传递方法。
- 在这种数据传递方法下，被调用方法对形参的计算，加工与对应的实参已完全脱离关系。
⭕4. 实参与形参
实参 ：全称为"实际参数"是在调用时传递给函数的参数. 实参可以是常量、变量、表达式、函数等， 无论实参是何种类型的量，在进行函数调用时，它们都， 以便把这些值传送给形参。 因此应预先用赋值，输入等办法使实参获得确定值。
形参 : 全称为"形式参数" 由于它不是实际存在变量，所以又称。是在定义函数名和函数体的时候使用的参数,
。因而，必须注意实参的个数，类型应与形参一一对应，并且实参必须要有确定的值。
区别：
- 形参出现在函数定义中，在整个函数体内都可以使用， 离开该函数则不能使用。
- 实参出现在主调函数中，进入被调函数后，实参变量也不能使用。
- 形参和实参的功能是作数据传送。发生函数调用时， 主调函数把实参的值传送给被调函数的形参从而实现主调函数向被调函数的数据传送。
-
形参变量只有在
，在调用结束时， 即刻释放所分配的内存单元。因此，形参只有在
。 函数调用结束返回主调函数后则不能再使用该形参变量。
-
实参可以是常量、变量、表达式、函数等， 无论实参是何种类型的量，在进行函数调用时，它们都
， 以便把这些值传送给形参。 因此应预先用赋值，输入等办法使实参获得确定值。
-
实参和形参在
， 否则会发生“类型不匹配”的错误。
- 函数调用中发生的数据传送是
。
- 当形参和实参不是指针类型时，在该函数运行时，形参和实参是不同的变量，他们在内存中位于不同的位置，形参将实参的内容复制一份，在该函数运行结束的时候形参被释放，而实参内容不会改变。而如果函数的参数是
变量,在调用该函数的过程中，传给函数的是实参的地址，在函数体内部使用的也是实参的地址，即使用的就是实参本身。所以在函数体内部
。
⭕5.传递方法
使用引用传递方法时，方法的参数类型一般是复合类型（引用类型）。复合类型变量中存储的是对象的引用，所以在参数传送中是传送引用，方法接收参数的引用，因此任何对形参的改变都会影响到对应的实参。“引用的单向传送，数据的双向传送”。
实例：
class Point{
int x,y;
void setXY(int x1,int y1){
x=x1;
y=y1;
}
void squarePoint(Point p){
p.x=p.x*p.x
p.y=p.y*p.y
}
}
public class j14{
public static void main (String args[]){
Point p0=new Point();
p0.setXY(10,20);
System.out.println("x="+p0.x+"...y="+p0.y);
p0.squarePoint(p0);
System.out.println("x="+p0.x+"...y="+p0.y);
}
}
结果：
x=10...y=20
x=100...y=400
⭕6.返回值方法
返回值方法不是在形参和实参之间传递数据，而是被调方法通过方法调用后直接将返回值送到调用方法中。使用返回值方法时，方法的返回值类型不能为void，且方法体中必须有带表达式的trun语句，其中表达式的值就是方法的返回值。
public class j15{
public static void main(String args[]){
int v1,v2;
v1=10; v2=12;
System.out.println("max(+v1+","+v2+)"=+max(v1,v2));
}
static int max(int x,int y)
{
if(x>y)
return x;
else
return y;
}
}
输出结果：
max(10,12)=12
⭕7.实例变量和类变量传递方法
①实例变量 ：是用来定义一个确定的对象(大象)，目的是方便给与对象的一些属性(年龄，性别...)，没有它就没有对象，属性也就无法表示。
②没有使用static修饰的成员变量是实例变量，属于该类的实例
类变量 ：使用static修饰的成员变量是类变量，属于该类本身**，可以被其他对象调用，值可以改变。
class Person {
static int eyeNum;
String name;
int age;
public void info() {
System.out.println("Name: " + name + ", Age: " + age);
}
}
public class FieldTest {
public static void main(String[] args) {
// 类变量属于该类本身，只要改类初始化完成，程序即可使用类变量
Person.eyeNum = 2; // ①
// 通过Person类访问 eyeNum类变量
System.out.println("Person的eyeNum属性：" + Person.eyeNum);
// 创建第一个Person对象
Person p1 = new Person();
p1.name = "zhangsan";
p1.age = 22;
System.out.println("通过p1变量访问eyeNum类变量：" + p1.eyeNum); // ②
p1.info();
// 创建第二个Person对象
Person p2 = new Person();
p2.name = "lisi";
p2.age = 30;
p2.info();
// 通过p2修改Person类的eyeNum类变量
p2.eyeNum = 4; // ③
System.out.println("通过p1变量访问eyeNum类变量：" + p1.eyeNum);
System.out.println("通过p2变量访问eyeNum类变量：" + p2.eyeNum);
System.out.println("通过Person类访问eyeNum类变量：" + Person.eyeNum);
}
}
结果：
Person的eyeNum属性：2
通过p1变量访问eyeNum类变量：2
Name: zhangsan, Age: 22
Name: lisi, Age: 30
通过p1变量访问eyeNum类变量：4
通过p2变量访问eyeNum类变量：4
通过Person类访问eyeNum类变量：4
⭕8.构造方法
- Java通过构造方法来保证对每个对象进行初始化,构造方法是一种特殊的方法。
- Java中的每个类都可以用构造方法，用来初始化该类的一个新的对象。构造方法具有和类名相同的名称，而且不返回任何数据类型（void可以省略）。在构造方法的实现中，也可以进行方法重载。在类中没有构造方法时，使用默认的构造方法。
- 当我们没有写构造方法的时候，系统会默认给我们添加一个无参构造方法。但是只要我们给出了一个构造方法，系统就不会给出默认的无参构造方法，所以在写类的时候，一般建议自己手动加上无参构造方法。
- 一个类中可能没有构造方法，此时使用默认的构造方法。使用默认的构造方法时，按照默认的方式对变量进行初始化，即数值型初始化为0，引用型初始化为null，逻辑型初始化为false。
①类 构造方法数量>=1 ，如果没写使用默认。
②默认构造方法的值为 0 false null
③多个构造方法 名字相同 不同的参数。
public class Constructor {
// 给Constructor类定义了一个成员变量name
private String name;
// 无参构造方法，方法名必须跟类名一致，即首字母需要大写
public Constructor() {
System.out.println("调用无参数的构造方法。。");
}
// 带一个参数的构造方法
public Constructor(String name) {
// 通过this()调用无参构造方法
this();
this.name = name;
// 构造方法里可以调用普通方法
commonMethod();
}
public void commonMethod() {
System.out.println("调用普通方法");
}
// 写个主函数测试一下
public static void main(String[] args) {
// 通过无参构造创建一个Constructor对象
Constructor cons1 = new Constructor();
cons1.name = "我是通过无参构造器创建的对象";
System.out.println(cons1);
System.out.println("=====================我是分隔线=====================");
// 通过有参构造方法创建另一个对象
Constructor cons2 = new Constructor("我是通过有参构造方法创建的对象");
System.out.println(cons2);
}
@Override
public String toString() {
return this.getClass().getSimpleName() + "[我的名字是：" + name + "]";
}
}
输出结果
调用无参数的构造方法。。
Constructor[我的名字是：我是通过无参构造器创建的对象]
=====================我是分隔线=====================
调用无参数的构造方法。。
调用普通方法
Constructor[我的名字是：我是通过有参构造方法创建的对象]
