Java学习总结（面向对象中this关键字、代码块、static关键字）

最新推荐文章于 2023-10-08 09:20:21 发布

Qinqin.J

最新推荐文章于 2023-10-08 09:20:21 发布

阅读量328

点赞数

文章标签： java 学习

本文链接：https://blog.csdn.net/2202_75688394/article/details/130153982

版权

一、this关键字

1、使用this关键字调用本类中的属性

2、使用 this 关键字调用成员方法

3、使用 this 关键字调用本类的构造方法

使用 this 调用类的构造方法时，应注意以下几点。

示例：使用 static 关键字修饰 school 属性

2、静态方法

3、静态代码块

学习Java中的面向对象中this关键字、代码块、static关键字

一、this关键字

在Java开发中，当成员变量与局部变量重名时，需要使用到this关键字分辨成员变量与局部变量，Java中的this关键字语法比较灵活，

其主要作用有以下3种。

（1）使用this关键字调用本类中的属性。

（2）使用this关键字调用成员方法。

（3）使用this关键字调用本类的构造方法。

1、使用this关键字调用本类中的属性

Student类定义成员变量age表示年龄，而构造方法中表示年龄的参数是a，这样程序可读性很差。这时需要将一个类中表示年龄的变量进行统一命名，例如都声明为 age。但是这样做会导致成员变量和局部变量的名称冲突。

示例：

class Student{
    private String name;
    private int age;
    //定义构造方法
    public Student(String name, int age) {
        name = name;
        age = age;
    }
    public String read(){
        return "我是："+name+",年龄"+age;
    }
}
public class Example09 {
    public static void main(String[] args) {
        Student stu = new Student("张三", 18);
        System.out.println(stu.read());
    }
}
//结果：我是：null,年龄0

由结果发现，对象连名为null，年龄为0，这表明构造方法中的慰值并改有成功。这是的为构造方法的参数名称与对象成反变量名积相同，编译等无法确定哪个名称是当前对象的属性。为了解走个问题，Java提供了this关键字来指代当前对象，通过this可以访问当前对象的成员。

示例：

class Student{
    private String name;
    private int age;
    //定义构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String read(){
        return "我是："+name+",年龄"+age;
    }
}
public class Example10 {
    public static void main(String[] args) {
        Student stu = new Student("张三", 18);
        System.out.println(stu.read());
    }
}
//结果：我是：张三,年龄18

由结果看出，成功调用构造方法完成stu对象的初始化。这是因为在构造方法中，使用 this 关键字明确标识出了类中的两个属性“ this.name ”和“ this.age ”，所以在进行赋值操作时不会产生歧义。

2、使用 this 关键字调用成员方法

通过 this 关键字调用成员方法，具体示例代码如下：

class Student {
    public void openMouth ( ) {
         ...
    }
    public void read ( ) {
         this.openMouth ( ) ;
    }
}

上面的read ( ) 方法中，使用 this 关键字调用 openMouth ( ) 方法。此处的this关键字也可以省略不写。

3、使用 this 关键字调用本类的构造方法

构造方法在实例化对象时被Java虚拟机自动调用，在程序中不能像调用其他成员了法一样调用构造方法，但可以在一个构造方法中使用 “ this (参数1，参数2...) ”的形式调用其他的构造方法。

示例：

class Student{
    private String name;
    private int age;
    //无参数构造
    public Student(){
        System.out.println("实例化了一个新的Student 对象。");
    }
    //有参数构造
    public Student(String name, int age) {
        this(); //调用无参数的构造方法
        this.name = name;
        this.age = age;
    }
    public String read(){
        return "我是："+name+",年龄："+age;
    }
}
public class Example11 {
    public static void main(String[] args) {
        Student stu = new Student("张三", 18);//实例化对象
        System.out.println(stu.read());
    }
}
/*
结果：实例化了一个新的Student 对象。
        我是：张三,年龄：18
        */

提供了两个构造方法，其中，有两个参数的构造方法中使用this ( ) 的形式调用本类中的无参数构造方法，由结果得知，无参构造和有参数构造方法均调用成功。

使用 this 调用类的构造方法时，应注意以下几点。

（1）只能在构造方法中使用this调用其他的构造方法，不能在成员方法中通过this调用其他构造方

法。

（2）在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次。

错误示例：

public Student (String name) {
    System.out.println("有参的构造方法被调用了。");
    this(name); //不在第一行，编译错误
}

（3）不能在一个类的两个构造方法中使用 this 互相调用。

错误示例：

class Student {
    public Student(){
        this("张三"); //调用有参构造方法
        System.out.println("无参的构造方法被调用了。");
    }
    public Student (String name) {
        this( ); //调用无参构造方法
        System.out.println("有参的构造方法被调用了。");
    }
}

二、代码块

代码块，简单来说，就是用“ { } ”括号括起来的一段代码，根据位置及声明关键字的不同，代码块可以分为普通代码块、构造块、静态代码块、同步代码块4种。

1、普通代码块

普通代码块就是直接在方法或语句中定义的代码块，具体示例如下：

public class Example12 {
    public static void main(String[] args) {
    {
        int age = 18;
        System.out.println("这是普通代码块。age："+age);
    }
    int age = 30;
        System.out.println("age:"+age);
    }
}

在上述代码中，每一对“ { } ”括起来的代码都称为一个代码块。Example12是一个大的代码块，在Example12代块中包含了main ( ) 方法代码块，在main( )方法中又定义了一个局部代码块，局部代码块对main方法进行了“ 分隔 ”，起到了限定作用域的作用。局部代码块中定义了变量age,main()方法代码块中也定义了变量age，但由于两个变量处在不同的代码块，作用域不同，因此并不相互影响。

2、构造块

构造块（又称构造代码块）是直接在类中定义的代码块。

示例：构造代码块的作用

class Student{
    String name; //成员属性
    {
        System.out.println("我是构造代码块");  //与构造方法同级
    }
    //构造方法
    public Student(){
        System.out.println("我是Student 类的构造方法");
    }
}
public class Example12 {
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student();
    }
}
/*
结果：
        我是构造代码块
        我是Student 类的构造方法
        我是构造代码块
        我是Student 类的构造方法
        */

结果可以看出，在实例化Student类对象stu1、stu2时，都先输出了“ 我是构造代码块 ”，表明构造块的执行顺序优先于构造方法（这里的执行顺序与构造块写在前面还是后面是没有关系的）。

三、static 关键字

在定义一个类时，只是在描述某事物的特征和行为，并没有产生具体的数据。只有通过new关键字创建该类的实例对象时，才会开辟栈内存和堆内存，在堆内存中每个对象会有自己的属性。如果希望某些属性被所有对象共享，就必须将其声明为static 属性。如果属性使用了 static 关键字进行修饰，则该属性可以直接使用类名的进行调用。除了修饰属性，static 关键字还可以修饰成员方法。

1、静态属性

如果在Java程序中使用 static 修饰属性，则该属性称为静态属性（也称全局属性），静态属性可以使用类名直接访问。

格式：

类名.属性名

示例：

class Student{
    String name; //定义name
    int age; //定义age
    String school = "A大学";  //定义school
    //构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;   //给成员变量赋值
    }
    public void info(){
        System.out.println("姓名："+this.name+",年龄："+this.age+",学校："+school);
    }
}
public class Example13 {
    public static void main(String[] args) {
        Student stu1 = new Student("张三", 18);
        Student stu2 = new Student("李四", 19);
        Student stu3 = new Student("王五", 20);  //实例化对象
        stu1.info();
        stu2.info();
        stu3.info();  //调用访问
    }
}
/*
结果：
        姓名：张三,年龄：18,学校：A大学
        姓名：李四,年龄：19,学校：A大学
        姓名：王五,年龄：20,学校：A大学*/

为了解决上述问题，可以使用 static 关键字修饰 school 属性，将其变为公共属性。这样，school 属性只会分配一块内容空间，被 Student 类的所有对象共享，只是某个对象进行一次修改，全部学生对象的 school 属性值都会发生变化。

示例：使用 static 关键字修饰 school 属性

public class Example14 {
    public static void main(String[] args) {
        Student stu1 = new Student("张三", 18);  //实例化对象
        Student stu2 = new Student("李四", 19);
        Student stu3 = new Student("王五", 20);
        stu1.info();  //调用方法
        stu2.info();
        stu3.info();
        Student.school = "B大学";  //静态属性访问 类名.属性名  修改默认值为B大学
        stu1.info();
        stu2.info();
        stu3.info();
    }
}
class Student{
    String name; //定义name属性
    int age;  //定义age属性
    static String school = "A大学";  //定义school属性 静态变量  默认为A大学
    //构造方法
    public Student(String name, int age) {
        this.name = name;  // 赋值
        this.age = age;
    }
    public void info(){
        System.out.println("姓名："+this.name+",年龄："+this.age+",学校："+school);
    }
}

/*
结果：
        姓名：张三,年龄：18,学校：A大学
        姓名：李四,年龄：19,学校：A大学
        姓名：王五,年龄：20,学校：A大学
        姓名：张三,年龄：18,学校：B大学
        姓名：李四,年龄：19,学校：B大学
        姓名：王五,年龄：20,学校：B大学
        */

只修改了一个stu1对象的学校属性，stu1 和 stu2 对象的school 属性内容都发生了变化，说明使用 static 声明的属性是被所有对象共享的。

小提示：static 不能修饰局部变量

static 关键字只能修饰成员变量，不能修饰局部变量，否则编译器会报错

错误示例：

public class Student {
    public void study(){
        static int num = 10; //这行代码是非法的，编译器会报错
    }
}

2、静态方法

如果想要使用类中的成员方法，就需要先将这个类实例化，而在实际开发时，开发人员有时希望在不创建对象的情况下，通过类名就可以直接调用某个方法，要实现这样的效果，只需要在成员方法前加上static关键字，使用static关键字修饰的方法通常称为静态方法。
同静态变量一样，静态方法也可以通过类名和对象访问，具体如下：

//静态方法的使用
public class Example15 {
    public static void main(String[] args) {
        Student stu1 = new Student("张三", 18);  //实例化对象
        Student stu2 = new Student("李四", 19);
        Student stu3 = new Student("王五", 20);
        stu1.setAge(20);  //将李四的信息修改成小明
        stu2.setName("小明");
        Student.setSchool ("B大学");  //静态属性访问 类名.属性名  修改默认值为北海职业大学（全局修改）  封装性调用访问
        stu1.info();
        stu2.info();
        stu3.info();  //调用方法
    }
}
class Student{
    //封装性
    private String name; //定义name属性
    private int age;  //定义age属性
    public static String school = "A大学";  //定义school属性 静态变量  默认为A大学
    //构造方法
    public Student(String name, int age) {
        this.name = name;  // 赋值
        this.age = age;
    }
    public void info(){
        System.out.println("姓名："+this.name+",年龄："+this.age+",学校："+school);
    }
    // 封装性
    //获取name属性
    public String getName() {
        return name;
    }
    //设置name属性
    public void setName(String name) {
        this.name = name;  //赋值
    }
    //获取age属性
    public int getAge() {
        return age;
    }
    //设置age属性
    public void setAge(int age) {
        this.age = age;
    }
    //获取school属性
    public static String getSchool() {
        return school;
    }
    //设置school属性
    public static void setSchool(String school) {
        Student.school = school;
    }
}
/*结果：
        姓名：张三,年龄：20,学校：B大学
        姓名：小明,年龄：19,学校：B大学
        姓名：王五,年龄：20,学校：B大学*/

注意：

静态方法只能访问静态成员，因为非静态成员需要先创建对象才能访问，即随着对象的创建，非静态成员才会被分配内存。而静态方法在被调用时可以不创建任何对象。

3、静态代码块

在Java类中，用 static 关键字修饰的代码块称为静态代码块。当类被加载时，静态代码块会执行，由于类只加载一次，因此静态代码块只执行一次。在程序中，通常使用静态代码块对类的成员变量进行初始化。

示例：静态代码块的使用

class Student{
    {
        System.out.println("我是构造代码块");
    }
    static {
        System.out.println("我是静态代码块");
    }
    //构造代码块
    public Student(){
        System.out.println("我是Student 类的构造方法");
    }
}
public class Example16 {
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2= new Student();
        Student stu3 = new Student();
    }
}
/*
结果：
        我是静态代码块
        我是构造代码块
        我是Student 类的构造方法
        我是构造代码块
        我是Student 类的构造方法
        我是构造代码块
        我是Student 类的构造方法
        */

由结果可以看出，代码块的执行顺序为静态代码块、构造代码块、构造方法。static修饰的成员会随着class文件一同加载，其优先级最高。在main()方法中创建了3个Student对象，但在3次实例化对象的过程中，静态代码块中的内容只输出了一次，这就说明静态代码块在类第一次使用时才会被加载，并且只会加载一次。