Java基础_面向对象_ Java四大关键字this，static，final，super_13

this

this可以修饰属性：

总结：当属性名字和形参发生重名的时候，或者 属性名字 和局部变量重名的时候，都会发生就近原则，所以如果我要是直接使用变量名字的话就指的是离的近的那个形参或者局部变量，这时候如果我想要表示属性的话，在前面要加上：this.修饰
如果不发生重名问题的话，实际上你要是访问属性也可以省略this.

public class Person {
    //属性
    int age;
    String name;
    double height;
    //空构造器
    public Person(){
    }
    //有参构造器
    public Person(int age,String name,double height){
        this.age = age;
        this.name = name;
        this.height = height;
    }
    //方法：
    public void eat(){
        int age = 10;
        System.out.println(age);//就近原则，age指的是离它近的age--》局部变量的age
        System.out.println(this.age);//这里指代的就是属性的age
        System.out.println("我喜欢吃饭");
    }
}

this修饰方法：

总结：在同一个类中，方法可以互相调用，this.可以省略不写。

public class Person {
    //属性
    int age;
    String name;
    double height;
    //空构造器
    public Person(){
    }
    //有参构造器
    public Person(int age,String name,double height){
        this.age = age;
        this.name = name;
        this.height = height;
    }
    //方法：
    /*public void eat(){
        int age = 10;
        System.out.println(age);//就近原则，age指的是离它近的age--》局部变量的age
        System.out.println(this.age);//这里指代的就是属性的age
        System.out.println("我喜欢吃饭");
    }*/
    public void play(){
        /*this.*/eat();
        System.out.println("上网");
        System.out.println("洗澡");
    }
    public void eat(){
        System.out.println(/*this.*/age);
        System.out.println("吃饭");
    }
}

this可以修饰构造器：

总结：同一个类中的构造器可以相互用this调用，注意：this修饰构造器必须放在第一行

public class Person {
    //属性
    int age;
    String name;
    double height;
    //空构造器
    public Person(){
    }
    //有参构造器
    public Person(int age,String name,double height){
        this(age,name);
        this.height = height;
    }
    public Person(int age,String name){
        this(age);//会在所有方法中找只有一个参数的方法，然后把age传进只有一个参数的方法中
        this.name = name;
    }
    public Person(int age){
        this.age = age;
    }
    
}

static

static可以修饰：属性，方法，代码块，内部类。

static 修饰属性

一般官方的推荐访问方式：可以通过类名.属性名的方式去访问：
Test.sid = 100;
System.out.println(Test.sid);

static修饰属性总结：
（1）在类加载的时候一起加载入方法区中的静态域中
（2）先于对象存在
（3）访问方式： 对象名.属性名 类名.属性名（推荐）

public class MsbStudent {
    //属性：
    String name;
    int age;
    static String school;
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        MsbStudent.school = "马士兵教育";
        //创建学生对象：
        MsbStudent s1 = new MsbStudent();
        s1.name = "张三";
        s1.age = 19;
        //s1.school = "马士兵教育";
        MsbStudent s2 = new MsbStudent();
        s2.name = "李四";
        s2.age = 21;
        //s2.school = "马士兵教育";
        System.out.println(s2.school);
    }

static修饰方法

1. 静态方法不能使用this关键字，即System.out.println(this.id);（×）
2. 静态方法中不能访问非静态方法
3. 静态方法中不能访问非静态属性
4. 非静态方法可以用对象名.方法名去调用
5. 静态的方法可以用 对象名.方法名去调用 也可以 用 类名.方法名 ;在同一个类中静态方法可以直接调用

```java
public class Demo {
    int id;
    static int sid;
    public void a(){
        System.out.println("--------a");
    }
    public static void b(){
       // System.out.println(this.id);//静态方法不能使用this关键字
        //a();//静态方法中不能访问非静态方法
       // System.out.println(id);//静态方法中不能访问非静态属性
        System.out.println(sid);
        System.out.println("--------b");
    }

    public static void main(String[] args) {
        //非静态方法可以用对象名.方法名去调用
        Demo d = new Demo();
        d.a();

        //静态的方法可以用   对象名.方法名去调用  也可以 用  类名.方法名 （推荐）
        Demo.b();
        d.b();

        //在同一个类中静态方法可以直接调用
        b();
    }
}

super关键字

super：指的是父类；

super可以修饰方法，属性；

在子类的方法中，可以通过super.属性，super.方法的方式，显示的去调用父类提供的属性，方法。

在通常情况下，super.可以省略不写：

在特殊情况下，当子类和父类的方法/属性重名时，你要想使用父类的方法/属性，必须加上修饰符super.，只能通过super.方法来调用在这种情况下，super.就不可以省略不写。

super修饰构造器

其实我们平时写的构造器的第一行都有：super() -->作用：调用父类的空构造器，只是我们一般都省略不写
（所有构造器的第一行默认情况下都有super(),但是一旦你的构造器中显示的使用super调用了父类构造器，那么这个super()就不会给你默认分配了。如果构造器中没有显示的调用父类构造器的话，那么第一行都有super(),可以省略不写）

如果构造器中已经显示的调用super父类构造器，那么它的第一行就没有默认分配的super();了

在构造器中，super调用父类构造器和this调用子类构造器只能存在一个，两者不能共存：因为super修饰构造器要放在第一行，this修饰构造器也要放在第一行：

super调用父类构造器和this调用子类构造器只能存在一个

		super(a,b);
		this(a);//此代码错误

final关键字

修饰属性

package com.zt.final关键字;

/**
 * @Auther: ZhouT
 * @Date: 2021/1/10 - 01 - 10 - 16:44
 * @Description: com.zt.final关键字
 * @version: 1.0
 */
public class Test {
    public static void main(String[] args) {
        //第1种情况：
        //final修饰一个变量，变量的值不可以改变，这个变量也就变成了一个字符常量，约定俗成，名字大写
        final int A = 10;

        //第2种情况：
        final Dog dog = new Dog();//final修饰引用类型，那么地址值不可以改变
        //dog = new Dog();
        dog.age = 10;//dog的属性依然可以改变
        dog.weight = 100.00;

        //第3种情况：
        final Dog dog2 = new Dog();
        a(dog2);

        //第4种情况：
        b(dog2);
    }

    public  static void a(Dog d){
        d = new Dog();//dog2不可以改变，但是d可以改变，因为重新new Dod()了；
    }

    public  static void b(final Dog d){//d被final修饰了，指向不可以改变
        //d = new Dog();
    }
}

修饰方法

final修饰方法，那么这个方法不可以被该类的子类重写：

修饰类

final修饰类，代表没有子类，该类不可以被继承：一旦一个类被final修饰，那么里面的方法也没有必要用final修饰了（final可以省略不写）

案例

JDK提供的Math类

1. 使用Math无需导包，直接使用
2. Math没有子类，不可以被继承
3. 里面的属性全部被final修饰，方法也全部被final修饰（省略了）
4. 外界不可以被创建对象
5. Math所有的属性，方法都被static修饰，那么不用创建对象去调用，只能通过类名.属性名 类名.方法名 去调用

创建类，对象_局部，成员变量_权限修饰符_方法的重写_构造器_代码块_11

Java三大特性_封装，继承，多态_12

添加链接描述抽象类，抽象方法_14