构造者模式思想
进行初始化，解决了多个构造器重载，构造器参数过多记不住的情况。
1 package day7;//声明一个程序包 2 class Employee{ 3 private String name; 4 private int no; 5 private int age; 6 private String sex; 7 private String address; 8 //alt + shift + s 9 10 public int getNo() {11 return no;12 }13 /* public Employee() {14 }*/15 16 public Employee setNo(int no) {17 this.no = no;18 return this;19 }20 public String getName() {21 return name;22 }23 public Employee setName(String name) {24 this.name = name;25 return this;26 }27 public int getAge() {28 return age;29 }30 public Employee setAge(int age) {31 this.age = age;32 return this;33 }34 public String getSex() {35 return sex;36 }37 public Employee setSex(String sex) {38 this.sex = sex;39 return this;40 }41 public String getAddress() {42 return address;43 }44 public Employee setAddress(String address) {45 this.address = address;46 return this;47 }48 /* public Employee(String name, int no, int age, String sex, String address) {49 this.name = name;50 this.no = no;51 this.age = age;52 this.sex = sex;53 this.address = address;54 }*/55 public void show() {56 System.out.println(no+","+name+","+age+","+sex+","+address);57 }58 }59 public class TestEmployee {60 61 public static void main(String[] args) {62 /* Employee tom = new Employee("Tom",12,33,"男","上海");63 tom.show();*/64 /*构造者模式思想 ：进行 初始化。解决了 多个构造器重载 ，构造器 参数过多 记不住的情况*/65 Employee tom = new Employee().setNo(11).setAddress("北京").setAge(33).setSex("男").setName("Tom");66 tom.show();67 }68 69 } 包
package day7;//声明一个程序包，必须放在文件的第一行
层次结构
package 父包[.子包.······];
包名：小写字母;通常是域名反转.部门名.项目名包的好处
1.管理类和接口
2.防止命名冲突3.封装，通过权限的控制，更好的不同程序包下的类的方法访问方式
1.导入程序包
import b.Exam2;//导入b包下的类型Exam2import b.*;//不能导入子包import b.c.Exam3;//导入子包下的类型
2.用完全限定命名的方式
b.Exam2 e2 = new b.Exam2();
注意：两个包下有相同的类型，必须用完全限定命名的方式进行。
访问修饰符
Java将类成员的可见度分为四个种类：
创建类的时候只有两种：public和默认
static
static是一个修饰符
应用：可以用于修饰属性，方法，块，类静态变量class 类名{//静态成员变量，类变量public static 数据类型 变量名;} 1 package day7; 2 class Child{ 3 static int count; 4 } 5 public class TestChild { 6 public static void main(String[] args) { 7 Child a = new Child(); 8 Child b = new Child(); 9 //count被所有对象共享10 a.count ++;11 b.count ++;12 System.out.println(a.count);13 System.out.println(b.count);14 }15 } 
静态变量随着类的创建的而存在，优先于对象存在。
静态变量（类变量）
属于类的，被所有对象所共享，优先于对象而存在的。
使用类名.静态变量名
对象名.静态变量名//少用，容易混淆
静态变量和实例变量的区别
1.静态：类加载的时候就加载了，就创建了，就分配空间默认初始化了
实例：对象创建的时候，才能创建；
2.静态：属于类的，存在于方法区中的。实例：属于对象。存在于堆中。3.静态：声明周期很长，类销毁的时候，才回释放。实例：对象销毁，会释放。静态变量的应用场合
当数据共享时，使用。
当不需要对象，或无法创建对象时使用。
静态块
在类中定义
static{ 作用：初始化类的，给类变量初始化，静态变量} 局部代码块
定义：在方法中定义
public void show(){ { 局部代码块 作用：用来控制局部变量生命周期和使用范围。 }} 静态方法
静态方法中只能访问静态成员。
静态方法中不能使用this，super关键字。super可能访问到非静态的成员。静态方法和实例方法的区别
1.静态：属于类，用类名直接调用
实例: 属于对象调用。2.静态：只能直接访问静态成员（静态变量，静态方法）实例：可以直接访问静态的和非静态的3.静态：不能使用this，super。实例：可以使用this，super。应用场合
当不用创建对象访问，形式简单或者不能创建对象，那么就要用静态的方法了
静态导入
导入的是类中的静态成员，导入之后可以直接使用。
格式
import static 包名.类名.静态变量名（方法）;
单例模式
对类只能创建一个对象
饿汉模式
类加载时，静态变量就存储了一个对象
1 package day7; 2 class Window{ 3 private static Window win = new Window(); 4 private Window() { 5 } 6 public static Window getInstance() { 7 return win; 8 } 9 }10 public class TestWindow {11 public static void main(String[] args) {12 Window win = Window.getInstance();13 Window win1 = Window.getInstance();14 System.out.println(win);15 System.out.println(win1);16 }17 } 输出结果
day7.Window@7852e922day7.Window@7852e922
懒汉模式
类加载时，没有指定对象，只有在应用的时候才去创建对象，多线程的环境时，推荐使用饿汉式，因为是线
程安全的。 1 package day7; 2 class Window{ 3 private static Window win = null; 4 private Window() { 5 } 6 public static Window getInstance() { 7 if(win == null) { 8 win = new Window(); 9 }10 return win;11 }12 }13 public class TestWindow {14 public static void main(String[] args) {15 Window win = Window.getInstance();16 Window win1 = Window.getInstance();17 System.out.println(win);18 System.out.println(win1);19 }20 } 返回结果
day7.Window@7852e922day7.Window@7852e922
API之Math类
常用方法
1 package day7; 2 public class TestMath { 3 public static void main(String[] args) { 4 // Math 5 System.out.println(Math.abs(‐33.4));//33.4 6 //大于等于44.6的最小整数‐》double 7 System.out.println(Math.ceil(44.6));//45.0 8 //小于等于44.6的最大整数‐》double 9 System.out.println(Math.floor(44.6));//44.010 //四舍五入为一个long数字11 System.out.println(Math.round(44.6));//4512 //求几次方的值13 System.out.println(Math.pow(3,2));//9.014 //double [0.0,1.0)15 double n = Math.random();16 System.out.println(n);17 //1‐1018 //[最小值，最大值]19 //(int)(Math.random()*(最大值‐最小值+1)+最小值)20 int num = (int)(Math.random()*(10‐1+1)+1);21 System.out.println(num);22 }23 } Random类
Random rand1 = new Random(11);//11为随机种子System.out.println(rand1.nextDouble());Random rand2 = new Random(11);//System.out.println(rand2.nextDouble());
随机种子相同时，相同随机次数输出结果相同。
Random rand3 = new Random(11);//int范围内的整数System.out.println(rand3.nextInt());//[0,5)System.out.println(rand3.nextInt(5));