荐 java基础中的--------构造方法+静态+代码块+主方法解释

构造方法

一.概述

1.构造方法：构造函数，构造器，Constuctor

2.作用：用于给对象的成员变量进行赋值，在创建对象的同时，会自动调用构造方法，等对象创建完成时，对象的成员变量就已经有规定的值了。

3.定义格式;
修饰符 方法名称（参数列表）{
方法体；
}

4.说明：

构造方法的名称必须和类名一模一样的，连大小也要一样。
构造方法没有返回值，连void都没有，构造方法没有return语句，如果非要加上，就写return；建议省了。
构造方法不需要手动调动，由JVM(JAVA虚拟机）在创建对象的时候自动调用
对象本身不能调用构造方法
构造方法只调用一次

*
 * 构造方法
 * */
public class Demo01 {

	public static void main(String[] args) {
		Person p1 = new Person();
		//p1.Person();
		p1.eat();
		p1.eat();

	}

}
class Person{
	//属性  成员变量
	String name;
	int age;
	//构造方法
	public Person() {
		System.out.println("构造方法被调用了...");
	}
	
	
	
	//行为 成员方法
	
	public void eat() {}
}

二.构造方法的注意事项

1.构造方法可以有参数，也可以没有参数。
如果没有参数的构造方法，外界无需传入任何的参数值，只能给成变量赋固定值或者不赋值。
如果有参数的构造方法，外界在调用构造方法的时候，需要传入实际的参数，用于赋值给成员变量。

2.构造方法可以进行重载。

3.如果在类中没有定义任何的构造方法，系统会自动提供一个空参空实现的构造方法。

4.如果在类中手动定义了任意一个构造方法（空参还是有参），系统就不再提供任何的构造方法。

/*
 * 注意事项
 * */
public class Demo02 {

	public static void main(String[] args) {
		Student stu1 = new Student();
		System.out.println(stu1.name);
		System.out.println(stu1.age);
		
		Student stu2 = new Student("张三",20);
		System.out.println(stu2.name);
		System.out.println(stu2.age);

	}

}
class Student{
	String name;
	int age;
	public Student() {
		System.out.println("空参的构造方法执行了....");
		name = "rose";
		age = 20;
		
	}
	public Student(String name,int age) {
		System.out.println("有参的构造方法执行了....");
		this.name = name;
		this.age = age;
	}
	
	public Student(String name) {
		this.name = name;
	}
}
public class Demo03 {

	public static void main(String[] args) {
		Demo d = new Demo();

	}

}
class Demo{
	String str;
	int i;
	boolean result;
	public Demo(String str, int i, boolean result) {
		
		this.str = str;
		this.i = i;
		this.result = result;
	}
	public Demo() {
		
	}
	public Demo(String str, boolean result) {
		
		this.str = str;
		this.result = result;
	}
	

	
	
}

三.构造方法和set方法的比较

1.构造方法和set方法都是用于给成员变量赋值，不希望外界直接访问私有成员变量，通过构造方法和set方法，间接地访问私有成员变量。

2.区别：
构造方法在创建对象的同时，由JVM自动调用执行，用于给属性赋值，只能执行一次。
set方法是在创建对象之后，由对象手动调用执行，用于修改变量的值，可以调用多次。

3.使用场景
一般set方法使用比较灵活，调用多次，使用更加频繁
构造方法是在创建对象的时候进行初始化赋值。

public class Demo04 {

	public static void main(String[] args) {
		Person p = new Person("张三",30);
		System.out.println(p.getName());
		System.out.println(p.getAge());
		
		p.setName("jack");
		System.out.println(p.getName());
		
		p.setName("赵四");
		System.out.println(p.getName());
		
		/*Person p1 = new Person();
		p1.setName("rose");
		p1.setAge(20);
		System.out.println(p1.getName());
		System.out.println(p1.getAge());*/

	}

}
class Person{
	private String name;
	private int age;
	
	public Person() {
		
	}

	public Person(String name, int age) {		
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	/*private void method() {}
	public void run() {
		method();
	}*/
	
	
}

四.创建对象的内存理解

1.创建对象的过程，有三个初始化的步骤
构造方法初始化
默认初始化
显式初始化

2.执行顺序：默认初始化、显示初始化、构造方法初始化、set

3.步骤：
将对象的字节码加载到方法区
在栈内存创建对象的引用，将来用于存储对象的地址
在堆内存中开辟空间，给成员变量分配内存
给成员变量进行默认初始化赋值
给成员变量进行显示初始化赋值
给成员变量进行构造方法初始化赋值
将对象的址，赋值给栈内存中的引用

public class Demo05 {

	public static void main(String[] args) {
		Person p = new Person("张三",20);
		System.out.println(p.name);
		System.out.println(p.age);

	}

}
class Person{
	String name = "rose";
	int age = 20;
	public Person() {
		
	}
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
}

静态

一.静态的概述

1.没有静态
如果某个类型的所有对象，都具有一个相同的属性值，那么这个属性就没有必要在所有对象中，都存储一次，浪费内存空间，数据冗余，维护难度较大，一旦需要修改，就得修改所有的对象。

2.有静态
如果某个类型的所有对象，都具有一个相同的属性值，那么就在这个属性的定义上加上static关键字，让该变量存储在字节码的静态区中，避免了所有对象都存储相同的数据，节省了内存空间，将来维护容易（只要修改一次）

public class Demo01 {

	public static void main(String[] args) {
		Actor actor1 = new Actor("胡哥","中国");
		Actor actor2 = new Actor("彭于晏","中国");
		Actor actor3 = new Actor("杨幂","中国");
		
		System.out.println(actor1.country);
		actor3.country = "china";
		
		System.out.println(actor1.country);
		

	}

}
class Actor{
	String name;
	static String country = "中国";
	public Actor(String name,String country) {
		this.name = name;
		this.country = country;
	}
	
}

二.静态变量的特点

1.静态的解释：静止的，静态变量不会随着对象的变化而变化。

2.关键字：static

3.加载时机
随着类的加载而加载
静态变量随着类的加载而进入到方法区，就直接在静态区开辟空间存储变量的值。

4.静态变量优先于对象而存在。

5.静态变量被所有该类的对象所共享

6.代码层面
可以使用类名直接调用，不需要使用对象名，在不创建对象的前提下，仍然可以访问这个静态变量，建议使用类名调用。

public class Demo02 {

	public static void main(String[] args) {
		/*Actor a1 = new Actor();
		a1.name = "张三";
		System.out.println(a1.country);*/
		
		System.out.println(Actor.country);

	}

}

三.静态访问的注意事项

1.静态方法：在方法声明上，加上了static关键字的方法，就是静态方法。

2.静态方法不能访问非静态方法。
原因：静态方法不依赖于对象先加载到内存中，在调用一个可能还没有进入到内存的非静态方法，非常有可能找不到。

3.静态方法不能访问非静态的变量
原因：静态方法可以在没有创建对象的时候调用，非静态变量只有在创建对象之后才存在，如果静态方法可以访问非静态的变量，那么就相当于在对象创建之前，就访问了对象创建之后的数据，明显不合量。

4.静态方法中不能存在this关键字
原因：this关键字代表当前对象。静态方法可以在对象创建之前调用。如果静态方法可以访问this关键字，相当于在创建对象之前，就可使用了该对象，明显不合理。

5.总结：静态只能访问静态，不能访问非静态，非静态可以访问静态。

6.静态方法可以使用对象名调用，也可以使用类名调用。

public class Demo02 {

	public static void main(String[] args) {
		/*Actor a1 = new Actor();
		a1.name = "张三";
		System.out.println(a1.country);*/
		
		System.out.println(Actor.country);
		
		//method();
		
		Demo.method03(5);

	}
	public static void method() {
		
	}

}
class Demo{
	int i = 20;
	/*public void method01() {
		method03();
	}
	public void method02() {
		method01();
	}*/
	public static void method03(int i) {
		//System.out.println(i);
		//this.i = i;
		
	}
}

四.静态变量和非静态变量的区别（面试题）

1.所属类型不同：
静态变量：属于类，类变量
非静态变量：属于对象

2.内存存储位置不同：
静态变量：存储在字节码中，存储在方法区中
非静态变量：依赖于对象，存储在堆内存中

3.生命周期不同：
非静态变量属于对象，所以生命周期和对象相同，随着对象的创建而存在，随着对象的销毁而消失。
静态变量属于类，所以生命周期和类相同，随着类的加载而存在，随着类的消失而消失。

4.访问方式不同：
非静态变量只能使用对象名访问。
静态变量既可以使用对象名访问，也可以使用类名来访问。
类名.静态变量名;
类名.静态方法名();

主方法解释

import java.util.Arrays;
public class Demo03 {
	/*
	 * public:公共状态，权限修饰符，所有情况都可以访问
	 *      主方法是由JVM虚拟机调用的，语言之间相互调用，需要使用最大的最高的访问权限
	 * static:静态，本类对象没有创建，依然的可以调用主方法执行，因为static修饰的方法不依赖于对象
	 * void:空，没有返回值   程序的执行唯一路口
	 * main:标识符，不是关键字  设定
	 * String[] args 形式参数  字符串数组类型
	 *          在执行主方法的时候，可以传递一个字符串数组参数，将来在主方法中，可以接收这些参数
	 * 
	 * */
	public static void main(String[] args) {
		System.out.println(Arrays.toString(args));

	}
}

Arrays工具类

定义 二分查找 比较 填充
public class Demo01 {

	public static void main(String[] args) {
		int[] arr1 = {2,4,7,9,10,20,34};
		int[] arr2 = {2,4,7,9,10,20,34};
		
		/*System.out.println(compareArr(arr1,arr2));
		
		fillArr(arr1,100);
		System.out.println(Arrays.toString(arr1));*/
		
		System.out.println(myBinarySearch(arr1, 34));
		

	}
	/*
	 * 两个数组比较
	 * */
	public static boolean compareArr(int[] arr1,int[] arr2) {
		if(arr1.length!=arr2.length) {
			return false;
		}
		for(int i=0;i<arr1.length;i++) {
			if(arr1[i]!=arr2[i]) {
				return false;
			}
		}
		return true;
	}
	/*
	 * 数组填充
	 * */
	public static void fillArr(int[] arr,int key) {
		for(int i=0;i<arr.length;i++) {
			arr[i] = key;
		}
	}
	/*
	 * 二分查找
	 * */
	public static int myBinarySearch(int[] arr, int val) {
		int max = arr.length - 1;
		int min = 0;
		while(min<=max) {
			int mid = (min + max) / 2;
			if (val > arr[mid]) {
				min = mid + 1;
			} else if (val < arr[mid]) {
				max = mid - 1;
			} else {
				return mid;
			}
			
		}
		return -1;
	}

}

代码块

一.概述

1.使用大括号包起来的一段代码，放在不同的位置，有不同的名称，有不同的作用，有不同的执行时机。

2.分类：
局部代码块
构造代码块
静态代码块
同步代码块（线程）

二.局部代码块

1.格式：使用大括号括起来的一段代码

2.位置：方法中

3.作用：限定变量的生命周期
在局部代码块中声明的变量，只能在局部代码块的范围来使用，一旦出了局部代码块的范围，就量就不能继续使用了。
某个变量一旦不能使用了，就会被回收，节省内存空间。

4.注意事项：
如果在局部代码块中修改了局部代码块外的声明的变量，局部代码块结束之后，并不会消除局部代码块对这个变量的改变。

public class Demo01 {

	public static void main(String[] args) {
		int i = 20;
		//局部代码块
		{
			
			int j = 40;
			System.out.println(j);
			i = 30;
		}
		//System.out.println(j);
		System.out.println(i);

	}

}

三.构造代码块

1.格式：使用大括号括起来的一段代码

2.位置：类中方法外

3.作用：用于给成员变量赋值

4.执行说明：
在创建对象的时候执行，由JVM默认调用
在任意的构造方法之前执行
任意的构造方法执行之前，都会执行一次构造代码块
如果每个构造方法都会执行的内容，提取到构造代码块中

public class Demo02 {

	public static void main(String[] args) {
		Person p1 = new Person();
		Person p2 = new Person("rose");
		Person p3 = new Person("jack",20);
		Person p4 = new Person("张三",30,"中国");

	}

}
class Person{
	//属性
	String name;
	int age;
	String country;
	//构造代码块
	{
		System.out.println("构造代码块执行了...");
		country = "中国";
	}
	
	//构造方法
	public Person() {
		//country = "中国";
		System.out.println("空参的构造方法执行了");
		
	}

	public Person(String name) {
		//country = "中国";
		System.out.println("一个参数的构造方法执行了");
		this.name = name;
	}

	public Person(String name, int age) {
		//country = "中国";
		System.out.println("两个参数的构造方法执行了");
		this.name = name;
		this.age = age;
	}

	public Person(String name, int age, String country) {
		//country = "中国";
		System.out.println("三个参数的构造方法执行了");
		this.name = name;
		this.age = age;
		this.country = country;
	}
}

四.静态代码块

1.格式
static{
静态代码块的内容
}

2.位置：类中方法外

3.作用：
加载资源文件，只执行一次
用于给静态的成员变量初始化赋值

4.执行特点：
随着类的加载而执行
类只加载一次，所以静态代码块只执行一次
执行的时候最早，早于所有的对象相关内容。

public class Demo03 {

	//测试类的静态代码块 1
	static {
		
		System.out.println("测试类的静态代码块执行了...");
	}
	public static void main(String[] args) {
		Student stu1 = new Student();
		Student stu2 = new Student("张三");
		Student stu3 = new Student("rose",20);

	}
}
class Student{
	String name;
	int age;
	static String country;
	//Student类的静态代码块  2
	static {
		System.out.println("Student类的静态代码块块执行了...");
		country = "中国";
	}
	//Student类的构造代码块  3
	{
		
		System.out.println("Student类的构造代码块执行了...");
	}
	//4 构造方法
	public Student() {
		//局部代码块   5
		{
			
			System.out.println("student类的局部代码块执行了...");
		}
		System.out.println("空参的构造方法执行了...");
	}
	public Student(String name) {
		System.out.println("一个参数的构造方法执行了..."+name);
	}
	public Student(String name,int age) {
		System.out.println("空参的构造方法执行了..."+name+"..."+age);
	}
}

总结

1.构造方法
概述、给成员变量进行初始化赋值
定义：public 类名(参数列表){}
调用：JVM自动调用，在创建对象的时候。
注意事项：默认提供一个无参无实现的构造方法
写了任意一个构造方法时，默认的构造方法就不再提供了
构造方法可以发生重载
2.静态
static:不属于任何一个对象，存储在方法区中的静态区
访问原则：静态只能访问静态。
3.Arrays工具类
4.代码块
局部
构造
静态

本文地址：https://blog.csdn.net/liutaiwu/article/details/107369611