Java面向对象——部分关键字的学习

马俊玮

已于 2023-07-15 20:20:31 修改

阅读量34

点赞数

文章标签： java 学习开发语言

于 2023-07-15 16:00:35 首次发布

本文链接：https://blog.csdn.net/Kochiya_ika/article/details/131736584

版权

this关键字

this关键字代表的是当前正在执行的对象，我们一般使用关键字来区分成员变量和局部变量

public class Student {
    //定义成员变量
    int number;
    String name;
    String gender;
    public Student(int number,String name,String gender){
    //通过this来区分成员变量和局部变量
        this.number=number;
        this.name=name;
        this.gender=gender;
    }
    void printf(){
        System.out.println(this.name);
        System.out.println(this.gender);
        System.out.println(this.number);
    }
    void exam(){
        System.out.println(this.name+"考试");
    }
}

static关键字

static关键字，被称为静态关键字，static可以修饰成员方法、成员变量、代码块还有内部类。

其主要特点有：1.不依赖于对象，只要类被加载就跟着一起加载；2.优先于对象而存在；3.修饰的成员被所有类而共享；4.可以不创建对象通过类名直接调用。

我们平常使用到的也就是其中第三点特点：就好比创建了一个汽车人类，这一类的所有对象的共同特点是汽车人，那么我们在定义成员变量的时候就可以使用以下两种方法：

String type0="汽车人";
static String type1="汽车人";

这两种方法都可以用来定义类型，但是从内存上来考虑：static修饰的type1只在方法区定义一次，但是type0要在每一次创建对象的时候跟着在内存区创建一个type0，长久来看，需要花费很大的空间在这种重复的定义上。

当然，我们在使用static关键字也要对于第一个特点有很深的理解：只要类被加载就一起加载，这一点利用好，可以帮我们省去很大的工作量：因为当类被加载的时候我们的static所修饰的成员会被一起加载，所以我们可以省去调用对象这一个环节，直接通过类名.的方式来调用成员，比如说我们昨天举的MyMath例子：在我们使用MyMath类之前需要先创建一个对象之后才能调用，但是我们通过对其方法添加static修饰之后可以省去这一步骤：

public class MyMath {
    //通过添加static修饰符来省去创建对象的步骤
    /*
        通过这里我们也可以学习到：如果没有创建成员变量，我们也可以通过创建静态方法来直接调用类中的方法
     */
    public static int max(int x,int y){
        int max=x>y?x:y;
        System.out.println("最大的是："+max);
        return max;
    }
    public static int max(int x,int y,int z){
        int max=(x>y?x:y)>z?(x>y?x:y):z;
        System.out.println("最大的是："+max);
        return max;
    }
    public static double max(double x,double y){
        double max=((x-y)>0)?x:y;
        System.out.println("最大的是："+max);
        return max;
    }
    public static double max(double x,double y,double z){
        double max=((((x-y)>0)?x:y)-z)>0?(((x-y)>0)?x:y):z;
        System.out.println("最大的是："+max);
        return max;
    }

接下来我们通过代码来看看如何调用静态与非静态的变量：

public class Saber {

    static int num;
    String ori="orioriori";

    public static void main(String[] args) {
        //静态变量可以被直接调用
        Saber.num=18;
        //静态方法可以通过类名.的方法被调用
        Saber.atk();
        //静态方法里可以调用静态属性，但是不能调用非静态属性
       /*
            System.out.println(ori);
            Saber.run();
        */
    }

    public static void atk(){
        System.out.println("给你一拳");
    }

    void run(){
        System.out.println("winwinwin~");
        //非static可以调用static
        Saber.atk();
    }
}

其实其中提到的规则道理都很简单，还是：只要类被加载就跟着一起加载。

代码块

代码块分为静态代码块和实例代码块，都是很容易理解的概念，我们通过接下来的代码来了解，两者有什么区别：

public class Codeblock {
    //实例代码块：直接用大括号包括起来一个符合Java语法的语句即可
    {
        System.out.println("这是一个实例代码块1");
    }
    {
        System.out.println("这是一个实例代码块2");
    }
    //静态代码块：static{//符合Java语法的语句}
    static{
        System.out.println("这是一个静态代码块2");
    }
    static{
        System.out.println("这是一个静态代码块1");
    }
    static void Codeblock(){
        System.out.println("构造方法");
    }
}

实例代码块：在创建对象的时候会被自动调用执行；

静态代码块：加载类的时候会自动调用执行；

那么类在什么时候会被执行，我们首先要知道如果执行类代表着：这个类被调用，所以当有一下三种方式发生的时候就会执行类：1.访问类中的静态成员；2.在一个类中使用main方法；3.创建对象。但是我们要知道类只会被执行一次。

再然后让我们猜一下：如果创建对象的话，计算机是会先执行构造方法还是先执行实例代码块：答案是先执行实例代码块，并且按顺序执行