java面向对象---this、static、代码块

雨天_

已于 2022-11-04 21:22:55 修改

阅读量130

点赞数 1

文章标签： java 开发语言 ide

于 2022-04-07 21:00:27 首次发布

本文链接：https://blog.csdn.net/weixin_62443409/article/details/123995653

版权

一、this的使用

【1】创建对象的过程：

（1）在第一次遇到这个类的时候，对这个类要进行加载，只加载一次

（2）创建对象，在堆中开辟空间

（3）对对象进行初始化操作，属性赋值都是默认的初始值

（4）new关键字调用构造器，执行构造方法，在构造器中对属性重新进行赋值

this:

从上面的效果能够看到，this指代的就是当前对象

内存分析：

this 关键字的用法：

（1）this 可以修饰属性：

总结：属性名字和形参重名的时候，或者属性名字和局部变量的名字重名的时候，都会发生就近原则。所以如果直接使用变量名字，就指的是离得近的那个星灿或者局部变量。

要表示属性的话，在前面加上 this. 修饰

不发生重名问题的话，访问属性也可省略 this.

package com.mxdx4;

/**
 * @Auther:雨天_
 * @Date: 2022/4/6 - 04 - 06 - 21:58
 * @Descroption: com.mxdx4
 * @version:1.0
 */
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---->局部变量
        System.out.println(this.age);//这里指代的是属性的age
        System.out.println("我喜欢吃饭");
    }
}

package com.mxdx4;

/**
 * @Auther:雨天_
 * @Date: 2022/4/6 - 04 - 06 - 22:02
 * @Descroption: com.mxdx4
 * @version:1.0
 */
public class Test {
    //这是一个main方法
    public static void main(String[] args) {
        //创建一个Person类的具体的对象
        Person p = new Person(19,"wyd",170.1);
    }
}

（2）this 修饰方法：

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

package com.mxdx4;

/**
 * @Auther:雨天_
 * @Date: 2022/4/6 - 04 - 06 - 21:58
 * @Descroption: com.mxdx4
 * @version:1.0
 */
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---->局部变量
        System.out.println(this.age);//这里指代的是属性的age

         */
        System.out.println("我喜欢吃饭");
    }

    public void play(){
        //System.out.println("吃饭");
        /*this.*/eat();
        System.out.println(/*this.*/age);
        System.out.println("上网");
        System.out.println("洗澡");
    }
}

（3）this 可以修饰构造器

总结：同一个类中的构造器也可以相互用 this 调用。

（ps：this 修饰构造器必须放在第一行）

package com.mxdx4;

/**
 * @Auther:雨天_
 * @Date: 2022/4/6 - 04 - 06 - 21:58
 * @Descroption: com.mxdx4
 * @version:1.0
 */
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);
        this.name = name;

    }
    public Person(int age){
        this.age = age;
    }
    //方法
    public void eat(){
        /*int age = 10;
        System.out.println(age);//就近原则,指的是最近的age---->局部变量
        System.out.println(this.age);//这里指代的是属性的age

         */
        System.out.println("我喜欢吃饭");
    }

    public void play(){
        //System.out.println("吃饭");
        /*this.*/eat();
        System.out.println(/*this.*/age);
        System.out.println("上网");
        System.out.println("洗澡");
    }
}

二、static 的使用

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

1. static 修饰属性：

package com.mxdx5;

/**
 * @Auther:雨天_
 * @Date: 2022/4/6 - 04 - 06 - 22:38
 * @Descroption: com.mxdx5
 * @version:1.0
 */
public class Test {
    //属性
    int id;
    static int sid;

    //这是一个main方法
    public static void main(String[] args) {

        //创建一个Test类的具体的对象
        Test t1 = new Test();
        t1.id = 10;
        t1.sid = 10;

        Test t2 = new Test();
        t2.id = 20;
        t2.sid = 20;

        Test t3 = new Test();
        t3.id = 30;
        t3.sid = 30;

        //读取该属性的值
        System.out.println(t1.id);
        System.out.println(t2.id);
        System.out.println(t3.id);

        System.out.println(t1.sid);
        System.out.println(t2.sid);
        System.out.println(t3.sid);
    }
}

内存分析：

一般官方的推荐访问方式是：类名 . 属性名

        Test.sid = 100;
        System.out.println(Test.sid);

修饰属性总结：

（1）在类加载的时候，一起加载入方法区中的静态域中

（2）先于对象存在

（3）通过对象名 . 属性名来访问，或者通过类名 . 属性名（推荐）来访问

修饰属性的应用场景：特定属性在内存中共享(只有一块)--->这种情况就可以用 static 来修饰

属性分为：静态属性（类变量）动态属性（实例变量）

package com.mxdx5;

/**
 * @Auther:雨天_
 * @Date: 2022/4/7 - 04 - 07 - 18:01
 * @Descroption: com.mxdx5
 * @version:1.0
 */
public class Student {
    //属性：
    String name;
    int age;
    double height;
    static String school;

    //构造器：
    public Student(){

    }

    //这是一个main方法
    public static void main(String[] args) {

        Student.school = "yszx";

        Student s1 = new Student();
        s1.name = "dz";
        s1.age = 19;
        s1.height =124.4;
        //s1.school = "yszx";
        
        Student s2 = new Student();
        s2.name = "ww";
        s2.age = 19;
        s2.height =140.4;
        //s2.school = "yszx";
        
        System.out.println(s2.school);
    }
}

2. static 修饰方法

package com.mxdx5;

/**
 * @Auther:雨天_
 * @Date: 2022/4/7 - 04 - 07 - 18:18
 * @Descroption: com.mxdx5
 * @version:1.0
 */
public class Demo {
    int id;
    static int sid;

    public void a(){
        System.out.println(id);
        System.out.println(sid);
        System.out.println("-----a");
    }

    //1.static和public 没有先后顺序,都是修饰符
    public static void b(){
        //System.out.println(this.id);静态方法中不能使用this关键字
        //a();静态方法中不能访问非静态的方法
        //System.out.println(id);静态方法中不能访问非静态的属性
        System.out.println(sid);
        System.out.println("-----b");
    }


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

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

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

三、代码块

类的组成：属性、方法、构造器、代码块、内部类

代码块分类：

普通块、静态块、构造块、同步块（多线程）

package com.mxdx6;

/**
 * @Auther:雨天_
 * @Date: 2022/4/7 - 04 - 07 - 18:53
 * @Descroption: com.mxdx6
 * @version:1.0
 */
public class Test {
    //属性
    int a;
    static int sa;

    //方法
    public void a(){
        System.out.println("-----a");
        {
            //普通块限制了局部变量的作用范围
            System.out.println("这是普通块");
            int num = 11;
            System.out.println(num);
        }
    }

    public static void b(){
        System.out.println("-----b");
    }
    //System.out.println("-----ccc");
    //构造块:解决在方法外写代码的问题
    {
        System.out.println("这是构造块");
        System.out.println("-----ccc");
    }
    //静态块:static修饰的
    static {
        //在静态块中只能访问：静态属性，静态方法
        System.out.println("这是静态块");
        System.out.println("-----ddd");
        System.out.println(sa);
        b();
    }

    //构造器
    public Test(){
        System.out.println("这是空构造器");

    }
    public Test(int a){
        this.a = a;
    }

    //这是一个main方法
    public static void main(String[] args) {
        Test t = new Test();
        t.a();

        Test t2 = new Test();
        t2.a();
    }
}

运行结果：

总结：

代码块执行顺序：

（1）最先执行静态块：只在类加载的时候执行一次，一般用于执行一些全局性的初始化操作。例如：创建工厂，数据库的初始化信息

（2）第二个执行构造块（不常用）

（3）在执行构造器

（4）最后执行方法中的普通块

四、包--import

1. 包的作用：

解决重名问题（实际上的包对应的就是盘符上的文件夹）解决权限问题

2.创建包

包名定义：

（1）名字全部小写

（2）中间用 . 隔开

（3）一般是公司域名倒着写。例如：com.tb com.jd com.albb

（4）一般加上模块名字例如：com.jd.login

（5）不能使用系统中的关键字例如：con , nul , com1-----com9.....

（6）包声名的位置一般都在非注释性代码的第一行例如：

3. 导包问题

//声名包：
package com.mxdx7;

import com.mxdx3.Person;

import java.util.Date;

/**
 * @Auther:雨天_
 * @Date: 2022/4/7 - 04 - 07 - 19:49
 * @Descroption: com.mxdx7
 * @version:1.0
 */
public class Test {
    //这是一个main方法
    public static void main(String[] args) {
        new Person();
        new Date();
        new java.sql.Date(1111L);//导包后，还想用别的别的包下同名的类，就得手动导包
        new Demo();//同一个包下的类不需要导包
    }
}

package com.mxdx7;


public class Demo {

}

总结：

（1）使用不同包下的类需要导包

（2）导包后，还想用别的包下的同名的类，就得手动导包

（3）同一个包下的类使用的时候无需导包，可直接使用

（4）在 java.lang 包下的类，可以直接使用，无需导包

（5）导包快捷键：alt + enter

（6）可直接导入 * （ * 代表所有）

4.在 java 中的导包没有包含和被包含的关系

5.静态导入

package com.mxdx7;

//静态导入：
import static java.lang.Math.*;
//导入java.lang 下的 Math 类中的所有静态内容
/**
 * @Auther:雨天_
 * @Date: 2022/4/7 - 04 - 07 - 20:02
 * @Descroption: com.mxdx7
 * @version:1.0
 */
public class Demo {
    //这是一个main方法
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
        System.out.println(round(5.6));
    }

    //静态导入后，同一各类中有相同的方法的时候，优先走自己定义的方法
    public static int round (double a){
        return 1314;
    }
}