Java中的构造方法和方法重载
一、构造方法
定义：用来创建对象的方法（实例化对象的方法）
作用：创建对象过程中对成员变量进行初始化
分类：无参构造方法 & 有参构造方法
格式：
public class 类名 {
修饰符 类名 (【参数列表】){
方法体
}
}
特点：
（1）方法名和类名相同，采用大驼峰命名法。
（2）无返回值（不用写void）
（3）每创建一个类，系统自动为这个类添加一个无参构造方法（默认存在）。
（4）通过无参构造方法创建对象，没有给对象的属性赋值，那么对象的属性值全部为默认值
（5）当你在类中添加了其它的构造方法后，默认的无参构造方法会被覆盖，如果你还想使用无参构造方法，需要手动添加
二、this关键字
语法知识：
（1）this修饰的变量用于指代成员变量
（2）方法被哪个对象调用，this就指代哪个对象
（3）this关键字调用方法时，this关键字调用方法的语句必须放在第一行
（4）方法的形参如果没有和成员变量重名，不带this关键字修饰的变量指的是成员变量
（5）方法的形参如果和成员变量重名，不带this关键字修饰的变量指的是形参而不是成员变量。
作用：
（1）this关键字可以调用成员方法。
（2）this关键字用于指代当前对象，所以this关键字可以调用属性。
（3）this关键字解决了成员变量和局部变量的名称冲突问题，防止成员变量名被局部变量名隐藏。
（4）this关键字可以调用构造方法：
1.在构造方法中使用this关键字调用其他构造方法时，不能在成员方法中使用。
2.在构造方法中使用this关键字调用其他构造方法，this关键字调用构造方法的语句必须是该方法的第一条执行语句，且只能出现一次。
注意： 不能在一个类的两个构造方法中使用this互调。
范例代码
package test;
public class Person {
public String name;
public String gender;
public int age;
//无参构造方法
public Person() {
System.out.println("我是无参构造方法");
}
//有参构造方法
public Person(String name, String gender, int age) {
//调用无参构造方法，必须放在第一行
this();
//调用属性
this.name = name;
this.gender = gender;
this.age = age;
System.out.println("姓名："+name+" "+"性别："+gender+" "+"年龄："+age);
System.out.println("我是有参构造方法");
}
}
//测试类
package test;
public class PersonTest {
public static void main(String[] args) {
//创建对象
Person person = new Person("张三", "男", 25); //实例化对象
}
}三、方法重载
定义：在同一个类中，一组方法名相同，参数列表不同，就构成方法重载
特点：
（1）在同一个类中
（2）方法名相同
（3）参数列表不同（参数个数、参数顺序、参数类型）
（4）与访问权限修饰符和返回值类型无关
优点：
方法重载其实是对原有方法的一种升级，可以根据参数的不同，采用不同的实现方法，而且不需要编写多个名称，简化了类调用方法的代码
范例代码：
package homework;
public class Demo {
//定义两个int类型数据相加的方法
public int sum(int a,int b){
return a+b;
}
//定义两个double类型数据相加的方法
public double sum(double a,double b){
return a+b;
}
//定义两个double类型数据相加的方法
public int sum(int a,int b,int c){
return a+b+c;
}
//定义三个double类型数据相加的方法
public double sum(double a,double b,double c){
return a+b+c;
}
/*方法重载特点：
（1）在同一个类中
（2）方法名相同
（3）参数列表不同（参数个数、参数类型）
（4）与访问权限修饰符和返回值类型无关
*
*/
}
//测试类
package homework;
public class DemoTest {
public static void main(String[] args) {
Demo demo = new Demo();
//两个int类型的数据相加
int result1 = demo.sum(10, 20);
System.out.println("两个int类型的数据相加和为："+result1);
//两个double类型的数据相加
double result2 = demo.sum(10, 20);
System.out.println("两个double类型的数据相加和为："+result2);
//三个int类型的数据相加
int result3 = demo.sum(10, 20,30);
System.out.println("三个int类型的数据相加和为："+result3);
//三个double类型的数据相加
double result4 = demo.sum(10, 20,30);
System.out.println("三个double类型的数据相加和为："+result4);
}
}
四、static关键字
1.静态变量
静态变量：static关键字修饰的成员变量
实例变量（非静态变量）：没有static关键字修饰的变量
特点：
（1）静态变量被该类所有对象共享
（2）static关键字修饰的属性，属于类，不属于对象
（3）静态变量会随着类的加载而加载，而优先于对象出现
注意：static只能修饰成员变量，不能修饰局部变量
调用方式：
1.类名调用（推荐）
格式：类名.成员变量名
2.对象名调用
格式：对象名.成员变量名
范例代码：
package test;
public class Student {
//成员变量
private String name;
private String gender;
private int age;
public static String schoolName;
//创建无参构造方法
public Student() {
super();
}
//创建有参构造方法
public Student(String name, String gender, int age) {
super();
this.name = name;
this.gender = gender;
this.age = age;
}
//创建get方法和set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//成员方法
public void method() {
System.out.println("姓名："+name+","+"性别："+gender+","+"年龄："+age+","+
"就读于"+schoolName);
}
}//测试类
package test;
public class StudentbtTest {
public static void main(String[] args) {
//静态变量赋值
Student.method(); //通过类名调用静态变量并赋值
//创建第一个对象
Student st1 = new Student();
st1.setName("张三");
st1.setGender("男");
st1.setAge(21);
//创建第二个对象
Student st2 = new Student();
st1.setName("李四");
st1.setGender("男");
st1.setAge(20);
}
}
/*
运行结果：
姓名：张三,性别：男,年龄：21,就读于清华大学
姓名：李四,性别：男,年龄：22,就读于清华大学
结果分析：
通过结果可以看出使用类名调用静态变量scoolName并赋值，对象st1和对象st2都显示出了
清华大学，从中可以得出static关键字能实现共享的特点
*/2.静态方法
静态方法：static关键字修饰的成员方法
实例方法（非静态方法）：没有static关键字修饰的方法
调用方式：
1.类名调用
格式：类名.成员方法名
2.对象名调用
格式：对象名.成员方法名
特点：
（1）静态方法里不能使用this关键字
（2）静态方法只能调用静态方法和静态变量，不能调用非静态的方法和变量
（3）非静态方法可以调用非静态的成员方法和成员变量，也可以调用静态方法和静态变量
package homework;
public class Person {
String name;
String gender;
int age;
/*非静态成员方法的形参中都隐藏一个this关键字,这个this不能在调用方法时手动赋值，
* 它是调用方法的时候，虚拟机给这个this赋值，就是谁调用当前方法，那么this就表示谁的地址值
* this表示当前方法调用者的地址值，也表示当前调用对象
*/
//成员方法
public void method(Person this) { //方法的形参中含有隐藏的关键字
System.out.println("this:"+this); //打印方法调用者的地址值
System.out.println("我是非静态方法");
//谁调用method方法，this就指的时谁
System.out.println("姓名："+this.name+","+"性别："+this.gender+","+"年龄："+this.age);
way();//非静态方法可以调用静态
}
//静态方法
public static void way() { //静态方法形参中无隐藏的this关键字
System.out.println("我是静态方法");
}
}
//测试类
package homework;
public class PersonTest {
public static void main(String[] args) {
//创建对象
Person person1 = new Person();
//调用非静态方法
person1.method();//peson1调用method方法,method方法形参中的this指的就是peson1
System.out.println("person1:"+ person1); //输出对象person1的地址值
System.out.println("-------------------------------------------");
//创建对象
Person person2 = new Person();
//调用非静态方法
person2.method();//peson2调用method方法,method方法形参中的this指的就是peson2
System.out.println("person2:"+ person2);//输出对象person2的地址值
System.out.println("-------------------------------------------");
Person.way(); //类名调用静态方法
person1.way();//对象名调用静态方法
}
}