类的成员：属性和方法

• 一、类中属性的使用
• 1. 属性的语法格式
• 1.1 修饰符

• 2.1 区别
• 2.2 属性的赋值和取值

• 1.理解
• 1.1 定义
• 1.2 方法的常见类型：

• 2.1 自定义方法的声明
• 2.2 相关标准

• 5.1 具体使用

• 6.1 定义

• 7.1 方法的形参的传递机制：值传递

一、类中属性的使用

1. 属性的语法格式

属性语法格式：修饰符 数据类型 属性名 = 初始化值;

1.1 修饰符

修饰符：private、缺省（常用）、protected、public； static、final、transient、volatile (暂不考虑)
注意：

1. 具体项目设计中，属性一般设置为私有的private（考虑封装性）；
2. 后面，讲反射会在讲到属性的修饰符

2.属性的分类

1. 成员变量（在方法体外，类体内声明的变量）
   成员变量：实例变量（不以static修饰）；类变量（静态属性）（以static修饰）
2. 局部变量（在方法体内部声明的变量）。
   局部变量：形参（方法、构造器中定义的变量）；方法局部变量（在方法内定义）；代码块局部变量（在代码块内定义）

2.1 区别

相同点：

1. 定义变量的格式相同：数据类型 变量名 = 变量值
2. 都是先声明，后使用
3. 变量都有其对应的作用域

不同点：

1. 在类中声明的位置的不同
   属性(Field)：直接定义在类的一对{}内
   局部变量(Parameter)：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2. 于权限修饰符的不同
   属性：可以在声明属性时，指明其权限，使用权限修饰符。
   常用的权限修饰符：private、缺省、protected、public —>封装性（声明属性时，常用private）。
   局部变量：不可以使用权限修饰符。
3. 默认初始化值的情况（无参构造方法）：
   属性：类的属性，根据其类型，都有默认初始化值。
   整型（byte、short、int、long）：0
   浮点型（float、double）：0.0
   字符型（char）：(char)0 （或’\u0000’）
   布尔型（boolean）：false
   引用数据类型（类、数组、接口）：null（系统常量）
   局部变量：没有默认初始化值。
   意味着，我们在调用局部变量之前，一定要显式赋值。
   特别地：形参在调用时，我们赋值即可。
4. 在内存中加载的位置：
   属性：加载到堆空间中（非static）或静态域（static）中；
   局部变量：加载到栈空间

2.2 属性的赋值和取值

1. 赋值（修改对象的属性值）：通过普通方法，setter； set属性名（命名规则同类名）
2. 取值（获取对象的属性值）：通过普通方法，getter； get属性名（命名规则同类名），用return 返回值。

3.程序中成员变量赋值的执行顺序：

1. 声明成员变量的默认初始化
2. 显式初始化、多个初始化块依次被执行（同级别下按先后顺序执行）
3. 构造器再对成员进行初始化操作
4. 通过”对象.属性”或”对象.方法”的方式，可多次给属性赋值
5. 静态代码块中赋值
   以上操作的先后顺序：1 - 2/ 5 - 3 - 4
   2 / 5 具体的执行顺序按程序代码的先后为准

二、 方法

1.理解

1.1 定义

定义：（描述类应该具有的功能）方法是类或对象行为特征的抽象，用来完成某个功能操作。
比如：Math类： sqrt()\random() …
Scanner类： nextXxx() …
Arrays类： sort() \ binarySearch() \ toString() \ equals() \ …
注意：

1. .Java里的方法不能独立存在，所有的方法必须定义在类里。
2. 方法讲究 单进单出。
   单进：方法的参数列表尽可能的精简高效，采用尽可能少的参数实现预期功能，例如 可变数量形参，类及数组。
   单出：通常来讲，一个方法只有 1个出口， 1个return；

1.2 方法的常见类型：

1. 入口方法：public static void main(String[] args){……}
2. 构造方法（构造器）：public 类名（参数列表）{……}
3. toString方法：类信息
4. 自定义方法：

2.自定义方法

2.1 自定义方法的声明

权限修饰符 返回值类型 方法名(形参列表){
方法体程序代码
return;}
注意：static、final、abstract、synchronize 来修饰的方法，后面再讲。

2.2 相关标准

1. 关于权限修饰符：Java规定的4种权限修饰符：private、缺省default、protected 、public -->封装性再细说
2. 返回值类型（方法的出口）： 有返回值 vs 没有返回值
   1 如果方法有返回值，则必须在方法声明时，指定返回值的类型（返回类型 >= 值类型）。
   同时，方法中，需要使用return关键字来返回指定类型的变量或常量：“return 数据”。
   2 如果方法没有返回值，则方法声明时，使用void来表示。
   通常，没有返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
   思考：我们定义方法该不该有返回值？
   ① 题目要求； ② 凭经验：具体问题具体分析。
3. 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
4. 形参列表（方法的入口）： 方法可以声明0个，1个，或多个形参。
   格式：数据类型1 形参1,数据类型2 形参2,…
   0个：无参； 1～３个：直接入参；
   4个以上：封装入参。
   （同类型，采用可变个数形参（或者封装为数组形式入参）；不同类型，采用封装（类）对象入参）
   思考：我们定义方法时，该不该定义形参？
   ① 题目要求； ② 凭经验：具体问题具体分析。
5. 方法体：方法功能的体现。

3.return关键字（方法级跳转语句）

使用范围：使用在方法体中
作用：

1. 结束方法
2. 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
   注意点：return关键字后面不可以声明执行语句。

4.方法的使用

1. 调用当前类的属性或方法。
2. 特殊的：（递归方法）方法A中又调用了方法A。

注意：

1. 方法中，不可以定义方法。
2. 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
   递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

5.可变个数形参的方法

1. jdk 5.0新增的内容 Varargs(variable number of arguments)机制

5.1 具体使用

1. 可变个数形参的格式：
   方法名(参数的类型名（数据类型） …参数名（变量名）)
   例：public static void test(int a ,String…books);
2. 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
3. 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
4. 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
5. 可变个数形参在方法的形参中，必须声明在末尾
6. 可变个数形参在方法的形参中,最多只能声明一个可变形参。

6.方法的重载 overload

6.1 定义

定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
“两同一不同”:
同一个类、相同方法名；
（形参）参数列表不同，参数个数不同，参数类型不同；
注意：

1. 形参列表是有顺序的。public void getSum(String s ,int i)跟 public void getSum(int i,String s)构成重载。
2. 判断是否是重载：跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
   ② 在通过对象调用方法时，如何确定某一个指定的方法：
   方法名 —> 参数列表

7.关于变量的赋值

变量是基本数据类型，此时赋值的是变量所保存的数据值。
变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

7.1 方法的形参的传递机制：值传递

方法，必须由其所在类或对象调用才有意义。
若方法含有参数

1. 形参：方法声明时的参数（方法定义时，声明的小括号内的参数）（确定参数的类型）；
2. 实参：方法调用时，实际传递给形参的数据（确定参数的值）；

值传递机制：
3. 形参是基本数据类型，此时实参赋给形参的是实参真实存储的数据值，（将实参基本数据类型变量的“数据值”传递给形参）
4. 形参是引用数据类型，此时实参赋给形参的是实参存储数据的地址值（数据类型需要一致）。（将实参引用数据类型变量的“地址值”传递给形参）

三、代码展示

// 变量的赋值操作测试。
class ValueTransferTest {
public static void main(String[] args) {
System.out.println("***********基本数据类型：****************");
int m = 10;
int n = m;
System.out.println("m = " + m + ", n = " + n);
n = 20;
System.out.println("m = " + m + ", n = " + n);

System.out.println("***********引用数据类型：****************");
Order4 o1 = new Order4();
o1.orderId = 1001;
Order4 o2 = o1;  //赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
}
}
class Order4{
int orderId;
}

//方法的形参的传递机制：值传递 。
class ValueTransferTest1 {
public static void main(String[] args) {
int m = 10;
int n = 20;
System.out.println("m = " + m + ", n = " + n);
//交换两个变量的值的操作
//		int temp = m ;
//		m = n;
//		n = temp;

ValueTransferTest1 test = new ValueTransferTest1();
test.swap(m, n);
System.out.println("m = " + m + ", n = " + n);

}
public void swap(int m,int n){
int temp = m ;
m = n;
n = temp;
}
}
class ValueTransferTest2 {
public static void main(String[] args) {
Data data = new Data();
data.m = 10;
data.n = 20;
System.out.println("m = " + data.m + ", n = " + data.n);

//交换m和n的值
//		int temp = data.m;
//		data.m = data.n;
//		data.n = temp;
ValueTransferTest2 testFM = new ValueTransferTest2();
testFM.swap(data);
System.out.println("m = " + data.m + ", n = " + data.n);
}
public void swap(Data data){
int temp = data.m;
data.m = data.n;
data.n = temp;
}
}
class Data{
int m;
int n;
};