JAVASE——构造器、this、static、block和debug

最新推荐文章于 2024-05-21 15:20:38 发布

代码压力大233

最新推荐文章于 2024-05-21 15:20:38 发布

阅读量232

点赞数

文章标签： java intellij-idea

本文链接：https://blog.csdn.net/weixin_45989875/article/details/123409507

版权

一、构造器|构造函数|构造方法

new关键字做的事情:
1.在堆中为对象开辟空间,成员变量跟随对象进入到堆内存并附默认值
2.调用构造器为对象初始化信息
3.将地址返回给引用

构造器是一种特殊的方法

作用: 为对象初始化信息,为对象的属性赋值,不是用来创建对象的,new能够创建对象
调用: 只能跟随new一起使用
定义:
修饰符类名(参数){
初始化信息代码;
}

注意:
构造器可以实现重载
如果没有显示定义任何构造器,编译器会自动默认提供一个空构造(没有参数)
如果存在显示定义构造器,编译器都不会再提供任何构造器
至少实体类中自定义一个空构造,根据需求提供带参

public class Class001_Constructor {
    public static void main(String[] args) {
        //创建对象
        Dog dog = new Dog();
        //为属性赋值
        dog.name="点点";
        dog.type="泰迪";
        dog.color="白色";

        //带构造实现创建对象的同时为对象的属性赋值
        Dog dog2 = new Dog("二狗子");
        dog2.show();

        Dog dog3 = new Dog("三狗子","萨摩耶","白色");
        dog3.show();
    }
}


class Dog{
    public String name;
    public String type;
    public String color;

    //空构造
    public Dog(){
        System.out.println("空构造...");
    }

    public Dog(String dogName){
        System.out.println("带1个参构造...");
        name = dogName;
    }

    public Dog(String dogName,String dogType,String dogColor){
        System.out.println("带3个参构造...");
        name = dogName;
        type = dogType;
        color = dogColor;
    }

    public void show(){
        System.out.println(name+"-->"+type+"-->"+color);
    }
}

二、This 关键字

This指代当前new的对象

作用:
1) 在构造器的首行通过this(实参)调用本类中其他构造器
构造器不能相互调用

2) 区分同名成员与局部变量问题
默认会发生就近原则
可以通过this.调用成员,否则默认找局部
如果不存在局部与成员同名问题,指代成员的this.可以省略

注意:
1.this在构造器中使用,默认指代当前new的对象
2.在成员方法中的this,默认指代调用成员方法的对象
3.this不能使用在static方法中

public class Class001_This {
    public static void main(String[] args) {
        /*Person p = new Person("张三",18,true);
        p.show();*/

        Person p = new Person("张三");
        System.out.println("p--->地址--->"+p);
        p.show();
    }
}

class Person{
    //属性
    public String name;
    public int age;
    public boolean gender;

    //构造器
    public Person(){
        System.out.println("-----空造器.....");
    }

    //带参构造
    public Person(String name){
        System.out.println("-----1个参数构造器.....");
        this.name = name;
    }
    public Person(String name,int age){
        System.out.println("-----2个参数构造器.....");
        this.name = name;
        this.age = age;
    }

    public Person(String name,int age,boolean gender){
        this(name,age);
        this.gender = gender;
        System.out.println("-----3个参数构造器.....");
    }

    //功能
    public void show(){
        System.out.println("this------->"+this);
        String name = "str";
        System.out.println(this.name+"--->"+age+"--->"+this.gender);
    }
}

三、Static 关键字

static 静态的
成员修饰符,可以修饰成员内容,不可以修饰局部

修饰成员变量--> 静态变量|类变量
修饰方法 --> 静态方法|类方法
修饰块
修饰类

static修饰的成员变量与成员方法使用方式:
1.对象.静态变量名
对象.静态方法名(参数列表)
2.类名.静态变量名
类名.静态方法名(参数列表)

注意:
成员是属于对象的,需要跟随对象使用
静态的是属于类的,根据可以随类名使用

成员 :
被static修饰的--> 类的成员
变量-> 静态变量|类变量
方法-> 静态方法|类方法
没有被static修饰 --> 实例成员
变量-> 实例变量
方法-> 实例方法

静态内容是属于类的,在类第一次加载完成之后就初始化
初始顺序 : 先静态后成员
成员存在与对象的堆内存中,new对象了才开辟堆内存,才在对象的堆内存中存在成员
静态变量会给加载到静态区中,每个类的静态变量只有一份

静态内容是当前类所有对象共享的,独一份的
成员内容是属于每一个对象的,有几个对象就存在几份

public class Class001_Static {
    //类中方法外
    int i = 1;  //实例变量
    static int j = 2;  //静态变量

    public static void main(String[] args) {
        //局部
        //测试调用
        System.out.println(Class001_Static.j);
        Class001_Static cs = new Class001_Static();
        System.out.println(cs.i);
        System.out.println(cs.j);

        Class001_Static.testStatic();
        cs.testStatic();

        cs.test();
    }

    //成员方法
    public void test(){
        System.out.println("成员方法");
    }

    //静态方法
    public static void testStatic(){
        System.out.println("静态方法");
    }
}

静态的使用注意：
成员方法中的this默认指代当前调用成员方法的对象
成员方法中可以直接使用成员可以直接使用静态
静态方法中可以直接使用静态内容需要通过对象使用成员
在静态方法中不能使用this,因为冲突

四、block 块

块 {}:
自成作用域

{}定义在方法中|语句块中 : 局部代码块|普通语句块执行时机 : 跟随方法
{}定义在类中方法外 : 构造块 |成员代码块执行时机 : 跟随new
static{}定义在类中方法外 : 静态块执行时机 : 类第一次加载
同步代码块 : 多线程时候讲

注意 :
构造块中的代码先于构造器代码之前执行,因为在编译期间构造块代码会被编译到要执行的构造器内部,构造器代码之前
如果存在多个构造块,从上到下依次执行
静态块中的内容在类第一次加载完成之后就执行,并且只执行一次,先与main方法执行
如果存在多个静态块,从上到下依次执行

执行顺序 : 静态块 --> main ---> 构造块 --> 构造器

public class Class001_Block {
    static int i = 10;
    int j;

    //静态块
    static{
        System.out.println("我是静态块1");
    }
    static{
        System.out.println("我是静态块2");
    }
    static{
        System.out.println("我是静态块3");
    }

    public Class001_Block(){
        System.out.println("构造器...");
    }
    public Class001_Block(int j){
        System.out.println("构造器...");
    }

    //构造块
    {
        j = 10;
        System.out.println("构造块1");
    }
    {
        System.out.println("构造块2");
    }
    {
        System.out.println("构造块3");
    }

    public static void main(String[] args) {
        i = 1;
        //局部代码块|普通语句块
        {
            System.out.println("局部代码块");
            int  i = 5;
            System.out.println(i); //5
        }
        System.out.println(i); //1

        Class001_Block cb  = new Class001_Block();
        Class001_Block cb2  = new Class001_Block();
    }
}

注意: 构造块会被编译到要执行的构造器代码的内部的最上面,如果this(),先执行this()

public class Class002_BlockTest {
	public static int a = 0;

	{
		a = 10;
		System.out.println("3  、非静态代码块执行a=" + a); //10
	}

	static {
		a = 6;
		System.out.println("1 、静态代码块执行a=" + a); //6
	}
	public Class002_BlockTest() {
		this(a); //6

		System.out.println("6 、"+a);  //10
		System.out.println("7 、无参构造方法执行a=" + a); //10
	}
	public Class002_BlockTest(int n) {
		System.out.println("4 、"+n); //6
		System.out.println("5 、"+a);//10
	}	
	public static void main(String[] args) {
		System.out.println("2 、main"); //main
		Class002_BlockTest tsc = new Class002_BlockTest();
	}
}

五、Debug 调试工具

       作用 :
           1.追踪程序的执行流程
           2.定位异常问题出现的位置
           3.执行过程中方便观察变量的变化
           4.通过追踪程序的执行流程学习一些第三方框架的源码

   步骤 :
       1.设置断点
           debug模式运行的时候停在第一个断点位置,后续的执行有程序员手动控制
       2.debug模式运行
       3.
           Step over F8 : 下一步跳过|略过
               如果下一步是方法的调用,直接略过,不跟随方法内部执行
           Step into F7 : 下一步如果是方法的调用,进入方法跟随一起执行
               要求是自定义方法才会进入跟随,jdk提供方法不会进入
           Force Step into alt+shift+F7 : 强制进入,如果下一步是jdk方法的调用,进入跟随执行
           Step out shift+f8 : 跳出到方法调用的下一步
           Run to Cursor : 运行的到光标所在位置