2021.07.08 Java 构造器以及几个关键字

最新推荐文章于 2024-06-12 11:59:04 发布

这里MMMMMM东西吗？

最新推荐文章于 2024-06-12 11:59:04 发布

阅读量75

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/Mxxxxxx_/article/details/118580879

版权

1、构造器

定义：初始化对象的信息（之前说过，在对象里定义的变量在被new 以后，就会进入堆内存然后给变量赋默认值就是构造器的功能）(这里的初始化：第一次赋值)-----> 为对象的成员变量子啊创建对象的同时给他们赋值。构造器是跟随new一起使用（new的第二步就调用他）

class Person{
    public String name;
    public int age;

    //构造器
    public Person(){}

不需要返回值类型,也没有void
可以根据需要定义return关键字,这时的return作用提前结束方法
构造器的名字与类名保持一致

构造器也是特殊的方法,定义多个重载构造器,构造器的名字都与类名保持一致,参数列表不同就能构成重载构造器
如果没有显示的定义构造器,编译器会自动为类提供一个空构造
如果存在显示定义的构造器,编译器不会提供任意构造器

例如

/*
    Person 类

 */
public class Class002_ConstructorTest {
    public static void main(String[] args) {
        //.1.创建对象的同时就能够确定所有成员的值-->可以选择使用带参构造为对象在创建对象的同时赋值
        Person p = new Person("",1);
        p.show();

        p.name = "某某某";

        //2.创建对象的时候,不确定成员变量值,什么时候确定什么时候赋值
        Person p2 = new Person();
        p2.name = "";
        p2.age = 1;
        p2.show();

        Scanner sc = new Scanner(System.in);

        String str1 = "";  //""字符串对象  空串对象
        String str2 = null; //null是一个空常量,不是对象

    }
}

class Person{
    public String name;
    public int age;

    //构造器
    public Person(){}

    public Person(int personAge){
        age = personAge;
    }

    public Person (String personName,int personAge){
        if(personName == null || personName == ""){
            return;
        }
        name = personName;
        age =  personAge;
    }

    public void eat(){
        System.out.println("胡吃海喝~~~~");
    }

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

2、关键字

2.1 this

指代当前对象（new的对象) —》就是存储所有指向的对象地址

this (参数列表）在构造器的首行调用本类中的其它构造器且只能在构造的第一行

区分同名的成员与局部的问题
默认就近原则
如果出现同名问题,想要指代调用成员,通过this.成员-->因为this指代对象,通过对象调用成员
如果没有同名问题,可以省略this.调用成员
在构造器中使用this,默认指代当前new的对象,存储的是this的对象的地址
在的成员方法中使用this,this在成员方法中默认指代当前调用成员方法的对象

注意:
1.多个构造器之间不能相互调用,否则无法停止调用
2.在static修饰的内容中不能使用this

例如：

 public static void main(String[] args) {
        Dog dog = new Dog("斑点波比","萨摩耶","白色");
        dog.show();

        Dog dog2 = new Dog("小白");
        dog2.show();
        System.out.println("dog2的地址"+dog2);
    }
}

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

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

    public Dog(String name){
        System.out.println("一个参数构造");
        this.name = name;
        System.out.println("this地址" + this);
    }

    public Dog(String name,String type){
        System.out.println("二个参数构造");
        this.name = name;
        this.type = type;
    }

    public Dog(String dogName,String dogType,String dogColor){
        this(dogName,dogType);
        color = dogColor;
        System.out.println("三个参数构造");
    }

    public void lookDoor(){
        System.out.println(name+"正在看家....");
    }
    public void show(){
        String name = "局部的name值";
        //this在成员方法中默认指代当前调用成员方法的对象
        System.out.println(this.name+"-->"+type+"-->"+color);
    }
}

2.2 static 静态的

成员修饰符：只能修饰成员位置的内容，不能修饰局部

修饰变量：静态变量 | 类变量

修饰方法：静态方法 | 类方法

修饰块：静态块修饰类：静态内部类

静态内容的使用：

1、跟随类名使用

类名.静态变量名|静态方法名（参数列表）；

2、跟随对象使用

引用.静态变量名|静态方法名（参数列表）；

成员是是属于对象的
静态的是属于类的

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

注意:
this只能使用在非静态环境中
在非静态方法中使用this,默认指代当前调用实例方法的对象
静态内容是独一份的,静态变量存在与静态区中,多个对象共享的资源
成员内容跟随对象存在与对象的堆内存中,多个对象,就有多份成员
初始加载顺序: 先静态后成员
静态内容在类第一次加载完成之后就会进行初始化
成员变量必须在执行到new对象的时候,才会存在对象的堆内存,在对象的堆内存中才会有成员变量

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

    //静态方法
    public static void main(String[] args) {
        //测试静态内容使用方式
        System.out.println(j); //本类中可以省略类名直接使用
        System.out.println(Class001_Static.j);

        Class001_Static cs = new Class001_Static();
        Class001_Static cs2 = new Class001_Static();
        System.out.println(cs.j);

        //测试实例变量的使用
        System.out.println(cs.i);
        //System.out.println(Class001_Static.i);

        cs.j++;
        cs2.j++;

        System.out.println(cs.j);  //4
        System.out.println(cs2.j); //4
        System.out.println(Class001_Static.j); //4


    }
}

1.在静态内容中,可以直接使用静态的内容,需要跟随对象使用成员
2.在成员内容中,可以直接使用静态内容,可以直接使用成员内容

this不能使用在静态环境中,静态的方法可以直接跟随类调用,可以能根本不存在对象,静态方法的this,无法指代某个对象

静态变量|方法的应用场景:
1.工具类 : Math,Arrays... 静态工厂
可以跟随类名直接使用静态方法,使用简单
2.定义一个类,类中的内容,所有当前类型对象共享的,唯一的可以定义为静态的 | 没有对象就可以使用的成员可以定义为静态的
具体的需要根据业务进行分析,不绝对

//输出答案
public class Class003_StaticTest {
	public static int id;
	public int age;

	public static void main(String[] args) {
		Class003_StaticTest class003_StaticTest = new Class003_StaticTest(); 
		System.out.println(Class003_StaticTest.id);   //0
		System.out.println(class003_StaticTest.age);   //0

		class003_StaticTest.change(); //id=1   age=0       //id=1 class003_StaticTest.age=1
		System.out.println(Class003_StaticTest.id); //1
		System.out.println(class003_StaticTest.id);  //1
		System.out.println(class003_StaticTest.age);  //0
		class003_StaticTest.change();  //id=2   age=0       //id=2 class003_StaticTest.age=1
		System.out.println(id);  // 2
		System.out.println(class003_StaticTest.age);  //0


	}

	public void change() {
		Class003_StaticTest class003_StaticTest = new Class003_StaticTest(); 
		class003_StaticTest.age++;  //
		Class003_StaticTest.id++;  //
		System.out.println("In change(): id = " + id + " age = " + age);  //id=1  2   age= 0  0
		System.out.println("In change(): id = " + id + " class003_StaticTest.age = " + class003_StaticTest.age);
		//id=1 2  class003_StaticTest.age=1 1

	}
}

2.3 block(了解）

{} 块自成作用域
分类执行时机
局部代码块|普通语句块 : {}定义在方法中跟随方法的调用而执行
1) 作用域看待
2) 语义化
构造块 : {}定义在类中方法外跟随new一起使用
1) 成员内容的初始信息,比构造器中的代码跟早执行
2) 对对象的某些内容进行初始
静态块 : static修饰{},定义在类中方法外在类第一次加载完成之后执行
1) 会为静态内容进行初始化
2) 信息的配置,资源的加载
同步块 : 会在多线程学习

构造块中的代码会先于构造器中的代码之前执行
如果存在多个构造块,会从上到下一次执行
静态块在类第一次加载完成之后执行,并且仅会执行一次
如果存在多个静态块,会从上到下一次执行

静态块-->main-->创建对象 --> 构造块 --> 构造器

例如：

//找到打印顺序+结果
/*
	构造块在编译期间,会被编译到要执行的构造器内部,放在构造器代码的上面
 */
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) { //n=6
		//构造块
		/*{
			a = 10;
			System.out.println("3、非静态代码块执行a=" + a); //10
		}*/
		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();
	}
}

3 Debug调试工具

debug的作用:
       1.追踪程序的执行流程
       2.定位异常出现的位置
        3.观察程序运行期间变量变化的情况
       4.根据程序的执行流程学习第三方框架的源码

   步骤:
   1.打断点
         在行号的后面单击设置断点,单击取消断点
2.debug运行
step over F8 下一步跳过
         如果遇到方法的调用,不进入,直接跳过进入下一行
       step into F7 步入
        如果下一步遇到自定义方法的调用,进入方法跟随执行,如果是jdk提供的方法,不会进入
       Force step into alt+shift+F7 强制步入
      如果是jdk提供的方法,会强制进入跟随执行
      step out shift+F8 跳出
  如果执行在方法的调用中,下一步直接调出到方法调用的位置
      Run to Cursor 运行到光标所在位置

这里MMMMMM东西吗？

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2021.07.08 Java 构造器以及几个关键字

1、构造器定义：初始化对象的信息（之前说过，在对象里定义的变量在被new 以后，就会进入堆内存然后给变量赋默认值就是构造器的功能）(这里的初始化：第一次赋值)-----> 为对象的成员变量子啊创建对象的同时给他们赋值。构造器是跟随new一起使用（new的第二步就调用他）class Person{ public String name; public int age; //构造器 public Person(){}不需...
复制链接

扫一扫