构造方法,static关键字与代码块

构造方法,static关键字与代码块

1.构造方法

2.static关键字

3.代码块的概述与分类

---

---

1.构造方法

方法的定义:

方法就是一个代码片段，类似于C语言中的“函数”。它可以多次被调用。

代码部分如下图

public static 方法返回值 方法名称 （方法的形参）{
  //方法体代码;
  return 语句
  }

知道了什么是方法与方法的定义语法后,

我们需要知道什么是构造方法

---

构造方法的定义:

类构造对象时调用的方法，主要用来实例化对象。

构造方法分为无参构造方法、有参构造方法。

---

构造方法的作用:

对对象的数据(即属性)初始化

---

构造方法的特点:

1.方法名与类名相同。

2.没有返回值类型(甚至连void都没有)。

3.既然连返回值类型都没有了，自然就没有具体的return类型。

---

代码如下

无参构造:

public class test1{
public static void main(String[] args){
	test2 xp = new test2();//在创建对象的时候，系统已经进行了构造方法
	//注意构造方法不能进行对象调用(即不能进行xp.test2())
  
}
}


public class test2{
    
    //构造方法
	public test2(){
		System.out.println("hello world");
        return;
}
}

最后会输出hello world

至于为什么没有调用该方法就输出了hello world注释里面已经写了

有参构造:

public class test3{
public static void main(String[] args){
    //有参构造
    test4 xp = new test4(1);
    
    xp.show();
}
}


public class test4{
    private int x;
    //构造方法
    public test4(int x){
        this.x=x;
    }
    public show(){
		System.out.println(x);
    }
}

最后会输出2

装逼小技巧:

如果一段代码里面没有有参构造也没有无参构造,那么一律当无参构造处理

public class test1{
    public static void main(String[] args){
        test2 xp = new test2();//无参构造
        xp.setAge(19);
        xp.setName("小胖");
        System.out.println("姓名为:"xp.getName()+"年龄为:"xp.getAge());
        
        test2 xp1 = new test2(19,"小胖");
        System.out.println("姓名为:"xp.getName()+"年龄为:"xp.getAge());
    }
}

public class test2{
    private int x;
    private String y;
    public test2(){//无参构造
        
    }
    public test2(int x,String y){//有参构造
        this.x=x;
        this.y=y;
    }
    
    
    
    public void setAge(int x){
        this.x=x;
    }
    public void setName(String y){
        this.y=y;
    }
    public int getAge(){
        return x;
    }
    public String getName(){
        return y;
    }
}

用无参构造与有参构造出来的结果都是:
姓名为:小胖年龄为:19

但是要注意:

如果在有参构造的下一行加一句话:

xp1 = new test2(20,"渊酱");

输出出来后有参构造的结果变为:

姓名为:渊酱年龄为:20

相当于新创建了一个对象，把原来的对象扔掉

而无参构造

只需要:

xp.setAge=20;
xp.setName="渊酱";

就可以了

不需要新创建对象

无参构造与有参构造用前者比较多,因为更灵活,修改属性值直接修改,不需要像有参构造一样,创建新的对象。

---

---

2.static关键字

static关键字又被称为:静态关键字。使用static关键字:一个类的不同对象有些共享的数据，这样我们就可以使用static来修饰 一旦使用了static关键字，那么这样的内容不再属于对象，而是属于类的，所以凡是本类的对象，都共享同一份。

可以用来修饰成员变量，修饰成员方法，以及静态代码块儿。

静态变量又叫：类变量，成员变量又叫:对象变量。

---

static关键字的特点:1.随着类的加载而加载

​ 2.优先于对象存在

​ 3.被类的所有对象共享

​ 4.可以通过类名来调用

​ 5.不能修饰局部变量

---

代码如下

public class test1{
    static int age;
    static String name;
    int room;
}
public class test2{
    public static void main(String[] args){
        test1 new1 = new test1();
        new1.age=1;
        new1.name="小胖";
        new1.room=2;
        System.out.println(new1.age+new1.name+new1.room);
    }
    	test1 new2 = new test1();
    	new2.room=3;
    	System.out.println(new2.age+new2.name+new2.room);
}

输出来是:
1小胖2
1小胖3
如果没有static关键字,输出来的便为:
1小胖2
0NULL3

---

static关键字的内存图

---

代码如下

public class test1{
public static void main(String[] args){
    test2 new1 = new test2();
    new1.name="小胖";
    new1.age=20;
    new1.print();
}
}


public class test2{
    String name;
    int age;
    public static void print(){
        System.out.println(name+age);
    }
}
public class test3{
    String name;
    int age;
    public void print(){
		System.out.println(name+age);
    }
}

最后会报错,原因是因为无法从静态上下文中引用非静态的

public class test1{
public static void main(){
    test3 new1 = new test3();
    new1.name="小胖";
    new1.age=20;
    new1.print();
}
}




public class test3{
    String name;
    int age;
    public void print(){
		System.out.println(name+age);
    }
}

现在不会报错,并输出:
小胖20

---

static关键字的注意事项

1:在静态方法中是没有this关键字的

静态是随着类的加载而加载，this是随着对象的创建而存在。

静态比对象先存在。

2:静态方法只能访问静态的成员变量和静态的成员方法

静态方法：

成员变量：只能访问静态变量

​ 成员方法：只能访问静态成员方法

非静态方法:

成员变量：可以是静态的，也可以是非静态的

​ 成员方法：可以是静态的成员方法，也可以是非静态的成员方法。

---

---

3.代码块的概述与分类

---

代码块的概述
在Java中,使用{}括起来的叫做代码块。

---

代码块的分类
根据位置和声明不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块

局部代码块：在方法中出现，限定变量生命周期，及早释放，提高内存利用率
构造代码块（初始化块）:在类中方法外出现
静态代码块：一般用于加载驱动
static{}

---

代码：
局部代码块

public class test1{
public static void main(String[] args){
	{
		int x=10;
		System.out.println("局部代码块"+x);//限定变量的生命周期
	}
}
}

最后输出来是:
局部代码块10

如果我们将输出语句放在int x=10这句话的大括号后面,就会报错。

构造代码块

public class test1{
public static void main(String[] args){
	test2 new1 = new test2();
	new1.setAge(20);
	new1.setName("小胖");
	System.out.println(new1.getAge()+new1.getName());
	test2 new2 = new test2();
	new2.setAge(19);
	new2.setName("渊酱");
	System.out.println(new2.getAge()+new2.getName());
	}
}

public class test2{
	private int age;
	private String name;
	public test2(){
	}//空参构造
	public void setAge(int age){
		this.age=age;
	}
	public void setName(String name){
		this.name=name;
	}
	public int getAge(){
		return age;
	}
	public String getName(){
		return name;
	}
	{
		System.out.println("傻逼");//构造代码块,每创建一次对象,代码块就会执行一次.
	}
}

最后输出来是:
傻逼
20小胖
傻逼
19渊酱

静态代码块

public class test1{
public static void main(String[] args){
	test2 new1 = new test2();
	new1.setAge(20);
	new1.setName("小胖");
	System.out.println(new1.getAge()+new1.getName());
	test2 new2 = new test2();
	new2.setAge(19);
	new2.setName("渊酱");
	System.out.println(new2.getAge()+new2.getName());
	}
}

public class test2{
	private int age;
	private String name;
	public test2(){
	}//空参构造
	public void setAge(int age){
		this.age=age;
	}
	public void setName(String name){
		this.name=name;
	}
	public int getAge(){
		return age;
	}
	public String getName(){
		return name;
	}
	static{
	System.out.println("傻逼");
	}//静态代码块，随着类的加载而加载，并且只执行一次

}

最后输出:
傻逼
20小胖
19渊酱

---

综上所述:

局部代码块：在方法中出现,限定变量的生命周期,及早释放,提高内存的利用率。
构造代码块：又叫初始化块在类中方法外出现，随着对象的创建而加载，创建一次对象构造代码块执行一次,在构造方法前执行。
静态代码块：在类中方法外出现，随着类的加载而加载，并且只执行一次（一般用于加载驱动）
主方法类中的静态代码块：优先于主方法执行。
同步代码块:它是在多线程里面才学,所以现在先不写。