【Java学习笔记13】面向对象Part Ⅲ：类的成员——属性和方法

一、类的成员之一：属性(field)

1.1 语法格式

修饰符 数据类型 属性名 = 初始化值 ; 

说明：

• 修饰符 ：常用的权限修饰符有：private、缺省、protected、public ；其他修饰符：static、final (暂不考虑)
• 数据类型 ：任何基本数据类型(如int、Boolean) 或 任何引用数据类型。
• 属性名：属于标识符，符合命名规则和规范即可。

举例：

public class Person{ 
    private int age; //声明private变量 age 
    public String name = “Lila”;//声明public变量 name 
}

1.2 成员变量与局部变量

在方法体外，类体内声明的变量称为成员变量；在方法体内部声明的变量称为局部变量。

例如：

class User{
	//属性（或成员变量）
	String name;
	public int age;
	boolean isMale;

	public void talk(String language){//language:形参，也是局部变量
		System.out.println("我们使用" + language + "进行交流");
		
	}	
	public void eat(){
		String food = "烙饼";//局部变量
		System.out.println("北方人喜欢吃：" + food);
	}	
}

成员变量和局部变量比较：

相同点：

• 定义变量的格式：数据类型 变量名 = 变量值
• 先声明，后使用
• 变量都有其对应的作用域

不同点见下表：

	成员变量	局部变量
声明的位置	直接声明在类中	方法形参或内部、代码块内、构造器内等
修饰符	private、public、static、final等	不能用权限修饰符修饰，可以用final修饰
初始化值	有默认初始化值	没有默认初始化值，必须显式赋值，方可使用
内存加载位置	堆空间 或 静态域内	栈空间

说明：

• 成员变量更形象的说，是直接定义在类的一对{}内；局部变量更详细的说，是声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量。
• 成员变量可以在声明属性时，指明其权限，使用权限修饰符；而局部变量不可以。
• 常用的权限修饰符：private、public、缺省、protected 。此处不详细展开，等到讨论封装性的时候再详细论述。
• 成员变量，根据其类型，都有默认初始化值，与数组的默认初始化值一致。

成员变量类型	成员变量初始值
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0
char	0 或写为:’\u0000’(表现为空)
boolean	false
引用数据类型（类、数组、接口）	null

• 局部变量没有默认初始化值，意味着在调用局部变量之前，一定要显式赋值。特别地：形参在调用时赋值即可。

二、类的成员之二： 方法(method)

2.1 方法的概念

方法是类或对象行为特征的抽象，用来完成某个功能操作。在Java中，方法描述类应该具有的功能。在某些语言中也称为函数或过程。

将功能封装为方法的目的是，可以实现代码重用，简化代码。

Java里的方法不能独立存在，所有的方法必须定义在类里。

举例：

public class Person{ 
    private int age; 
    public int getAge() { //声明方法getAge() 
        return age; 
    } 
    public void setAge(int i) { //声明方法setAge 
        age = i; //将参数i的值赋给类的成员变量age 
    } 
}

2.2 方法的声明

语法格式：

权限修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛ 
    方法体程序代码 
    return 返回值; 
｝

说明：

• 权限修饰符：public,缺省,private, protected等 。
• 返回值类型：没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可 以不必使用return语句，如果使用，仅用来结束方法； 有返回值，声明出返回值的类型，与方法体中return 返回值搭配使用 。
• 方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意” 。
• 形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开 。
• 返回值：方法在执行完毕后返还给调用它的程序的数据。
• 方法的使用：可以调用当前类的属性和方法，特别地，方法A中又调用了方法A，这种方法称为递归方法。但是，方法中不能定义另外的方法。

2.3 方法的调用及案例

方法通过方法名被调用，方法被调用一次，就会执行一次，且只有被调用才会执行。

对象数组案例：
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。

• 问题一：打印出3年级(state值为3）的学生信息。
• 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

提示：

1. 生成随机数：Math.random()，返回值类型double;

2. 四舍五入取整：Math.round(double d)，返回值类型long。

类声明

public class Student {
    int number;//学号
    int state;//年级
    int score;//成绩

    //显示学生信息的方法
    public String info() {
        return "学号：" + number + ",年级：" + state + ",成绩：" + score;
    }
}

测试类：

public class StudentsTest {
    public static void main(String[] args) {
        //声明Student类型的数组
        Student[] stus = new Student[20];
        for (int i = 0; i < stus.length; i++) {
            //给数组元素赋值
            stus[i] = new Student();
            //给Student对象的属性赋值
            stus[i].number = (i + 1);
            //年级：[1,6]
            stus[i].state = (int) (Math.random() * (6 - 1 + 1) + 1);
            //成绩：[0,100]
            stus[i].score = (int) (Math.random() * (100 - 0 + 1));
        }
        
        StudentsTest test = new StudentsTest();
        //遍历学生数组
        test.print(stus);
        System.out.println("********************");
        //问题一：打印出3年级(state值为3）的学生信息。
        test.searchState(stus, 3);
        System.out.println("********************");
        //问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
        test.sort(stus);
        //遍历学生数组
        test.print(stus);
    }

    /**
     * 遍历Student[]数组的操作
     *
     * @param stus
     */
    public void print(Student[] stus) {
        for (int i = 0; i < stus.length; i++) {
            System.out.println(stus[i].info());
        }
    }

    /**
     * 查找Stduent数组中指定年级的学生信息
     *
     * @param stus
     * @param state
     */
    public void searchState(Student[] stus, int state) {
        for (int i = 0; i < stus.length; i++) {
            if (stus[i].state == state) {
                System.out.println(stus[i].info());
            }
        }
    }

    /**
     * 给Student数组排序
     *
     * @param stus
     */
    public void sort(Student[] stus) {
        for (int i = 0; i < stus.length - 1; i++) {
            for (int j = 0; j < stus.length - 1 - i; j++) {
                if (stus[j].score > stus[j + 1].score) {
                    //如果需要换序，交换的是数组的元素：Student对象！！！
                    Student temp = stus[j];
                    stus[j] = stus[j + 1];
                    stus[j + 1] = temp;
                }
            }
        }
    }

}

三、匿名对象

理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象

特征：匿名对象只能调用一次。

使用：

public class InstanceTest {
	public static void main(String[] args) {		
		//匿名对象
//		new Phone().sendEmail();
//		new Phone().playGame();

		new Phone().price = 1999;
		new Phone().showPrice();//0.0
		
		//**********************************
		PhoneMall mall = new PhoneMall();
		//匿名对象的使用
		mall.show(new Phone());
		
	}
}

class PhoneMall{
	public void show(Phone phone){
		phone.sendEmail();
		phone.playGame();
	}
}
class Phone{
	double price;//价格
	
	public void sendEmail(){
		System.out.println("发送邮件");
	}
	public void playGame(){
		System.out.println("玩游戏");
	}
	public void showPrice(){
		System.out.println("手机价格为：" + price);
	}
}