Java 入门探索者07（this关键字，方法重载，重写，构造方法）

this关键字是Java中的一个特殊关键字， 它可以引用当前对象。在Java中，每个类的方法都有一个隐含的this参数，指向调用该方法的对象。通过this关键字，可以在类的方法中访问类的成员变量和方法。

this关键字的主要用途有以下两种：

1. 用来区分实例变量和方法参数：在方法中，可以使用this关键字来引用当前对象的实例变量，以区分方法的参数和实例变量的同名问题。例如：

```java
public class Person {
    private String name;
    
    public void setName(String name) {
        this.name = name;
    }
}
```

在上述代码中，this.name表示当前对象的name实例变量，而name表示方法的参数。

2. 用来调用当前对象的其他方法：在方法中，可以使用this关键字来调用当前对象的其他方法。例如：

```java
public class Person {
    private String name;
    
    public void sayHello() {
        System.out.println("Hello, my name is " + this.getName());
    }
    
    public String getName() {
        return name;
    }
}
```

在上述代码中，sayHello方法通过this.getName()调用了当前对象的getName方法。

总之，this关键字是Java中用来引用当前对象的特殊关键字，可以在类的方法中访问类的成员变量和方法，以及调用当前对象的其他方法。


//this的三种用法
//1.当全局变量和局部变量同名的时候，可以使用this关键字解决屏蔽问题
//2.在一个构造方法中调用其他的构造方法，只能放在第一行
//3.在一个实例方法中，访问当前实例的引用（作为方法的实参传递）
public class Person {
    int no;
    String name;
    int age ;
    double score;
    public Person(int no){
        this.no = no;
    }
    public Person(int no,String name){
        this.no = no;
        this.name = name;
    }
    public Person(int no,String name,int age){
        this.no = no;
        this.name = name;
        this.age = age;
    }
    public Person(int no,String name,int age,double score){
        //this.no = no;
        //this.name = name;
        //this.age = age;
        this( no, name, age);//减少代码行数，提高代码复用性必须放在第一行
        this.score = score;
    }
    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    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 getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    //主调方法：主动调用其他方法的方法
    //被调方法：被其他方法调用的方法
    public void doSomething(){
        //this表示对象本身，谁调用的此方法，在这个方法运行过程中this表示的就是谁
        System.out.println(this);
        saySomething(this);
    }
    public void saySomething(Person p){}

    public static void main(String[] args) {
        Person person = new Person(10);
        person.doSomething();
        System.out.println(person);
    }
}

Java中的方法重载（Method Overloading）和方法重写（Method Overriding）是面向对象编程中常用的概念。它们的主要区别在于：

方法重载：
- 方法重载指同一个类中定义了多个方法，它们具有相同的名称但具有不同的参数列表（参数类型、个数或顺序不同）。
- 重载的方法可以拥有不同的返回类型。
- 方法重载可以在同一个类中定义，也可以在父类和子类之间定义。
- 编译器根据调用方法时所传递的参数类型和个数来决定调用哪个重载的方法。

方法重写：
- 方法重写指子类定义了与父类中具有相同名称、参数列表和返回类型的方法。
- 方法重写只能在子类中进行，且必须是在父类的基础上进行。
- 重写的方法不能拥有比父类更严格的访问修饰符，但可以比父类拥有更宽松的访问修饰符。
- 在运行时，如果子类对象调用了父类和子类都存在的方法，则会执行子类中的重写方法。

以下是方法重载和方法重写的示例：

方法重载示例：
```java
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
}
```

方法重写示例：
```java
public class Animal {
    public void makeSound() {
        System.out.println("Animal makes sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}
```

总结来说，方法重载是在同一个类中定义多个方法，根据参数的类型、个数或顺序的不同来区分它们；方法重写是子类对父类中已有方法的重新定义。方法重载提供了更灵活的方法调用方式，而方法重写则允许子类根据自身需要修改父类方法的行为。


public class Student {
    //方法重载：方法名相同，参数不同一个方法称为另一个方法的重载方法
    //条件：1.在同一个类中
    //2.方法名相同
    //参数的个数，类型，顺序至少有一个不同
    public void eat(){
        System.out.println("喝西北风");
    }
    public void eat(Chicken c){
        System.out.println("吃鸡肉");
    }
    public void eat(Chicken e,Beef b){
        System.out.println("吃鸡肉和牛肉");
    }
    public void eat(Beef b,Chicken e){
        System.out.println("吃牛肉和鸡肉");
    }
    public void eat(Bread bread){
        System.out.println("吃面包");
    }
    public Student(){
        //构造方法可以重载
    }
    public Student(int a){

    }
    public Student(int a ,int b ){

    }
    public static void main(String[] args) {
        //重载方法如何调用
        //利用传递的参数来区分调用是哪一个重载方法
        Student s = new Student();
        Chicken chicken = new Chicken();
        Beef beef = new Beef();
        Bread bread = new Bread();
        s.eat();
        s.eat(chicken);
        s.eat(chicken,beef);
    }
}
class Chicken{}
class Beef{}
class Bread{}

Java构造方法是一种特殊的方法，用于创建和初始化对象。它具有以下特点：

1. 构造方法的名称必须与类的名称相同，且没有返回类型（连void也没有）。
2. 构造方法在使用new关键字创建对象时自动调用，用于初始化对象的成员变量。
3. 可以有多个构造方法，只要它们的参数列表不同，这被称为方法的重载。
4. 如果没有显式地定义构造方法，Java会提供一个默认的无参构造方法，该方法什么也不做。
5. 如果显式地定义了构造方法，则默认的无参构造方法将不再被提供。

构造方法可以通过以下几种方式使用：

1. 构造方法的基本使用
```java
public class MyClass {
    private int myVar;

    // 构造方法
    public MyClass(int var) {
        myVar = var;
    }
}

// 使用构造方法创建对象
MyClass obj = new MyClass(10);
```

2. 方法的重载
```java
public class MyClass {
    private int myVar;

    // 无参构造方法
    public MyClass() {
        myVar = 0;
    }

    // 有参构造方法
    public MyClass(int var) {
        myVar = var;
    }
}

// 使用不同的构造方法创建对象
MyClass obj1 = new MyClass();      // 使用无参构造方法
MyClass obj2 = new MyClass(10);    // 使用有参构造方法
```

3. 调用其他构造方法（使用this关键字）
```java
public class MyClass {
    private int myVar1;
    private int myVar2;

    // 有参构造方法
    public MyClass(int var1) {
        myVar1 = var1;
    }

    // 重载的构造方法，调用有参构造方法
    public MyClass(int var1, int var2) {
        this(var1);     // 调用有参构造方法
        myVar2 = var2;
    }
}

// 使用重载的构造方法创建对象
MyClass obj = new MyClass(10, 20);
```

构造方法的主要作用是将对象初始化为合适的状态。在构造方法中可以进行一些初始化操作，例如给成员变量赋初值、创建其他对象等。构造方法是面向对象编程的重要概念，在Java中广泛应用于对象的创建和初始化过程中。


public class Teacher {
    //构造方法的作用是给对象进行初始化工作的，为实例变量赋予合适的初始值
    //实例变量又叫成员变量，全局变量，属性
    private int age;
    private String name;
    //构造方法的方法名必须跟类名相同，包括大小写
    //构造方法没有返回值类型，也不能使用返回值类型修饰
    //如果有显示定义的构造方法，编译器就不会给我们添加无参的构造方法，
    //如果没有显示定义的构造方法，编译器就会添加一个无参的构造方法
    //赋值顺序是默认初始化-->显示初始化-->构造方法初始化
    public Teacher(){
        age = 30;
        name = "张三";
        System.out.println(age);
        System.out.println(name);
    }

    public static void main(String[] args) {
        //构造方法不能通过直接调用方法的方式调用而是通过new关键字调用
        Teacher t = new Teacher();
    }
}