构造方法
构造方法的概述和作用
创建对象，给对象中的成员进行初始化
构造方法的格式特点
a、方法名与类名相同
b、没有返回值类型，连void也没有
c、没有具体的返回值
构造方法的重载及注意事项
如果我们没有给出构造方法，系统将会自动提供一个无参构造方法。
如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法。
给成员变量赋值的两种方式：
a:setXxx()方法
b:构造方法
这里创建set和get方法不同的IDE会有不同的快捷方式，自行了解。
我们先来创建一个简单的学生类来总结一下。
//先创建一个学生类
class Student {
private String name;
private int age;
//提供无参构造
public Student() {
}
//提供有参构造
public Student(String name,int age){
this.name = name;
this.age = age;
}
//提供set和get方法、
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class MyConstructor {
public static void main(String[] args) {
//我们首先创建一个学生对象
Student student = new Student();
//我们现在需要给学生添加属性，通过set方法可以完成
student.setAge(18);
student.setName("冯宝宝");
//现在有了构造方法，我们可以直接完成上面这些步骤
Student student1 = new Student("史莱姆", 19);
}
}
一个对象的创建过程做了哪些事情?
Student s = new Student();
步骤:
(1):加载Student.class文件进内存
(2):在栈内存为s开辟空间
(3):在堆内存为学生对象开辟空间
(4):对学生对象的成员变量进行默认初始化
(5):对学生对象的成员变量进行显示初始化
(6):通过构造方法对学生对象的成员变量赋值
(7):学生对象初始化完毕，把对象地址赋值给s变量
案例演示：
需求：
定义一个长方形(RectangleDemo)类,定义求周长(length)和面积(area)的方法,
然后定义一个测试类Test，进行测试。
//创建一个长方形类
class RectangleDomo {
//首先定义长和宽
private double a;
private double b;
//提供无参构造方法
public RectangleDomo() {
}
//提供set和get方法
public double getA() {
return a;
}
public void setA(double a) {
this.a = a;
}
public double getB() {
return b;
}
public void setB(double b) {
this.b = b;
}
//提供有参构造方法
public RectangleDomo(double a, double b) {
this.a = a;
this.b = b;
}
//提供求周长的方法1,这里我们可以只传一个RecangleDeme对象
public double C(RectangleDomo rectangleDomo) {
return (rectangleDomo.a + rectangleDomo.b) * 2;
}
//提供求周长的方法2，我们也可以直接把长和宽传进来
public double C(double a, double b) {
return (a + b) * 2;
}
//提供求面积的方法1，同样的，只传一个RecangleDeme对象
public double S(RectangleDomo rectangleDomo) {
return rectangleDomo.a * rectangleDomo.b;
}
//提供求面积的方法2，把长和宽直接传进来
public double S(double a, double b) {
return a * b;
}
}
public class Test {
public static void main(String[] args) {
//A:先采用无参构造
RectangleDomo rectangleDomo1 = new RectangleDomo();
//通过set和get赋值
rectangleDomo1.setA(20);
rectangleDomo1.setB(10);
//求周长
double c1 = rectangleDomo1.C(rectangleDomo1);
System.out.println("无参构造，通过方法1获得的周长是" + c1);
double c2 = rectangleDomo1.C(20, 10);
System.out.println("无参构造，通过方法2获得的周长是" + c2);
//求面积
double s1 = rectangleDomo1.S(rectangleDomo1);
System.out.println("无参构造，通过方法1获得的面积是" + s1);
double s2 = rectangleDomo1.S(20, 10);
System.out.println("无参构造，通过方法2获得的面积是" + s2);
//B:采用有参构造
RectangleDomo rectangleDomo2 = new RectangleDomo(10, 20);
//求周长和面积的方法与上面类似，就不再赘述
}
}
案例演示
需求：定义一个员工(Employee)类,自己分析出几个成员，然后给出成员变量，构造方法，getXxx()/setXxx()方法，
以及一个显示所有成员信息的方法。并测试。
//定义员工类
class Employee {
//定义成员变量
private String name;
private int age;
private double salary;
//提供无参构造
public Employee() {
}
//提供set和get方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
//提供有参构造
public Employee(String name ,int age,double salary){
this.age = age;
this.name = name;
this.salary = salary;
}
//提供方法来显示成员信息
public void showInfo(Employee employee){
System.out.println("该员工的信息如下：");
System.out.println("ta的名字是："+employee.name);
System.out.println("ta的年龄是："+employee.age);
System.out.println("ta的薪水是："+employee.salary);
System.out.println("--------------------------------------");
}
}
public class Test {
public static void main(String[] args) {
//我们先用无参构造来创建一个员工
Employee employee1 = new Employee();
//我们先不给这个员工添加属性，来看看他的信息
employee1.showInfo(employee1);
//ta的名字是：null
//ta的年龄是：0
//ta的薪水是：0.0
//这些都是系统的默认值，只有在赋值之后，才会把这些值覆盖
employee1.setName("艾希");
employee1.setAge(19);
employee1.setSalary(8000);
//我们再用有参构造来创建一个员工
Employee employee2 = new Employee("嘉文四世", 20, 10000);
//好了，员工创建好了，我们现在来显示他们的信息
employee1.showInfo(employee1);
//我们通过employee1和employee2都可以访问到这个方法
//影响结果的只是传进去的参数，而不是谁调用了这个方法
employee1.showInfo(employee2);
employee2.showInfo(employee2);
}
}
static关键字
特点
1、随着类的加载而加载；
2、优先于对象存在；
3、被类的所有对象共享。
4、可以通过类名和对象名可以调用，推荐使用类名。
所以呢，如果某个成员变量是被所有的对象共享的，那么就应该把它定义成静态的。
注意事项
1、在静态方法中是没有this关键字的，怎么理解呢？静态是随着类的加载而加载，this是随着对象的创建而存在。所以说**“静态比对象先存在”**；
2、静态方法只能访问静态的成员变量和静态的成员方法；
静态变量和成员变量有什么区别呢？
1、所属不同
静态变量属于类，所以也称为类变量；
成员变量属于对象，所以也称为实例变量（对象变量）。、
2、内存中位置不同
静态变量存储在方法区的静态区；
成员变量存储于堆内存。
3、内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失；
成员变量随着对象的创建而存在，随着对象的消失而消失。
4、调用方法不同
静态变量可以通过类名调用，也可以通过对象调用；
成员变量只能通过对象名调用。
为什么主函数前面要加上static修饰？
这段内容是从网上找来的，挑着写了一些，原文在这里：
先来说说static，我们已经知道：
static修饰的域，我们叫做静态域，它是归类所有的，被所有对象所共享，只有一个；
static修饰的区块，域指挥初始化一次；
static修饰的域或方法，可以直接通过类的名字加上.来访问；
static修饰的方法内不能直接使用非静态成员。
static关键字，告知编译器main函数是一个静态函数，也就是说main函数中的代码是储存在静态存储区的，静态方法在内存中的位置是固定的，即当定义了类以后这段代码就已经存在了。若果main（）方法没有使用static修饰符，那么编译不会出错，但是如果你试图执行该程序就会报错，提示main（）方法不存在。因为包含main（）的类并没有实例化（即没有这个类的对象），所以其main（）方法也不会存。而使用static修饰符则表示该方法是静态的，不需要实例化即可使用。
main（）方法是一个程序的入口，如果写成非静态的，那么就必须实例化一个对象再来调用它。既然是入口那么这样肯定不行，静态方法是属于类的，直接用类名就可以调用。static方法不需要创建对象，可以直接访问，这样main（）方法就不需要做特殊处理。static方法在静态数据区中，这样就可以直接调用不需要每次调用都需要重新生成。
Math类的随机数功能
通过一个猜数游戏来说明：
import java.util.Scanner;
public class MyConstructor {
public static void main(String[] args) {
//Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
//Math类里面所有的成员变量和成员方法都用static修饰了，类名直接调用即可
//static double random () 生成随机数
//返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
double random = Math.random();
//获得100个随机整数（0~100）
for (int i = 0; i < 100; i++) {
int random1 = (int) (Math.random() * 100);
System.out.println(random1);
}
//猜数游戏
Scanner scanner = new Scanner(System.in);
//先产生一个随机数（0~100）
int random2 = (int) (Math.random() * 100);
//记录猜数的次数
int times = 0;
System.out.println("游戏开始：");
while (true) {
System.out.println("请输入一个整数（0~100）：");
int userNum = scanner.nextInt();
times++;
if (userNum < random2) {
System.out.println("猜小了");
} else if (userNum > random2) {
System.out.println("猜大了");
} else if (userNum == random2) {
System.out.println("恭喜猜对了,花了" + times + "次");
break;
}
}
}
}