Java中this关键字、构造函数、栈和堆、重载你了解多少

     this关键字

     构造函数

     栈和堆

     重载

this是自身的一个对象，代表对象的本身，可以理解为：指向对象本身的一个指针。

(1)this调用本类中的属性，也就是类中的成员变量

(2)this调用本类中的其他方法

(3)this调用本类中的其他构造函数，调用时要放在构造函数的第一行

1、成员变量和方法的形参名字重名，用this来区分

public class Student {

  private int age = 8;//成员变量
   
  Student() {
    System.out.println("初始化的年龄：" + age);
  }

  public int getAge(int age) {//定义一个形参（局部变量）name
    //将局部变量的值传递给成员变量
    this.age = age;//前者this.age是成员变量、后者age是方法的形参
    return this.age;
  }

  public static void main(String[] args) {
    Student student = new Student();
    System.out.println("this关键字来区分形参和成员变量名字重名：" + student.getAge(10));
  }
}

运行结果：

初始化的年龄：8
this关键字来区分形参和成员变量相同的字段名：10

2、可以在构造函数中调用其他构造函数。但是，只能定义在构造函数第一行，因为初始化动作要先执行

public class Student {

  private int age;
  private String name;

  Student() {
    name = "张三";
    age = 10;
    System.out.println("这是无参的构造函数");
  }

  Student(String name, int age) {
    //调用其他构造函数，只能定义在构造函数第一行，因为初始化要先执行
    this();//调用了上面Student()构造函数并打印println语句
    this.name = name;
    this.age = age;
  }

  public void print() {
    System.out.println("我叫：" + this.name + "年龄：" + this.age);
  }

  public static void main(String[] args) {
    Student student = new Student("李四", 15);
    student.print();
  }
}

运行结果：

这是无参的构造函数
我叫：李四    年龄：15

这样我们可以看得出来：Student（String name，int age）构造函数调用了Student（），但是最后输出结果，只是这是无参的构造函数，成员变量的内容还是我们在新建对象时，传递进去的参数，并不是 Student() 中初始化的内容。

 3、什么是构造函数（方法）上面提及到构造函数，进行补充内容

构造函数，是一种特殊的方法。主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。特别的一个类可以有多个构造函数，可根据其参数个数的不同或参数类型的不同来区分它们即构造函数的重载。

4、构造函数的特点

1.构造函数的命名要和类一定相同。

2.构造函数不能直接被调用，必须通过new运算符在创建对象时才会自动去调用

3.当我们去定义一个类的时候，没有去创建构造函数的时候，系统会默认无参构造函数

4.构造函数的作用是在类创建是定义初始化状态。它没有返回值，不能使用void来修饰

（注意）一般函数不能调用构造函数，只能是构造函数才能去调用构造函数

5、无参构造函数

public class Student {

  //定义无参构造函数，打印println语句
  Student() {
    System.out.println("无参的构造函数");
  }

  public static void main(String[] args) {
    //输出无参构造函数的打印语句。当new对象创建，就会去调用对应的构造函数，并打印println语句
    Student student = new Student();
  }
}

运行结果：

无参的构造函数

6、有参构造函数

public class Student {

  private String name;
  private int age;

  //定义有参的构造函数，打印println语句
  Student(String name, int age) {
    this.name = name;
    this.age = age;
    System.out.println("名字：" + this.name + " 年龄：" + this.age);
  }

  public static void main(String[] args) {
    //new Student()里直接调用有参构造函数并直接传值，然后直接打印
    Student student = new Student("张三", 10);
  }
}

运行结果：

名字：张三 年龄：10

 或

public class Student {

  private String name;
  private int age;

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

  public String getName() {
    return name;
  }

  public int getAge() {
    return age;
  }

  public static void main(String[] args) {
    Student student = new Student("张三", 10);
    System.out.println("我叫" + student.getName() + " 年龄" + student.getAge());
  }
}

运行结果：

名字：张三 年龄：10

7、构造函数只能被运行一次，如果想要重新给对象赋值，那就要使用set和get方法赋值，此时的set和get当一般函数来使用 

public class Student {

  private String name;
  private int age;

  Student(String name, int age) {
    this.name = name;
    this.age = age;
    System.out.println("我叫" + this.getName() + " 年龄" + this.getAge());
  }
  //set方法是再次给name赋值
  public void setName(String names) {
    name = names;
  }
  //set方法是再次给age赋值
  public void setAge(int ages) {
    age = ages;
  }
  //get方法是获取到set赋值的name值
  public String getName() {
    return name;
  }
  //get方法是获取到set赋值的age值
  public int getAge() {
    return age;
  }

  public void print() {
    System.out.println("我叫" + name + " 年龄：" + age);
  }

  public static void main(String[] args) {
    //当创建new Student("张三", 10),直接调用相应构造函数里面传值，直接打印。同时，不能new同一个对象多次，否则会报错
    Student student = new Student("张三", 10);
    //想要改变name的值，就要去调用setName方法来重新赋值，然后getName获取到值
    student.setName("李四");
    student.setName("老五");//可以调用对象多次
    //想要改变age的值，就要去调用setAge方法来重新赋值，然后getAge获取到值
    student.setAge(15);
    student.setAge(14);//可以调用对象多次
    //最后调用print()方法来打印获取到的name和age
    student.print();
  }
}

运行结果：

我叫张三 年龄10
我叫老五 年龄：14

栈：内存空间小一些，栈的内存要远远小于堆内存，如果你使用递归的话，那么你的栈很快就会充满。如果递归没有及时跳出，很可能发生StackOverFlowError问题。主要存放函数体的地址、函数的参数、局部变量临时变量等。

堆：内存空间大一些，主要存放一些通过new出来的对象或者malloc申请的内存空间。

1、这是Student student = new Student（“张三”，10）这行代码执行完之后

2、这是student.setName（“李四”）这行代码执行完之后

 

 3、这是student.setName（“老五”）这行代码执行完之后

4、这是student.setAge(15)这行代码 执行之后

5、这是student.setAge(14)这行代码 执行之后

6、这是执行最后一句代码student.print（）。student（name：老五，age：14）打印出

名字：老五 年龄：14

8、什么是重载

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

重载规则:

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。
• 无法以返回值类型作为重载函数的区分标准。

1、重载参数个数不一样实例：

public class Student {

  private String name;
  private int age;

  //方法名相同，参数一个
  public void method(int age) {
    System.out.println("我的年龄：" + age);
  }

  //方法名相同，参数两个，构成重载
  public void method(String name, int age) {
    System.out.println("我的名字：" + name + " 我的年龄：" + age);
  }

  public static void main(String[] args) {
    Student student = new Student();
    student.method(10);
    student.method("张三", 15);
  }
}

 运行结果：

我的年龄：10
我的名字：张三 我的年龄：15

2、重载参数类型不同的实例：

public class Student {

  //方法名相同，参数两个，int类型
  public void method(int a, int b) {
    System.out.println("两个int参数的值：" + a + " " + b);
  }

  //方法名相同，参数两个，double类型，因为参数相同类型不同构成重载
  public void method(double a, double b) {
    System.out.println("两个double参数的值：" + a + " " + b);
  }

  public static void main(String[] args) {
    Student student = new Student();
    student.method(10, 15);
    student.method(5.0, 8.0);
  }
}

 运行结果：

两个int参数的值：10 15
两个double参数的值：5.0 8.0

9、构造函数的重载 

构造函数也是函数的一种，也具备着重载（overloading）的特性。

1.构造函数重载的实例：

public class Student {

  private String name;
  private int age;

  //这三个方法方法名相同，方法的参数不同，可以构成重载
  Student() {
    System.out.println("无参的构造函数：" + "name:" + name + "  age:" + age);
  }

  Student(String name) {
    System.out.println("一个参数的构造函数：" + "name:" + name + "  age:" + age);
  }

  Student(String name, int age) {
    System.out.println("两个参的构造函数：" + "name:" + name + "  age:" + age);
  }

  public static void main(String[] args) {
    Student student = new Student();
    Student student1 = new Student("张三");
    Student student2 = new Student("张三", 10);
  }
}

运行结果：

无参的构造函数：name:null  age:0
一个参数的构造函数：name:张三  age:0
两个参的构造函数：name:张三  age:10