**Javase 重要知识点总结 day08

**

关键词： 包 访问修饰符 静态 Math

**
#一、包解决的问题

程序包: 管理 类 和 接口 的工具 ，一组 类 和 接口的集合。
1、创建
package 包名；// 声明包;
package 父包名.子包名.[……]；
声明 必须 位置 文件的第一行代码处；
只能有一句声明代码；
规范：所有字母都小写
包名要唯一： 域名反转.部门名.项目名

2、使用
不同包:
1) 导入程序包
import 包名.类名； 例如 import a.A 导入程序包a下的A类文件
import 包名.; 例如：import a. 导入程序包a下的所有类文件
例如：你在程序包b（父包）下，新建了一个程序包c（子包），import b.* 只能导入父包下所有的类文件，不能导入子包c中的文件
import b.c.* 导入b.c包下所有的类文件。
注意：
父包 . * ; 只能 导入 父包 下的类型，父包下的 子包的类型不能导入；
2) 完全限定名称
包名.类型名
注意：两个包下的类同名 ，用 完全限定名称
例如下图案例中的：
a.A a =new a.A(); //调用程序包a 中的A类，新建对象，为了避免与本包中的类重名，必须使用完全限定的方法**。a.A
程序包的优点:**
1. 分类管理文件
2.解决了命名冲突的问题；
3.提供了更好的封装。

常见的系统包：
java.util: 工具类 / 集合框架的接口和类 Arrays Scanner Collection LIst
java.math: 数学 BigDecimal
java.lang: 核心类库。 System String Integer
java.text : 格式化 Format 0.46
java.sql : 数据库 相关的类
java.net : 网络数据传输 Socket
java.io: 流 InputStream Reader

#二、访问修饰符
注意：
1）private 的可见度最低，我们之前访问是通过，访问器setter getter方法，只能在本类中访问，那你在其他包和子类中，就不能访问。
2）默认，就是 ： 数据类型 变量名；本程序包的它都可以访问
3）public 任何地方都可见的

可见度：private< 默认的 < protected < public

#三、static修饰符
修饰： 类 （内部类）， 属性，方法，代码块
1.修饰变量

静态变量：
在方法区中，有一个区域 是静态区static区，在静态区区中开辟一个空间，用于初始化静态变量。static属于类的变量，所以加载类的时候，会进行初始化static变量。
public class Student {
// 静态成员变量，类变量（属于类）
//类加载的时候，进行初始化
//静态变量属于类，不属于对象
//被所有对象共享，所有对象都能用它，是一个公共区，公共空间。
//优先于对象而存在，因为他和类在一起存在的
static int homeWord ;// 公共的空间
// 实例成员变量（属于对象）
int num = 33;//实例成员变量

public static void main(String[] args) {
    // 交作业
    Student guojing = new Student();
    guojing.homeWord ++;// 1
    Student yangkang = new Student();
    yangkang.homeWord ++;// 2
    //就是说，对象guojing huangrong 操作的是同一个静态变量，它是共用的，你加1，我加1，最后它的值就是2了。
    
    System.out.println(guojing.homeWord);// 2
    System.out.println(yangkang.homeWord);// 2
    //类名.静态变量名   ------可以不创建对象,直接使用
    Student.count++;
    Student.count++;
    
}

}
points：
1）// 静态成员变量，类变量（属于类）
//类加载的时候，进行初始化
//静态变量属于类，不属于对象
//被所有对象共享，所有对象都能用它，是一个公共区，公共空间。
//优先于对象而存在，因为他和类在一起存在的
2） //就是说，对象guojing huangrong 操作的是同一个static 静态变量，它是共用的，例如：初始值为0，guojing你自增1，huangrong你自增1，最后它的值就是2了。
静态变量（类变量）
属于对象

静态变量（类变量）	实例变量（非static修饰）
属于类	属于对象
在加载类的时候 就加载了	对象创建了 才创建
–	–
在类卸载的时候才能释放掉（应用程序结束）	对象被回收了那么就释放了

使用方法:
1. 类名.静态变量名：（常用）在同一个类中使用可以省略掉类名
2. 对象名.静态变量名；
在不同类中,static (方法or变量) ,前面有static修饰，就用类.静态变量or方法 去调用
前面没有static修饰，就用 对象.静态变量o方法 去调用。
场合：
数据共享用静态变量。
2.修饰方法
静态方法，类方法，属于类，不属于对象。
语法使用：
类名.静态方法名（常用)
对象名.静态方法名
静态方法 实例方法
只能直接访问静态成员 静态和非静态的都能直接访问
不能使用this,super this,super都能使用
静态方法 使用 场景：

1. 有的类不能创建对象，why？ never heared that calss .想实现功能，就只能调用静态方法。
2. 使用简单，（不用总是创建对象）
   package day 08
   public class TestStaticMethod1{
   int n=11;
   static int sn=22;
   //实例成员方法
   public void f(){
   System.out.println(“f”);
   System.out.println(n);
   System.out.println(sn);
   }
   //静态方法（类方法）
   public static void sf(){
   System.out.println(“sf”);
   //静态方法中只能访问静态成员（变量or 方法）
   System.out.printl(sn);
   //非静态的创建对象
   System.out.println(new TestStaticMethod1().n);//我还创建了一个匿名对象

}
public static void method main (String[] args){
TsetStaticMehod1.sf();
new TestStaticMethod1().sf();//error:创建对象后出现错误，因为sf()方法是静态的，属于类的，创建对象没用
new TestStaticMethod1().f();//这个是 创建的匿名对象，然后调用实例方法

}
}

#3.修饰代码块

代码块:
##1.构造块

class 类{
{
// 构造块：初始化对象的（对象的实例变量赋值）
}

}
##2. 静态块
class 类{
static {
// 静态块：初始化类的（给类的静态变量用静态块赋值）
}

}
代码块的执行顺序：

##3. 局部块
class 类{
public void 方法名(){
int n = 11; // 局部变量
{
// 局部代码块：控制局部变量的使用范围和声明周期
}
}
}
代码块的变量 使用范围： 只能在代码块中，代码块外调用，会出现异常
**生命周期：**代码块执行完之后，就会消失
##4.静态变量初始化

静态变量初始化过程：

// 主类，启动类
public class TestStaticDemo1 {
/{
System.out.println(“构造块 new”);
}/
static int sn = 11;
// 执行：在类 初始化的时候自动执行
static {
sn = 22;
}
public static void main(String[] args) {
// TestStaticDemo1 test = new TestStaticDemo1();
// 主动使用某个类的时候，才能引起此类的加载
//
System.out.println(sn);// 22
}
}
注：
1） //带主方法main 的 类，是主动类，启动类（他是程序的入口，启动点，然后才会进行加载类文件，然后static 变量初始化，以及其他类的操作）
2） // 主动使用某个类的时候，才能引起此类的加载
5.静态导入
格式：
import static 包名.类名.静态变量名（方法）；
有一种方式，可以导入这个类下 所有的静态变量， 不用你一个一个导入相应的静态变量 了。太麻烦。。。。
方式： import static test2.Demo2.* (这样就可以导入包下，指定类中，所有的静态变量了 哈哈哈哈) 这个我比较喜欢，简单方便。

##6、单例模式
设计模式
单例模式：只能创建一个对象。
（例如，手机里的网易云播放音乐，只能同时播放一首歌，点开那个歌，会显示那个歌曲对应的歌词以及播放相应的歌曲（它不能一次性同时播放两首吧，那不就乱了，哈哈哈））
饿汉式 特点：（就是说呢，我只有在使用的时候，你给我创建一个对象(当然，只创建一个对象，无论需求是多少)，我不使用的时候，你不创建。）
1.类加载的时候数据 就 准备好了（对象就new 创建了new Window);
2.线程安全的。
/*饿汉式/
/class Window{
// 创建
private static Window win = new Window();
private Window(){}
// 提供对外的公共的访问方式
public static Window getWindow() {
return win;
}
}/
懒汉式:
（类加载的时候没有创建对象new Window）
特点：1）只有在使用的时候Window.getWindow()才会创建对象；
2） 线程非安全的。

// 懒汉式
class Window{
// 创建，静态变量只初始化一次
private static Window win = null;
private Window(){}
// 提供对外的公共的访问方式
public static Window getWindow() {
if(win == null) {
win = new Window();
}
return win;
}
}
public class TestWindow {
public static void main(String[] args) {
// ClassLoader.getSystemClassLoader().loadClass(“day1130.Window”);// 可以扩展 看一下 类加载的源码

    Window win1 = Window.getWindow();
    Window win2 = Window.getWindow();
    System.out.println(win1);
    System.out.println(win2);
}

}

#四、Math类

  Math类
    1）  Math.ceil(  )     ;  (ceil : 是天花板的意思，那就是最大值了)//double 大于等于 55.67的最小整数 的 double 值       
    System.out.println(Math.ceil(55.67));// 56.0
    2）Math.floor( );   (floor ；地板) //double  小于等于 55.67的最大整数 的 double 值
    System.out.println(Math.floor(55.67));// 55.0
    3）Math.round( ) ; long : 四舍五入为一个 整数
    System.out.println(Math.round(56.78));// 57
    4）Math.pow(   );  //double :   (底数，指数)
    System.out.println(Math.pow(2, 3));// 8.0
  5)    ------------- 产生随机整数：------------------------------------------------------

// [1,10]， 本来random是【0,1），乘以10 ，变成了【0,10），再加1------>【1,11）,因为是int值，取整数--------->所以变成了【1,10】
num = (int)(Math.random()*(10-1+1) + 1);
public class TestMath {
public static void main(String[] args) {

    // 产生随机数: 伪随机数
    // double: 范围 [0.0,1.0)
    System.out.println(Math.random());
    double n = Math.random();
    //------------------- 随机整数：------------------------------------------------------
    int num = (int)(Math.random() * 10 + 1);// 0 - 9
    System.out.println(num);//
    //  [最小值  ，最大值]
    // (int)(Math.random()* (最大值 - 最小值 + 1) + 最小值)
    // [1,10]
    num = (int)(Math.random()*(10-1+1) + 1);
    // [3,55]
    num = (int)(Math.random()*(55-3+1) + 3);
    //-----------------------Random类的方法------------------------------------------------------------
    
    Random r = new Random();
    System.out.println(r.nextDouble());
    // long : 随机种子
    Random r1 = new Random(5);
    Random r2 = new Random(6);
    System.out.println("-----------------");
    //  [0.0 , 1.0)  和 Math.random() 是一回事 
    System.out.println(r1.nextDouble());
    System.out.println(r2.nextDouble());
    // 当前的系统时间

// System.out.println(System.nanoTime());// long
// System.out.println(System.currentTimeMillis());// long 毫秒
// 随机整数 int
System.out.println(r.nextInt());
// [0,上限）
// System.out.println(r.nextInt(上限));
System.out.println(r.nextInt(9));
}
}

public class TestRandom1 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int r;
int n;
// 1-10
r = (int)(Math.random()*(10-1+1)+1);
System.out.println(“r–”+ r);
System.out.println("-- 输入一个数字：");
n = input.nextInt();
if(r == n) {
System.out.println(“中奖了”);
}else {
System.out.println(“谢谢参与”);
}
}
}