idea同时创建无参和有参构造器_java基础7（this、static、构造器、块）

一、this

this 代表当前对象(当前new的对象)本身,存储当前对象的地址

构造器中使用,构造器的*首行*使用

调用本类中的其他构造器 this(参数列表) -->实参

作用:可以帮转我们简化代码

注意:

1.必须在首行

2.构造器之间不能相互调用

区分同名变量问题:成员方法中使用,构造器中..

局部和成员之间.. 会发生就近原则,指向同名的成员,使用this

成员方法中,this代表当前调用成员方法的对象

如果同名,不适用this调用,默认发生就近原则

如果不存在同名问题,使用成员变量,前面默认省略了this

构造器中区分同名:

this-->当前new的对象

this不能使用在static修饰的方法中

class Demo{
    String str = "这是成员变量";
    void fun(String str){
        System.out.println(str);
        System.out.println(this.str);
        this.str = str;
        System.out.println(this.str);
    }
}
public class This{
    public static void main(String args[]){
        Demo demo = new Demo();
        demo.fun("这是局部变量");
    }
}


public class ThisDemo01 {
	public static void main(String[] args) {
		Flower f=new Flower("红色","玫瑰花", 1,12);
		System.out.println(f.color);
		System.out.println(f.type);
		System.out.println(f.num);
		System.out.println(f.age);
		f.open("紫色");
		
		Flower f2=new Flower("黄色","百合", 1);
		f2.open("");
	}
}
class Flower{
	public String color;
	public String type;
	public int age;
	public int num;
	
	public Flower() {
		System.out.println("我是空构造");
	}
	public Flower(String color,String type,int age) {
		System.out.println("我是3个参数构造器");
		this.color=color;
		this.type=type;
		this.age=age;
	}
	public Flower(String color,String type,int age,int num) {
		//调用空构造
		this(color,type,age);
		System.out.println("我是4个参数构造器");
		this.num=num;
	}
	public void open(String color){
		int num=10;
		System.out.println(this.color+"花开了..."+this.num);  //就近原则
	}
}

二、static

static 静态的 成员修饰符

static修饰变量-->静态变量|类变量

static修饰方法-->静态方法|类方法

静态内容的使用:

类名.静态变量名

对象.静态变量名

类名.静态方法名([参数列表]);

对象.静态方法名([参数列表]);

package com.ymz.test;
public class StaticTest02 {
	public static int age;
	public int id;
	public static void main(String[] args) {
		StaticTest02 staticTest02=new StaticTest02();
		System.out.println(StaticTest02.age);//0
		System.out.println(staticTest02.id);//0
		staticTest02.Change();//1 0
		System.out.println(StaticTest02.age);//1
		System.out.println(staticTest02.age);//1
		System.out.println(staticTest02.id);//0
		staticTest02.Change();//
		System.out.println(age);//2
		System.out.println(staticTest02.id);//0
	}
	public void Change(){
		StaticTest02 staticTest02=new StaticTest02();
		staticTest02.id++;//1
		StaticTest02.age++;//1
		System.out.println("In Change(): age="+age+"id="+this.id);
		System.out.println("In Change(): age="+age+"staticTest02="+staticTest02.id);
	}
}

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

静态的内容是独一份的,在静态区中,这个类所有对象共享一个类的静态内容,只在类第一次加载后初始化一次

如果静态的内容中可以直接使用静态的内容,但是不能直接使用成员的内容,通过对象去使用

如果成员的内容中,可以直接使用静态的内容,可以直接使用成员的内容

public class StaticDemo01 {
	static int id = 15;  //静态变量
	int age=10;  //成员变量
	public static void main(String[] args) {
		System.out.println(id);
		StaticDemo01 s=new StaticDemo01();
		System.out.println(s.age);
		System.out.println(s.id);
		System.out.println(StaticDemo01.id);
		
		change();  //  id=16  age=11
		System.out.println(s.age);   // 10
		System.out.println(s.id);    // 16
		System.out.println(StaticDemo01.id);  //16
		
		change();   //id=17  age=11
		System.out.println(s.age);   // 10
		System.out.println(s.id);    // 17
		System.out.println(StaticDemo01.id);  //17
		
		s.test();  // id=18 age=11
		System.out.println(s.age);   // 11
		System.out.println(s.id);   // 18
		
	}
	//静态的内容
	public static void change(){
		id++;
		StaticDemo01 s=new StaticDemo01();
		s.age++;
		System.out.println(id+"--->"+s.age);  
	}
	
	//成员内容
	public void test(){
		id++;
		this.age++;   // this指代调用成员方法的对象
		System.out.println(this.id+"-->"+this.age); //
	}
}

三、构造器

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

new会做3件事情:

1.在堆中为对象开辟空间,成员属性会跟随对象进入到堆内存中,并赋默认值

2.调用构造器为对象初始化信息

3.把地址反回给引用

构造器的作用:

为对象初始化信息,但不是创建对象的作用

构造器如何使用:

只能跟随new一起使用

定义:

修饰符 类名([参数列表]){

方法体;

}

如果没有在类中自定义构造器,编译器会默认为我们提供一个空构造(没有参数)

如果类中有自定义构造器,编译器都不会在为你提供任何构造器包括空构造

一个类中的多个构造器可以构成重载,调用的时候匹配实参

构造器没有返回值类型,也不需要void,可以根据需求添加return,但是不能返回数据

构造器不能被final,abstract,static修饰

构造器如果修饰符为private,只能在当前类中创建对象

构造器是特殊的方法,定义和使用比较特殊,但是依旧拥有方法的特性重载,作用就是为对象初始化信息

public class ConstructorDemo01 {
	public static void main(String[] args) {
		//创建对象
		//Dog d=new Dog();
		
		Dog dog2=new Dog("哈哈");
		dog2.wang();
		
		//创建对象的同时并赋值
		Dog dog=new Dog("王二狗","萨摩耶","白色");
		
		//对象的成员属性赋值
		dog.name="王大锤";
		
		//调用对象的功能
		dog.wang();
	}
}
class Dog{
	public String name;
	public String type;
	public String color;
	
	//空构造
	private Dog(){
		System.out.println("我是空构造啊hahaha");
	}
	public Dog(String dogName){
		System.out.println("我是带参数构造啊hahaha");
		if(dogName=="哈哈"){
			return;  //提前结束方法
		}
		name=dogName;
	}
	public Dog(String dogName,String dogType,String dogColor){
		System.out.println("我是带3个参数构造啊hahaha");
		name=dogName;
		color=dogColor;
		type=dogType;
	}
	public void wang(){
		Dog d=new Dog();
		System.out.println("一只名字为"+name+"的"+color+"的"+type+"在wangwangwang叫");
	}
}

四、块

块 {} -->作用域

{}-->方法中 ==>局部代码块|普通语句块 执行时机:调用方法

{}-->类中方法外 ==>构造块 执行时机:创建对象

static{}-->类中方法外==>静态块 执行时机:类加载

1.先于构造器的代码执行,编译时默认自动把构造块中的代码编译到要执行的构造器代码的最上方 ,如果存在多个构造块,从上到下以执依次

2.在类第一次加载完成之后执行,只执行一次,先于main方法执行,如果存在多个静态块,从上到下依次执行

static -->main

构造块-->构造器

public class BlockDemo01 {
	static int b=21;
	int age=13;
	static{
		System.out.println(b);
		System.out.println("我是静态块1");
		int c=333;  //局部变量
		BlockDemo01 bd=new BlockDemo01();
		System.out.println(bd.age);
	}
	public static void main(String[] args) {
		System.out.println("main");
		BlockDemo01 bd=new BlockDemo01();
	}
	public BlockDemo01() {
		System.out.println("空构造");
	}
	//构造块
	{
		System.out.println("我是构造块1");
	}
	{
		System.out.println("我是构造块2");
	}
	{
		System.out.println("我是构造块3");
	}
	//静态块
	static{
		System.out.println("我是静态块2");
	}
	static{
		System.out.println("我是静态块3");
	}
}