static

面向对象 static 变量 和代码块
静态的概诉和特点
static:是一个关键字
static的特点：
被所有的对象所共享
可以使用类名调用
静态的加载优先于对象
随着类的加载而加载
package con_01;

	public class StaticDemo{
		//类名调用
		person.graduateFrom = "传媒学院"；
		
		public static void main(String[] args){
			person p = new person();
			p.name = "alex";
			p.age = 18;
			//p.graduateFromm = "传媒学院";
			p.speack();
		}
	class person{
		String name;
		int age;
		String  static gradauateFrom;
		
		public void speack(){
			System.out.println(name+"----"+graduateFrom);
		}
	}
	}

静态的主义事项
静态的方法:
可以调用静态成员变量
可以调用静态成员方法
不可以调用非静态的成员变量
不可以调用非静态的成员方法
静态方法只能调用静态的成员
非静态的方法：
可以调用静态成员变量
可以调用静态成员方法
可以调用非静态的成员变量
可以调用非静态的成员方法

静态方法中是否有this这个对象？
不可行的；
package con_02;

	public class Student{
		public static void main(String[] args){
			Student.graduateFrom = "传媒学院";
			Student.sutdy();
		}
	}
	class Student{
		String name 
		int age;
		static String graduateFrom;
		public static void study(){
			System.out.println(graduateFrom);
			sleep();
			//eat();不可以调用非静态的成员方法
			//System.out.println("name");错误静态方法不能调用非静态成员变量
		}
		public static void sleep(){
			System.out.println("sleep");
		}
		public void eat(){
			System.out.println("eat");
			System.out.println(graduateFrom);
			sleep();
		}
	}

静态的优缺点以及应用场景
优点：
对对象的共享数据提供当独的空间存储，节省空间
没有必要为每个对象都储存一份
可以直接被类名调用，不用咋堆内存创对象
弊端：
访问出现局限性.(静态虽好，但是只能访问静态)
应用场景：
有一份数据所有对象都要用到并且所有对象用的都是一样的
注意：静态的方法，一个方法要访问不同对象的不同成员的方法时不能使用
Math常用方法：
Math.PI():pi值
Math.abs():绝对值
Math.ceil():向上取整 Math.ceil(1.1) 2
Math.floor():向下取整 Math.floor(1.9) 1
Math.round():四舍五入
Math.pow():求几次幂 pow(3,2) 9
Math.max():求最大值
Math.random():返回一个随机数，大于0小于1的随机数

	public class Student{
		public static void main(String[] args){
			//Math包含了一些基本的数学运输
			//static double PI
			System.out.println(Math.PI);
		}
自定义工具类
	package con_03;
	
	public class MyArrays{
		private  MyArrays(){}
		//返回数组中的最大值
		public static int getMax(int[] arr){
			int max = 0;
			for(int x = 0;x <arr.length:x++){
				if(arr[x] > max){
					max = arr[x];
				}
			return max;
			}
		}
		//返回数组的索引
	public static int getIndex(int[] arr,int a){
		for(int x = 0;x <arr.length:x++){
			if(arr[x] == a){
				return x;
			}
			return -1;//如果查不到数则返回-1；
	}
	}
	
	package con_04;
	
	public class MyArrayDemo{
	public static void main(String[] args){
		int  arr = {3,5,6,9,8};
		int max =  MyArray.getMax(arr);
		System.out.println(max);
		int index =  MyArray.getIndex(arr);
		System.out.println(index);
	}

代码块的概诉
局部代码块：存在于方法中，控制变量的生命周期｛作用域｝
构造代码块:抽取构造方法的共性
静态代码块：随着类的加载而加载，只加载一次，加载类时需要做的一些初始化，比如加载驱动
同步代码块
例如：
package con_04;

		public class MyArrayDemo{
		public static void main(String[] args){
		//局部代码块
		{
			for(int x = 1 ;x <= 10;x++){
				System.out,println("I loave java");
			}
			int num = 100;
		}
		//System.out,println(num");不可用
		 Teacher r = new  Teacher();
		 Teacher r1 = new  Teacher("alex",18);
		 
		}
		class Teacher{
			String name;
			int age l
			public Teacher(){
				
				}
			}
			public Teacher(String name,int age ){
				this.name = name;
				this.age = age;
				
			}
			//构造代码块：提取构造方法中的共性，每次创建对象都会执行，并且在构造方法执行前执行
			//{
			//	for(int x = 1 ;x <= 10;x++){
			//		System.out,println("I loave java");
			//	}
			//}
			//静态代码块：随着类的加载而加载，只加载一次，加载类时需要做的一些初始化，比如加载驱动
			static {
				System.out,println("I loave java");
			}
			}

代码块的面试问题
顺序：1.静态代码块执行————构造代码块执行————无参构造代码块执行
如：1
package con_05;

		public class Code{
		public static void main(String[] args){
			Code c = new Code();
		}
		class Code{
			static{
				System.out.println("静态代码块执行");
			}
			{
				System.out.println("构造代码块执行");
			}
			public Code(){
				System.out.println("无参构造代码块执行");
			}
		}

顺序：2.BlockText静态代码块执行——————BloockText的主函数执行——————Code静态代码块执行——————Code构造代码块执行——————Code无参构造代码块执行————Code构造代码块执行——————Code无参构造代码块执行
如：2.BlockText静态代码块执行
package con_05;

	public class BlockText{
		static{
			System.out.println("BlockText静态代码块执行");
		}
		{
			System.out.println("BlockText构造代码块执行");
		}
		public Code(){
			System.out.println("BlockText无参构造代码块执行");
		}
	}
	public class Code{
	public static void main(String[] args){
		System.out.println("BloockText的主函数执行");
		Code c = new Code();
		Code c2 = new Code();
	}
	class Code{
		static{
			System.out.println("Code静态代码块执行");
		}
		{
			System.out.println("Code构造代码块执行");
		}
		public Code(){
			System.out.println("Code无参构造代码块执行");
		}
	}