构造方法
构造方法的概述和作用
创建对象,给对象中的成员进行初始化
构造方法的格式特点
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;
}
}
}
}