面向对象之类的成员：属性、方法、构造器

类的成员之一：属性

语法格式：

修饰符 数据类型 属性名 = 初始化值 ;
说明1: 修饰符
常用的权限修饰符有：private、缺省、protected、public
其他修饰符：static、final (暂不考虑)
说明2：数据类型
任何基本数据类型(如int、Boolean) 或 任何引用数据类型。
说明3：属性名
属于标识符，符合命名规则和规范即可。

举例：

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

成员变量（属性）和局部变量的区别？

类的成员之二：方法

概念

方法(method、函数):

1. 方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
2. 将功能封装为方法的目的是，可以实现代码重用，简化代码
3. Java里的方法不能独立存在，所有的方法必须定义在类里。

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

声明格式

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

修饰符：public,缺省,private, protected等

返回值：方法在执行完毕后返还给调用它的程序的数据。 |

	没有返回值	有返回值
无形参	void 方法名() {}	返回值的类型 方法名() {}
有形参	void 方法名 (形参列表) {}	返回值的类型 方法名 (形参列表) {}

注意

1. 方法被调用一次，就会执行一次
2. 没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。
3. 定义方法时，方法的结果应该返回给调用者，交由调用者处理。
4. 方法中只能调用方法或属性，不可以在方法内部定义方法。

练习

public class Practise4 {
	public static void main(String[] args) {
		Practise4 p1 = new Practise4();
		p1.method(8,10);
		}
		int method(int m,int n) {
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				System.out.print("*");
			}
			System.out.println();
		}
		System.out.println(m*n);
		return m*n;
	}
}

/*
 * 4. 对象数组题目：
	定义类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 Practise5 {
	public static void main(String[] args) {
		//声明Student1类的数组，
		//与int[] s1 = new int[20];这类普通的数组声明类似
		//作用与基本数据类型一致，即能用基本数据类型，亦能用自创的类
		Student1[] s = new Student1[20];
		for(int i = 0;i< s.length;i++) {
			s[i]= new Student1();
			s[i].number = i+1;
			s[i].state = (int)(Math.random()*7 + 1);
			s[i].score = (int)(Math.random()*101);
			//打印出3年级(state值为3）的学生信息。
			if(s[i].state == 3) {
				System.out.println("学号："+s[i].number+","+"年级："+
			s[i].state+","+"成绩："+s[i].score);
			}			
		}
		System.out.println("***************");
		//问题二：使用冒泡排序按学生成绩排序
		for(int i=0;i<s.length-1;i++) {
			for(int j=0;j<s.length-1-i;j++) {
				if(s[j].score >s[j+1].score) {
					Student1 temp = s[j];
					s[j] = s[j+1];
					s[j+1] = temp;
				}
			}
		}
		//遍历所有学生信息
		for(int i=0;i<s.length;i++) {
			System.out.println("学号："+s[i].number+","
		+"年级："+s[i].state+","+"成绩："+s[i].score);
		}
		
	}
}
class Student1{
	int number;
	int state;
	int score;
}

方法重载

定义

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

注

1. 参数顺序不同亦为重载
   
2. 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系，严格按照定义来

练习

可变个数的形参

1. jdk 5.0新增的内容
2. 具体使用：
   2.1 可变个数形参的格式：数据类型 … 变量名
   2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
   2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
   2.4 可变个数形参（相当于就是数组）的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
   

2.5 可变个数形参在方法的形参中，必须声明在末尾

2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。

方法参数的值传递机制

本质

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

值传递练习

类的成员之三：构造器

作用

1. 创建对象

   

2. 初始化对象的信息（充当了set方法）

   

   

使用说明

1. 如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器

2. 定义构造器的格式：权限修饰符 类名(形参列表){}

   

3. 一个类中定义的多个构造器，彼此构成重载

4. 一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器

5. 一个类中，至少会有一个构造器。

练习

public class Test2 {
    public static void main(String[] args) {
        TriAngleTest triAngleTest = new TriAngleTest();
        System.out.println("三角形的面积为："+triAngleTest.area);//输出打印面积
    }
}
class TriAngle{
    private int base;//三角形的低
    private int height;//三角形的高
    public TriAngle(int b,int h){//起到set的作用
        base = b;
        height = h;
    }
    public int getBase(){
        return base;
    }
    public int getHeight(){
        return height;
    }
}
class TriAngleTest{
    TriAngle triAngle = new TriAngle(3,4);
    int area = triAngle.getBase()*triAngle.getHeight()/2;//计算三角形面积
}

public class Student {
    public static void main(String[] args) {
        Student student1 = new Student("张三",18);
        Student student2 = new Student("李四",19,"广州华商学院");
        Student student3 = new Student("王五",18,"电子科技大学","计算机科学与技术");
        System.out.println(student1.getAge()+"\t"+student1.getAge());
        System.out.println(student2.getAge()+"\t"+student2.getAge()+"\t"+student2.getSchool());
        System.out.println(student3.getAge()+"\t"+student3.getAge()+"\t"+student3.getSchool()+"\t"+student3.getMajor());
    }
    private String name;
    private int age;
    private String school;
    private String major;
    public Student(String n,int a){
        name = n;
        age = a;
    }
    public Student(String n,int a,String s){
        name = n;
        age = a;
        school = s;
    }
    public Student(String n,int a,String s,String m){
        name = n;
        age = a;
        school = s;
        major = m;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    public String getSchool(){
        return school;
    }
    public String getMajor(){
        return major;
    }
}

属性赋值顺序

1. 默认初始化
2. 显示初始化
3. 构造器初始化
4. 通过"对象.方法" 或 "对象.属性"的方式来赋值

以上操作的先后顺序：① -->② -->③ --> ④

JavaBean的概念

1. 类是公共的
2. 一个无参的公共的构造器
3. 属性是private且有对应的get、set方法