day8_java访问权限，static静态，单例模式，API之Math类

访问修饰符

由低到高

访问修饰符          类        同一包中     子类       不同包

private            可以

默认               可以         可以

protected          可以         可以       可以 

public             可以         可以       可以        可以

类： public，默认

类中的成员 ：public，protectd，默认，private

static

静态

修饰：

属性，方法，代码块，类

1.修饰属性（成员变量）

静态成员变量（类变量）：

 class  类名 {
     public static 数据类型 变量名；
 }

实例成员变量：属于对象的，存储在堆里

静态成员变量：属于类，被所有对象共享，优先于对象存在，类加载的时候就加载了，此时还没有任何对象

使用语法：

类名.静态变量        此种方法好
对象名.静态变量	    尽量不要此种方法
同一个类可以省略类名

使用场合：

当数据需要共享时使用

实例成员变量和静态成员变量的区别

1.静态成员变量属于类，实例成员变量属于对象；
2.加载类时加载成员变量，创建对象时创建实例变量；
3.类销毁时（应用程序结束时）销毁静态变量，静态变量的生命周期长
  对象销毁或者释放了，实例成员变量会销毁

public class Ex1 {
	//int homework = 0;//实例成员变量,程序结果为输出   1   1
	static int homework = 0;//静态成员变量,程序结果为输出   2   2

	public static void main(String[] args) {
		Ex1 e1 = new Ex1();
		Ex1 e2 = new Ex1();
		//类名.静态变量     此种方法好
		//对象名.静态变量	
		Ex1.homework++;
		Ex1.homework++;
		//同一个类可以省略类名
		homework ++;
		//e1.homework ++;
		//e2.homework ++;
		System.out.println(e1.homework);
		System.out.println(e2.homework);
		System.out.println(Ex1.homework);
		System.out.println(homework);

	}

}

2.修饰方法

静态方法

注意：

1.静态方法只能直接访问静态成员
2.静态方法内不可使用this、super关键字

使用场合

1.不能创建对象时使用
2.共享的办法，使用简单

静态方法和普通方法的区别

1.静态方法只能访问静态成员，实例方法都可以访问；
2.静态方法不能使用this、super，实例方法可以
3.静态方法不用对象，用类名就可以调用

public class Ex3 {
	//实例成员方法
	public void show1(){
		System.out.println("show1");
		Ex3.show2();
	}
	//静态方法，属于类
	public static void show2(){
		System.out.println("show2");
		//静态方法内不可直接访问非静态成员
		//show1();//会报错
		//静态方法内不可使用this关键字，用类直接调用
	}

	public static void show3(){
		System.out.println("show3");
		show2();
	}

	public static void main(String[] args) {
		Ex3.show2();
		Ex3 e1 = new Ex3();
		//静态方法内不可直接访问非静态成员,通过对象访问
		e1.show1();
	}
}

静态块

初始化类

class 类{
    static {
        初始化类
    }
}

执行：

在类加载的时候，自动执行；静态块优先于构造块

作用：对类进行初始化

静态变量初始化过程

1.默认初始化
2.声明出初始化
3.静态块初始化

构造块

局部代码块

public void 方法中（）{
{
    作用：限制局部变量的使用范围和生命周期
}
}

静态导入

import static 包名.类型名.类型成员
import static 包名.类型名.*

package a;
public class A {
	public static void sf1(){
	}
	public static int sn = 33;
}

package b;
import static a.A.*;

public class B {
	public void show(){
		sf1();
		System.out.println(sn);;
	}
}

单例模式

只能创建一个对象

饿汉式和懒汉式

1.饿汉式静态变量在类加载时已经创建对象赋值了
懒汉式 只有在调用方法时才创建对象赋值

2.多线程使用时，饿汉式更安全
懒汉式数据不安全。（线程非安全，数据不准确）

package day15;

/** 单例模式 */
//饿汉式  提前准备好
//在多线程情况下，相对来说数据安全
/*class window{
	static window win = new window();
	private window(){
	}
	
	public static window getInstance(){
		return win;
	}
}*/

//懒汉式,只有在使用方法时才创建对象
//
class window{
	static window win = null;
	private window(){
	}
	
	public static window getInstance(){
		if(win == null){
			win = new window();
		}
		return win;
	}
}

public class Ex5 {
	public static void main(String [] args){
		window win1 = window.getInstance();
		window win2 = window.win;
		System.out.println(win1);
		System.out.println(win2);
	}

}

API之Math类

double cell （double d）返回大于等于指定参数的最小整数（反回double类型的）

double floor （double d）返回小于等于指定参数的最大整数（返回double类型的）

long round（double d）返回四舍五入的一个整数（返回long类型的）

double pow(double a,double b)a是底数，b是指数

产生随机数有两种方法：

方法一：random double random(double a,double b)

方法二：math

package day15;

import java.util.Random;
import java.util.Scanner;

public class Ex6 {

	public static void main(String[] args) {
		//返回大于等于15.78的最小整数（double类型的）
		System.out.println(Math.ceil(15.78)); //16.0
		
		//返回小于等于15.78的最大整数（double类型的）
		System.out.println(Math.floor(15.78)); //15.0
		
		//四舍五入
		System.out.println(Math.round(15.78)); //16L
		//指数
		System.out.println(Math.pow(2,3)); //8.0
				
		//-----------------------Math随机数----------------------
		System.out.println(Math.random()); //[0,1)之间
	
		int n1 = (int)(Math.random() * 10+1); //1-10之间
		System.out.println(n1);
				
		//任意范围
		//int 随机整数 = （int）（Math.random()*(最大值-最小值+1)+最小值）
		int n2 = (int)(Math.random()*(25-10+1)+10); //10-25
		System.out.println(n2);
		//-------------random随机数---------------------------------
		
		//[0,1)之间
		Random r = new Random();
		System.out.println(r.nextDouble());
		//随机种子一样，相同次数产生的随机数一样
		Random r1 = new Random(11);
		Random r2 = new Random(11);
		System.out.println(r1.nextDouble());
		System.out.println(r2.nextDouble());
		
		//方法
		System.out.println(r.nextBoolean());//产生false或者true
		System.out.println(r.nextInt());//产生int范围内的随机数
		System.out.println(r.nextInt(5));//产生[0-5）范围内的随机数
		
		//---------------随机抽奖-----------------------------
		//int num = (int)(Math.random()*(10-1+1)+1);  [0-10]
		Random rm = new Random();
		int num = rm.nextInt(10)+1; //[0-10];
		Scanner input = new Scanner(System.in);
		System.out.println("请输入0-10的整数");
		int number = input.nextInt();
		if(num == number){
			System.out.println("中奖了");
		}else{
			System.out.println("没中奖");
		}

	}

}