几个关键字

几个关键字

静态static关键字

static用来修饰成员变量

public class Student {
    private String name;
    private  int age;
    static String room;
    private int id;
    private static int idCounter = 0;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCounter;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public static String getRoom() {
        return room;
    }

    public static void setRoom(String room) {
        Student.room = room;
    }

    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 Student() {
    }
}

public class DemoFileld {
    public static void main(String[] args) {
        Student one =  new Student("郭靖",15);
        one.room = "101教室";
        Student two =  new Student("黄蓉",16);
        System.out.println("姓名：" + one.getName() + ",年龄："+one.getAge()+"，教室："+one.getRoom()+",学号："+one.getId());
        System.out.println("姓名：" + two.getName() + ",年龄："+two.getAge()+"，教室："+two.getRoom()+",学号："+two.getId());

    }
}

static用来修饰成员方法
一旦使用static修饰成员方法，那么这就成为了静态方法，静态方法不属于对象，而属于类

如果没有static关键字，那么必须首先创建对象，然后对象才能使用它
如果有了static关键字，那么不需要创建对象，直接能通过类使用它。

无论是成员变量，还是成员方法，都推荐使用类名称进行调用

注意事项
1.静态不能直接访问非静态
原因：
因为在内存当中现有静态内容，后有非静态内容
”先人不知道后人，但后人知道先人“
2.静态方法当中不能用this
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。但是static和对象没有关系

public class MyClass {
    int num;
    static int staticNUM;
    public void method(){
        System.out.println("这是一个普通的成员方法");
        System.out.println(num);//成员方法可以访问成员变量
        System.out.println(staticNUM);//成员方法可以访问静态方法
    }

    public static void methodStatic(){
        System.out.println("这是一个静态方法");
       // System.out.println(num); //静态方法不能直接访问成员变量
        System.out.println(staticNUM);//静态方法可以访问静态变量
     //静态方法中不能使用this关键字
        //   System.out.println(this);//错误写法
    }
}

public class Demo02StaticMethod {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        //然后才能使用没有static的内容
        obj.method();
        //对于静态方法，可以通过对象名进行调用，也可以通过类名进行调用。
        obj.methodStatic();//正确，不推荐，这种形式在被Javac编译后，也会被翻译成 "类名称.态方法名"
        MyClass.methodStatic();//正确，推荐
        //对于本类当中的静态方法，类名称可以省略
        myMethod();
    }
    public static void myMethod() {
        System.out.println("自己的方法");
    }
}

static内存图

静态代码块

格式：

public class 类名称{

​ static{

​ //静态代码的内容

​ }

}

特点:当第一次用到本类时，静态代码块执行唯一的一次。

静态内容总是优先非静态，所以静态代码块先于构造方法执行。

静态代码块的典型用途：

​ 用来一次性的对静态变量进行赋值。

private关键字

/*
问题描述：定义Person类的时候，无法阻止不合理的赋值（年龄，负值）
用private修饰需要被保护的成员变量

一旦使用了private，那么本类当中仍然可以随意访问，
但是！超出本类范围就无法再直接访问了。

间接访问private变量，就是定义一对getter/setter
对于getter来说，不需要参数，返回值类型和成员变量相对应
对于setter来说，不能有返回值，参数类型和成员变量相对应
 */
public class Person {
    String name;
    private int age;
    public void show(){
        System.out.println("我是"+name+",今年"+age);
    }
//这个成员方法专门用来设置age
    public void setAge(int num) {
        if(num>=0 && num<=100){
        age = num;
        }else{
            System.out.println("数据不合理");
        }
    }
//这个方法专门用于获取age
    public int getAge() {
        return age;
    }
}

public class DemoPerson {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "赵丽颖";
//        person.age = -20;//直接访问private，错误写法

        person.setAge(-20);
        person.show();

    }
}

this关键字

this关键字的作用：

在同名的时候，起到区分的作用

当方法的局部变量和方法的成员变量重名的时候，根据”就近原则“，优先使用局部变量。
如果想要使用本类中的成员变量，需要使用格式：
this.成员变量名

"通过谁调用的方法，谁就是this person.sayHello person就是this,相当于person.sayHello"

public class Person {
    String name;

    public void sayHello(String name){
        System.out.println(name+"你好，我是"+this.name);
    }

}

public class DemoPerson {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "王健林";
        person.sayHello("王思聪");
    }
}

this关键字的三种用法

1.在本类的成员方法中，访问本类的成员变量
2.在本类的成员方法中，访问另一个成员方法
3.在本类的构造方法中，访问另一个构造方法

第三种需要注意的是：
A.this（。。。）调用也必须是构造方法的第一条语句
B.super()和this()调用不能同时，它们俩都必须是第一条语句

public class Zi extends Fu {
    int num = 20;
    public Zi(){
       // super();//这一行不再赠送
        this(123);//本类中的无参构造方法调用有参构造方法
       // this(1,2);//错误写法
    }
    public Zi(int n){
    }
    public Zi(int n ,int m){
    }
    public void showNum(){
        int num = 10;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
    public void methodA(){
        System.out.println("AAA");
    }
    public void methodB(){
        System.out.println("BBB");
    }
}

super关键字

super关键字的三种用法
1.在子类的成员方法，访问父类的成员变量
2.在子类的成员方法，访问父类的成员方法
3.在子类的构造方法，访问父类的构造方法

public class Zi extends Fu {
    int num = 20;

    public Zi() {
        //super();
    }

    public void methodZi(){
        System.out.println(super.num);
    }
    public void method(){
        super.method();
        System.out.println("子类方法");
    }
}

public class Fu {
    int num = 10;
    public void method(){
        System.out.println("父类方法");
    }
}

super与this图解

final关键字

含义

final 代表最终、不可改变的.

四种用法：

1.final可以用来修饰一个类

含义：当前这个类不能有任何的子类

格式：

public final class 类名{
	}

注意：一个类如果是final类，那么其中的成员方法都无法进行覆盖重写。

2.final可以用来修饰一个方法

含义：当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也即是不能被覆盖重写。

格式：

修饰符 final 返回值类型 方法名称（参数列表）{

//方法体

}

注意：对于类、方法来说，abstract和final不能同时使用，因为矛盾。（子类当中是一定要覆盖重写抽象方法的，除非你也是抽象类，final方法不能覆盖重写。）

public abstract final void 方法名（）是错误写法

3.final可以用来修饰一个局部变量

一旦使用final用来修饰局部变量，那么这个变量就不能更改

“一次赋值，终生不变”

final int num = 10；

num = 20 ；//错误

//正确写法，只要保证有一次唯一的赋值即可。

final int num2；

num2 = 30；

对于基本类型来说，不可变说的是变量当中的数据不可改变。

对于引用类型来说，不可变说的是变量当中的地址值不可改变。

Student stu1 =new Student("赵丽颖")；

System.out.println(stu1);//@50cbc42f

System.out.println(stu1.getname());//赵丽颖

stu1 = new Student("冯绍峰")；

System.out.println(stu1);//@75412c2f

System.out.println(stu1.getname());//冯绍峰

System.out.println("======================");

final Student stu2 = new Student("高圆圆")；

//错误写法！final的引用类型变量，其中的地址值不能改变

//stu2 = new Student("赵又廷");

System.out.println(stu2.getname());//高圆圆

stu2.setName（“高圆圆圆圆圆圆圆圆”）；

System.out.println(stu2.getname());//高圆圆圆圆圆圆圆圆

4.final可以用来修饰一个成员变量

对于成员变量来说，如果使用final关键字修饰，那么这个变量照样不能变。

1.由于成员变量具有默认值，所以用了final后必须手动赋值，不会再给默认值了。

2.对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。

3.必须保证类中所有重载的构造方法，都最终会对final的成员变量进行赋值。

private final String name = “鹿晗”；//构造方法报错

public Person（）{

	name = “关晓彤”

}