static关键字和数组创建

一、 static关键字

意义：static修饰的变量叫静态变量，修饰的方法叫静态方法

重要概念：所谓的静态在java中指随着虚拟机的加载而加载的变量及方法，称之为静态变量或方法

(直白点讲就是static修饰的变量和方法会随着虚拟机的加载而加载)

编译的过程：启动虚拟机、加载java文件、验证规则、生成class(字节码)文件

注意点：双亲委托机制，ClassLoader加载class文件
非静态的变量及方法的概念：未被static修饰的变量或方法称为非静态变量或方法，只有当创建对象的时候才会被加载进内存(如果未创建对象，那么非静态的变量或方法就不能调用[不存在于虚拟机所运行的内存中])，非静态的属性和方法只能通过对象调用

和静态之间的关系：不能静态方法中调用非静态的变量或方法，非静态方法中可以调用静态变量或方法

public class StaticDemo{
	//无法从静态上下文中引用非静态 变量 count
    int count = 2;
    public static void main(String[] args){
        StaticDemo sf = new StaticDemo();
        //int count = 1;
        System.out.println(sf.count);
    }
}

static的作用：资源共享

package cn.yunhe.sta;

/**
 * class文件也叫字节码文件，是由Java文件编译而来的，Java文件会先编译为字节码文件，再转为机械码文件，然后计算机才能识别
 * 机械码文件，是计算机可以直接识别的文件，通常C编译后的文件就是机械码文件
 * 
 * 1、什么是static
 * 	静态修饰符，修饰的方法称为静态方法，修饰的属性称为静态属性
 * 2、static的使用场景
 * 	思考：非静态的属性和方法都是随着对象的创建而加载的(反过来讲就是只有当对象存在时，非静态的属性及方法才会存在)，如果多个对象想要公用同一个属性或方法时怎么办？
 * 	例如：售票功能（多个窗口可以售卖同一趟列车的同一个时间点的票，多个窗口相当于是多个对象，共用的票就是同一个属性）
 * 3、怎么使用、什么时候用
 * 	属性或方法使用static关键字修饰即可
 * 作用：
 * 	数据共享
 * 编译后出现黄色警告线的原因：
 * 	1、变量未使用
 * 	2、泛型未定义
 * 	3、静态的方法使用了对象调用
 * 思考：非静态与静态的属性或方法应该如何调用
 * 	非静态：只能通过对象调用，因为非静态的属性或方法只有在创建对象的时候才会被加载进内存
 * 	静态：既可以通过对象调用，也可以通过类名调用，建议使用类名调用（非静态的属性或方法属于对象的，静态的属性或方法属于类的）
 * 思考：如果相互调用了会出现什么问题，为什么？
 * 	不能再静态的方法中调用非静态的属性或方法，因为非静态的属性或方法只有在创建对象的时候才会被加载进内存
 * 思考：静态的属性和方法时什么时候加载进内存的
 * 	Java文件在编译时会被加载进内存中，其中的静态的属性及方法都会随着class文件的加载而加载（简单点：类加载，那么静态的属性及方法就加载了）
 * 模拟售票功能
 */

public class StaticDemo {

	public static void main(String[] args) {
		Ticket t1 = new Ticket();
		Ticket t2 = new Ticket();
		
		for(int i=0;i<50;i++) {
			t1.sale();
			t2.sale();
		}
		
		t1.show();
		t2.show();
		Ticket.show();
	}
}

package cn.yunhe.sta;

public class Ticket {

	/**
	 * 默认的票数
	 */
	private static int ticketCount = 100;
	
	public void sale() {
		//show();
		if(ticketCount>0) {
			System.out.println("售票一张，还剩"+(--ticketCount)+"张");
		}
	}
	
	public static void show() {
		System.out.println("--static method--");
		//sale();
	}
}

静态方法和变量的调用形式：

1、通过类名直接调用–建议

2、通过对象进行调用

二、构造代码块和构造器区别

package cn.yunhe.block;

public class CodeBlock {

	public static void main(String[] args) {
		User user = new User();
		user.show();
		User.method();
	}
}

package cn.yunhe.block;

/**
 * 构造代码块的初始化比构造器的初始化时机早
 * 直接在属性上进行初始化的时机比构造代码块早
 */
public class User {

	private int age = 10;
	
	private String name;
	
	public User() {
		this.age = 10;
		System.out.println("--User-1-"+age);
	}
	
	{
		//this.age = 10;
		System.out.println("构造代码块-2--"+age);
	}
	
	static {
		System.out.println("--static--4");
	}
	
	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public void show() {
		System.out.println("--show--3");
	}
	
	public static void method() {
		System.out.println("--method--5");
	}
}

三、数组

是一个容器，当需要存储多个数据的时候，就需要有这么一个容器，以方便存储使用

数组的特点：大小固定，数组中能存储是数据必须是同一种类型的数据

数组的优缺点：查询快(下标)，增删速度慢

```java

```java

```java
package cn.yunhe.array;


public class ArrayDemo {

	public static void main(String[] args) {
		createArray5();
	}
	
	/**
	 * 二维数组
	 */
	public static void createArray5() {
		String[][] arr = new String[3][2];
		arr[0][0] = "a";
		arr[0][1] = "b";
		System.out.println(arr[0][1]+"--"+arr[1][0]);
		
		String[][] arr2 = {
				{"二七区","中原区","金水区"},
				{"朝阳区","海淀区","大兴区"},
				{"徐汇区","浦东新区","奉贤区"}
		};
		System.out.println(arr2[1][1]);
	}
	
	/**
	 * 定义一个数组，用于存储多个商品的信息
	 */
	public static void createArray4() {
		Items item1 = new Items(1,"德芙巧克力",39.9);
		Items item2 = new Items(2,"玫瑰花",5);
		Items item3 = new Items(3,"红酒",110);
		
		Items[] itemsArr = {item1,item2,item3};
		System.out.println(itemsArr[1].getItemName());
	}
	
	/**
	 * 数组的创建方式三
	 * 简写形式
	 */
	public static void createArray3() {
		String[] arr = {"abc","ccc","hehe"};
		System.out.println(arr.length);
	}
	
	/**
	 * 数组的创建方式二
	 * 指定内容
	 */
	public static void createArray2() {
		String[] arr = new String[] {"小祁","皮皮"};
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		//获取数组的大小 length属性
		System.out.println("数组大小："+arr.length);
	}
	
	/**
	 * 数组的创建方式一
	 * 指定大小
	 */
	public static void createArray1() {
		//创建了一个大小为3的数组容器
		int[] arr = new int[3];
		//赋值
		arr[0] = 7;
		arr[2] = 9;
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		//ArrayIndexOutOfBoundsException 数组下标越界异常
		//System.out.println(arr[3]);
		//System.out.println("--over--");
	}
}

需求：定义一个大小为3的int类型的数组
语法一：数据类型[] 变量名 = new 数据类型[size];//size是指一个具体的数字，表示数组的大小
int[] arr = new int[3];
String[] arr = new Strinrg[3];
语法二：数据类型[] 变量名 = new 数据类型[]{值,...};//直接给定结果，值的多少决定了容器的大小
int[] arr = new int[]{1,2,3};
String[] arr = new String[]{"a","b","c"};
语法三：数据类型[] 变量名 = {值,...};//简写形式
int[] arr = {1,2,3};
String[] arr = {"a","b","c"};
//注意点：数组的下标起始位置是从0开始的，这是不能变的
//获取数组大小的属性---length
System.out.println(arr.length);//3

package cn.yunhe.array;

/**
 * 商品信息类
 */
public class Items {

	/**
	 * 商品编号
	 */
	private int itemId;
	
	/**
	 * 商品名称
	 */
	private String itemName;
	
	/**
	 * 商品价格
	 */
	private double itemPrice;
	
	public Items() {}

	public Items(int itemId, String itemName, double itemPrice) {
		this.itemId = itemId;
		this.itemName = itemName;
		this.itemPrice = itemPrice;
	}

	public int getItemId() {
		return itemId;
	}

	public void setItemId(int itemId) {
		this.itemId = itemId;
	}

	public String getItemName() {
		return itemName;
	}

	public void setItemName(String itemName) {
		this.itemName = itemName;
	}

	public double getItemPrice() {
		return itemPrice;
	}

	public void setItemPrice(double itemPrice) {
		this.itemPrice = itemPrice;
	}
	
}