构造与方法重载

知识回顾

对象：现实世界中客观存在的物体都是对象，由属性和方法组成
属性：描述对象的特征
方法：描述对象的行为
类：具有相同属性和方法的多个对象的集合
类是抽象的，对象是具体的
类是一个模板，对象是一个特例

定义类：
public class 类名{
//定义属性
//访问权限修饰符 数据类型 属性名(变量名);

//定义方法
//访问权限修饰符 返回值类型 方法名(参数列表){方法体}
}

创建对象：
类名 对象名 = new 类名();
给对象属性赋值：
对象名.属性名 = 属性值;
对象调用方法：
对象名.方法名();

package cn.bdqn.demo01;

public class Student {
	
	//定义属性
	public String name;
	public int age;

}

package cn.bdqn.demo01;

public class StudentMethod {

	// 定义一个方法实现：在保存了多个学生对象的数组中，指定查找区间，查找某个学生姓名并显示是否查找成功
	public static boolean searchStudent(Student[] stus, int start, int end,
			String name) {

		boolean result = false;

		// 将你指定的区间里的学生对象遍历出来，然后将遍历出来的学生姓名与你要查找的学生姓名进行比较，如果相同，结束别叫并返回true，否则返回false
		for (int i = start; i <= end; i++) {
			if (stus[i].name.equals(name)) {
				result = true;
				break;
			}
		}

		return result;

	}

}

package cn.bdqn.demo01;

public class Test {

	public static void main(String[] args) {
		
		//准备一个数组，数组中存放的是Student类的对象，所以数组的类型是Student
		
		Student stu1 = new Student();
		stu1.name = "张三";
		stu1.age = 22;
		
		Student stu2 = new Student();
		stu2.name = "李四";
		stu2.age = 24;
		
		Student stu3 = new Student();
		stu3.name = "王五";
		stu3.age = 22;
		
		Student stu4 = new Student();
		stu4.name = "赵六";
		stu4.age = 23;
		
		Student stu5 = new Student();
		stu5.name = "如花";
		stu5.age = 25;
		
		Student[] students = {stu1,stu2,stu3,stu4,stu5};
		
		boolean bool=StudentMethod.searchStudent(students, 1, 4, "如花");
		System.out.println("students数组中有你要找的学生："+bool);
	}

}

注意public void calc2(Student student)的区别：
调用的是地址。

package cn.bdqn.demo02;

public class Student {
	
	int age;

}

package cn.bdqn.demo02;

public class Test {
	public void calc1(int num) {
		num = num + 1;
		System.out.println(num);
	}

	public void calc2(Student student) {
		student.age = student.age + 1;
		System.out.println("方法内的学生年龄："+student.age);
	}
	
	
	public static void main(String[] args) {
		//创建Test类对象
		Test test = new Test();
		int n=8;
		System.out.println(n);//8
		test.calc1(n);
		System.out.println(n);//8
		
		System.out.println("------------------");
		
		Student stu=new Student();
		stu.age=18;
		
		System.out.println(stu.age);//18
		
		
		test.calc2(stu);
		System.out.println(stu.age);//19
	}

}

构造与方法重载

构造方法

1. 无返回值类型
2. 方法名与类名相同
3. 可以指定参数

作用：
对象初始化

• 每个类都有个默认的无参构造方法

方法重载

• 在同一个类中，多个方法的方法名相同，参数列表不同，就构成方法重载

特点：
* 1）在同一个类中
* 2）方法名相同
* 3）参数列表不同（参数个数、参数顺序、参数类型）
* 4）与访问权限修饰符和返回值类型无关

package cn.bdqn.demo03;

public class CalculateTest {

	public static void main(String[] args) {
		//创建Calculate对象
		Calculate c = new Calculate();
		int result1 =c.sum(10, 20);
		System.out.println(result1);
		
	}

}

package cn.bdqn.demo03;

public class GirlFriend {
	//定义属性
	String name;
	char gender;
	int age;
	double height;
	double weight;
	String address;
	String phoneNum;
	double salary;
	String hobby;
	
	
	//添加无参构造方法
	public GirlFriend(){}

	//添加有参构造方法
	public GirlFriend(String name, char gender, int age, double height,
			double weight, String address, String phoneNum, double salary,
			String hobby) {
		this.name = name;
		this.gender = gender;
		this.age = age;
		this.height = height;
		this.weight = weight;
		this.address = address;
		this.phoneNum = phoneNum;
		this.salary = salary;
		this.hobby = hobby;
	}

	public GirlFriend(String name, int age) {
		this.name = name;
		this.age = age;
	}
}

this

表示一个对象，表示当前对象，谁调用这个构造方法，this就表示谁

package cn.bdqn.demo03;

public class Student {

	String name;
	int age;
	double height;
	double weight;

	// 手动添加一个无参构造方法
	public Student() {
	}

	// 添加一个有参构造方法
	// public Student(String str, int num, double a, double b) {
	// name = str;
	// age = num;
	// height = a;
	// weight = b;
	// }

	
	public Student(String name, int age, double height, double weight) {
//		this：表示一个对象，表示当前对象，谁调用这个构造方法，this就表示谁
		this.name = name;
		this.age = age;
		this.height = height;
		this.weight = weight;
	}

}

构造方法

用来创建对象的方法（实例化对象的方法）

构造方法的特点：
* 1）构造方法没有返回值，连void也不写。
* 2）构造方法的方法名与类名相同。
* 3）每创建一个类，系统自动为这个类添加一个无参构造方法（默认存在）。
* 4）当你在类中添加了其它的构造方法后，默认的无参构造方法会被覆盖，如果你还想使用无参构造方法，需要手动添加

package cn.bdqn.demo03;

public class Test {

	public static void main(String[] args) {
		//创建Student类对象
		Student stu1 = new Student();
		stu1.name = "张三";
		stu1.age = 22;
		stu1.height = 180;
		stu1.weight = 158;
		
		//通过有参构造方法来创建对象
		Student stu2 = new Student("王五", 26, 176, 148);
		System.out.println(stu2.name);
		System.out.println(stu2.age);
		System.out.println(stu2.height);
		System.out.println(stu2.weight);
		
		Student stu3 = new Student("王二麻子", 32, 171, 139);
	}

}

this()

• 调用其它构造方法，必须写在构造方法的第一行

package cn.bdqn.demo04;

public class Student {
	
	String name;
	int age;
	double height;
	
	public Student() {
		System.out.println("我是无参构造方法");
	}

	public Student(String name, int age, double height) {
		//调用其它构造方法，必须写在构造方法的第一行
		this();
		System.out.println("我是有参构造方法");
		//this调用属性
		this.name = name;
		this.age = age;
		this.height = height;
	}
	
	public void printName(){
		System.out.println("学生姓名："+this.name);
	}
	
	public void printInfo(){
		//this调用其它普通方法
		this.printName();
		System.out.println("学生年龄："+this.age);
	}

}

package cn.bdqn.demo04;

public class StudentTest {

	public static void main(String[] args) {
		
		Student stu = new Student("张三", 22, 178);
		
		stu.printInfo();

	}

}

局部变量

• 定义在方法或者某些结构中的变量，只能作用在方法中或者定义它的结构中

成员变量（全局变量）

• 定义在类中方法外（某些结构外）的变量，能够作用在整个类中
• 系统会给成员变量赋予一个默认值,局部变量必须先初始化（赋值）才能使用，系统不会给局部变量赋予默认值
• 同一个类中不能有同名的成员变量(全局变量),在同一个方法或者结构中，不能有同名的局部变量,不同的方法中可以有同名的局部变量
• 同一个类中可以有同名的成员变量和局部变量,但是局部变量具有更高的优先级

package cn.bdqn.demo06;

public class Demo01 {
	// 定义在类中，方法外
	int num = 10;
//	int num = 200;

	public void print() {
		// a定义在print()方法中，只在当前这个方法中可以使用
		int a = 100;
		// int a = 200;
		System.out.println(a);
		int num = 20;
		System.out.println(num);
	}

	public void printInfo() {
		int a = 300;
		// System.out.println(a);
	}

	public static void main(String[] args) {
		for (int i = 0; i <= 100; i++) {
			System.out.println(i);
		}

		// System.out.println(i);
	}

}