---

this关键字

this代表当前对象，有时候不太方便直接使用对象，可以用this

**用法1：**this.属性名 在类中调用全局变量

举个例子：

public class Student1 {
    public String name;
    public String sno;

    public void run(String aaaa){
        this.name = aaaa;  // =是赋值操作，等号前面是变量，等号后面是值
    }
}

public class Test1 {
    public static void main(String[] args) {
        Student1 student = new Student1();
        student.run("111");

        Student1 student1 = new Student1();
        student1.run("222");
    }
}

用法2：this.方法()

• static修饰的代码被所有对象共享，所以this可以调用static修饰的方法
• static修饰的代码当中不能出现关键字，因为类是构建对象的模板，有类不一定有对象

举个例子

    public void run(String aaaa){
        this.name = aaaa;  // =是赋值操作，等号前面是变量，等号后面是值
    }

    /**
     * static修饰的代码被所有对象共享，所以this可以调用static修饰的方法
     * static修饰的代码当中不能出现关键字，因为类是构建对象的模板，有类不一定有对象
     */
//    public static void run(String aaaa){
//        this.name = aaaa; // 会报错
//    }

    public void fff(){
        this.run("333");
    }

用法3：this()

• this()不可以在普通方法中使用，只能在构造方法中使用
• this()在构造方法中使用必须是第一条语句
• 在一个类下两个构造方法不能通过this()互相调用
• 不能与super()同时使用

举个例子

    public Student1(){
        this("aaa");
    }
    public Student1(String a){
//        this(); // 不可以两个构造方法同时调用，会报错
    }

final关键字

用法1：修饰类

• final修饰的类无法被继承

举个例子：

// final修饰的类无法被继承，如String等类
public final class A {

}

public class B extends A{ // 报错
}

以上代码在B类想要继承A类时会报错

用法2：修饰方法

• final修饰的方法无法被重写

public class A {
    public final void fly(){
        System.out.println("我可以飞");
    }
}

public class B extends A{
    public void fly(){ // 报错
        System.out.println("我可以飞");
    }
}

用法3：修饰变量

final修饰的变量为常量，常量是只能被赋值一次的变量；常量的变量名必须大写

1. 修饰全局变量：final定义的全局变量必须赋初始值，因为全局变量有默认值，系统会对全局变量进行初始化，为其指定默认值

   引用数据类型的基本值：null

   整形：0

   浮点型：0.0

   布尔型：false

   字符型：“ ”

   //    public final String name; // 报错
       public final String name = "123"; // final修饰的全局变量需要再定义时赋值
                                         // 全局变量是有默认值的
   

2. 修饰局部变量：系统不会自动为局部变量分配空间与初始化，因此final局部变量可以在后面使用的时候再赋值，但是也只能赋值一次。

   public void fff(){
       String name;
       
   }
   

   注意：当final修饰方法中的形参时，该参数不能在方法体中被赋值，因为系统会在调用该方法时，根据传入的参数来初始化

   public class Demo01 {
   	public void test1(final int a) {
   		//下方语句会报错
   		a = 10;
   	}
   }
   

3. 修饰基本数据类型定义的变量：对于基本数据类型而言，final固定的是变量的值

       public void run(){
            a = 11; //报错，final修饰的基本数据类型值无法被改变
       }
   

4. 修饰引用数据类型定义的变量：对于引用数据类型而言，final固定的是对象的地址，对象中的内容是可以改变的

   public void change(){
       arr = brr; // 一旦被final修饰则无法进行赋值操作
                  // 这里的意思是将brr的地址赋值给arr
   }
   
   public void change1(){
       arr[10] = 32;
   }
   

​ 内存图如下：

Java值传递

例1

public class Demo {
    public static void main(String[] args) {
        String nameString = "张三";
        name(nameString);
        System.out.println("main--->"+nameString);
    }

    public static void name(String name) {
        name = "李四";
        System.out.println("name--->"+name);
    }
}

输出：

1. 将字符串常量池中的“张三”所在的地址赋给nameString
2. name()方法入栈，将nameString指向的地址赋值给形参name，此时name也指向字符串常量池中的“张三”
3. 在字符串常量池中添加“李四”，并将其地址赋值给变量name，并输出name—>李四
4. 输出main—>张三

例2

public class Person {
    private String nameString;
    private int age;

    public Person(String nameString,int age){
        this.nameString = nameString;
        this.age = age;
    }

    @Override
    public String toString(){
        return "Person [nameString" + nameString + ",age=" + age + "]";
    }

    public static void name(Person person){
        person.age = 20;
        person.nameString = "李四";
        person = null;
    }

    public static void main(String[] args) {
        Person person = new Person("张三",18);
        System.out.println(person.toString());
        name(person);
        System.out.println(person.toString());
    }
}

输出：

1. main()方法入栈，创建对象person，并将字符串常量池中“张三”的地址赋给nameString，18赋值给age，
2. 打印person对象
3. name()方法入栈，将person对象传入name()方法，使name()中的形参person对象也指向地址0x1，此时形参对象person可以调用0x1中的变量，将age修改为20，将nameString指向字符串常量池中“李四”所在的地址，最后让将形参person不再指向地址0x1，name()方法出栈
4. 打印person对象

例3

public class Student1 {
    private String name;
    private int age;
    public Student1(String name,int age){
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString(){
        return "Student [name=" + name + ", age=" + age +"]";
    }
    public static void change(Student1 s1, Student1 s2){
        Student1 temp = new Student1("王五",18);
        temp = s1;
        s1 = s2;
        s2 = temp;
    }

    public static void main(String[] args) {
        Student1 zhangsan = new Student1("张三",18);
        Student1 lisi = new Student1("李四",20);
        Student1.change(zhangsan,lisi);
        System.out.println(zhangsan.toString());
        System.out.println(lisi.toString());
    }
}

输出：

1. 创建Student1类对象“zhangsan”、“lisi”，并开辟内存空间，将两个对象中的name变量分别指向字符串常量池中的“张三”、“李四”，给age分别赋值
2. 通过Student1()类调用change方法，change()方法入栈，将对象“zhangsan”、“lisi”作为形参s1、s2的值传入，使s1指向地址0x1，s2指向地址0x2
3. 创建Student1类对象temp，并开辟内存空间0x3，将其中的name指向字符串常量池中的“王五”。给age赋值
4. 将s1地址值赋给temp，此时temp指向0x1
5. 将s2地址赋值给s1，此时s1指向0x2
6. 将temp地址值赋给s2，此时s2指向0x1，执行结束之后change()方法出栈
7. 打印“zhangsan”、“lisi”

==注意：==这道题中交换的只是s1、s2、temp的地址值，而不是对象中的变量值作为交换，所以并不影响外部的对象“zhangsan”、“lisi”依旧指向自己原本的地址

例4

class Two {
    byte x;
}
public class Student2{
    public static void main(String[] args) {
        Student2 student = new Student2();
        student.start();
    }
    void start(){
        Two two = new Two();
        System.out.println(two.x+" ");
        Two two2 = fix(two);
        System.out.println(two.x+" "+ two2.x);
    }
    Two fix(Two tt){
        tt.x = 42;
        return tt;
    }
}

输出：

1. main()方法入栈创建Student2类对象student，并开辟内存空间，调用start()方法
2. start()方法入栈，创建Two类型对象two，初始化全局变量x = 0，打印two.x值为0
3. fix()方法入栈，将对象two传给形参tt，使tt指向内存0x2，修改其中x的值，此时x=42，返回tt的值给对象two2，fix()方法出栈
4. 打印此时的two.x和two2.x因为两个对象指向的是同一片内存地址，所以输出结果一样，都是42