Java 笔记 8：重载，参数，构造器

方法的参数传递机制：

实参-->形参

（1）形参是基本数据类型
实参赋值给形参的是数据值，形参值的修改不影响实参，因为实参是“copy，复制”了一份数据值给形参
（2）形参是引用数据类型
实参赋值给形参的是对象的地址值，如果形参修改了对象的属性值，那么实参对象的属性值也会修改。

陷阱：
当形参是引用数据类型，实参给形参地址值之后，
形参修改了地址值，那么和实参就无关了

方法的重载

在同一个类中，出现了两个或多个的方法名称相同，形参列表不同，称为方法的重载。
形参列表不同：形参的个数、数据类型不同
方法的重载和返回值类型无关。

为什么要有方法的重载？或者换句话说，为什么要声明多个方法名称相同呢？
（1）方法名代表方法的功能，这几个方法的功能是一样的，例如：都是找最大值
（2）为了调用者的方便，功能相同的方法取名一样的话，对于调用者来说就减少了学习和记忆的成本

	public static void main(String[] args){
		System.out.println(max(1,4));
		System.out.println(max(1.0,4.0));
		System.out.println(max(1,4,8));
	}
	
	//写一个方法，可以找2个整数的最大值
	public static int max(int a, int b){
		return a>b ? a : b;
	}
	//方法重载时，不去看返回值类型是否一致，只看方法名和形参列表
	//public static double max(int a,int b){
	//	return 0.0;
	//}
	
	//写一个方法，可以找2给小数的最大值
	public static double max(double a, double b){
		return a>b ? a : b;
	}
	
	//写一个方法，可以找3个整数的最大值
	public static int max(int a, int b, int c){
		int max = a > b ? a : b;
		max = max > c ? max : c;
		return max;
	}

命令行参数(了解)

给main方法传的实参，叫做命令行参数

格式：
java main所在的类名 实参1 实参2 …
例如：
java Test04_CommandParam hello java atguigu

可变参数

JDK1.5之后引入的
形参列表中出现了“数据类型… 形参名”形式的形参，就是可变参数。

包含可变参数的方法的调用原则：
（1）可变参数的形参部分，可以传入0~n个对应类型的实参，也可以传入对应类型的数组对象
（2）非可变参数的形参部分，原来该怎么传，现在还怎么传

可变参数的声明的原则：
（1）一个方法只能包含一个可变参数
（2）可变参数必须是形参列表的最后一个

参数：
（1）形参
（2）实参
（3）命令行参数
（4）可变参数
（5）…

	public static void main(String[] args){
		System.out.println(sum(1,2));
		
		int[] arr1 = new int[0];
		System.out.println("0个元素的累加和：" + sum(arr1));//可变参数部分，传入了对应类型的数组对象
		
		int[] arr2 = {1,2,3,4,5};
		System.out.println("5个元素的累加和：" + sum(arr2));//可变参数部分，传入了对应类型的数组对象
		
		System.out.println("0个元素的累加和：" + sum());//可变参数部分，传入了0个实参的int值
		System.out.println("5个元素的累加和：" + sum(1,2,3,4,5));//可变参数部分，传入了5个实参的int值
		System.out.println("3个元素的累加和：" + sum(5,3,1));//可变参数部分，传入了3个实参的int值
		System.out.println("-------------------------------");
	
		//System.out.println("0个元素的最大值：" + max());//错误的，因为max方法有一个非可变参数的形参，必须传值
		System.out.println("1个元素的最大值：" + max(5));//5赋值给了非可变参数的形参
		System.out.println("5个元素的最大值：" + max(5,1,5,6,8));//第1个5赋值给了非可变参数的形参，剩下的给了可变参数
	}
	
	//声明一个方法，功能：可以求两个整数的和
	public static int sum(int a, int b){
		return a + b;
	}
	//声明一个方法，功能：可以求0~n个整数的累加和
	/*
	//该方法不能与下面的(int... nums)同时存在
	public static int sum(int[] nums){
		int sum = 0; 
		for(int i=0; i<nums.length; i++){
			sum += nums[i];
		}
		return sum;
	}*/
	
	
	public static int sum(int... nums){
		//nums当成数组用
		int sum = 0; 
		for(int i=0; i<nums.length; i++){
			sum += nums[i];
		}
		return sum;
	}
	
	//声明一个方法，功能：可以求1~n个整数的最大值
	//int num1就是非可变参数部分
	//int... nums是可变参数
	public static int max(int num1, int... nums){
		int max = num1;
		for(int i=0; i<nums.length; i++){
			if(nums[i] > max){
				max = nums[i];
			}
		}
		return max;
	}
	

局部变量

变量的分类：
1、成员变量：今天讨论的都是非静态的成员变量
2、局部变量

（1）声明的位置不同
成员变量：
类中方法外
类{
【修饰符】 数据类型 成员变量;
}
局部变量
方法中：（1）形参，也是局部变量（2）方法体{}中声明的变量
后面可能还要加上代码块中。
类{
【修饰符】 返回值类型 方法名(【形参列表】){
数据类型 局部变量;
}
}
（2）运行时在内存中的位置也不相同
成员变量：堆
局部变量：栈

（3）初始化不同
成员变量：
如果没有初始化，有默认值
局部变量：
如果没有初始化，就会报错，不能用

（4）生命周期
成员变量：
随着对象的创建而分配，随着对象被垃圾回收器回收而结束
局部变量：
方法被调用，开始分配，方法执行结束就结束

（5）可用的修饰符
成员变量：有很多修饰符，具体哪些后面再讲
局部变量：唯一的一个就是final，具体什么意思再讲

	public static void main(String[] args){
		//要用一个数组，存储5个圆对象，半径分别为1-5
		//(1)声明一个数组
		//数组的元素的类型是Circle
		Circle[] arr = new Circle[5];//这个new是创建数组对象
		
		//(2)为数组的元素赋值
		for(int i=0; i<arr.length; i++){
			//元素：数组名[下标]
			//arr[i].radius = i+1;//java.lang.NullPointerException
			
			arr[i] = new Circle();//创建圆对象
			arr[i].radius = i+1;
		}
		
		//(3)遍历数组，打印每一个圆的信息
		for(int i=0; i<arr.length; i++){
			//现在的数组的元素arr[i]就是一个圆对象，既然是圆对象，就可以调用圆的属性和方法
			arr[i].printInfo();
			//System.out.println(arr[i]);
		}
	}

封装

面向对象的基本特征：
（1）封装
（2）继承
（3）多态

一、封装

1、封装的意义：
（1）隐藏实现细节
（2）安全

2、封装的类型：
（1）属性的封装、方法的封装等
（2）组件的封装
（3）系统的封装

3、封装的实现，靠权限修饰符来控制可见的范围。
权限修饰符：
(1)可见范围
本类 本包 其他包子类 任意位置
private： √ × × ×
缺省/省略： √ √ × ×
protected： √ √ √ ×
public √ √ √ √

(2)哪些可以加权限修饰符
类、属性、方法、构造器、内部类

(3)分别可以加什么权限修饰符
类：缺省或public
如果类前面有public，那么必须与源文件名相同
属性：四种都可以
方法：四种都可以

4、属性的封装
大多数情况下，属性都是private
如果属性私有化了，我们会提供get/set方法
get/set的标准写法：
public void set属性名(数据类型 形参名){
属性名 = 形参名;
}
public 属性的数据类型 get属性名(){
return 属性名;
}

5、方法的封装
大多数情况下，方法都是public

构造器

类的第三个组成部分：
构造器，也称为构造方法，因为（1）它长的像方法（2）它编译后是一个实例初始化方法

1、构造器的作用
（1）构造对象，创建对象
和new一起使用，每次调用它就是在创建新的对象
（2）可以在创建对象的同时，给属性赋值

2、构造器的特点
（1）所有类都有构造器
（2）如果一个类没有显式声明构造器，那么编译器将会自动生成一个默认的无参构造
（3）如果一个类显式声明了构造器，那么编译器将不会自动生成默认的无参构造了
（4）构造器的名称必须与类名相同
（5）构造器没有返回值类型，也不写void
（6）构造器可以重载

重载：在同一个类中，方法名相同，形参列表不同的两个和多个方法，和返回值类型无关

3、构造器的语法结构
【修饰符】 类名(){

}
【修饰符】 类名(形参列表){
	
}

回忆：
java.util.Scanner input = new java.util.Scanner(System.in);//调用的是有参构造
int num = input.nextInt();//从键盘输入一个整数
java.util.Random rand = new java.util.Random();//调用的是无参构造
int num = random.nextInt(10);//产生一个[0,10)的整数