Day7 访问权限

构造者模式思想

进行初始化，解决了多个构造器重载，构造器参数过多记不住的情况。

 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 }

View Code

包

package day7;//声明一个程序包，必须放在文件的第一行

层次结构

package 父包[.子包.······];
包名：小写字母;通常是域名反转.部门名.项目名

包的好处

1.管理类和接口
2.防止命名冲突
3.封装，通过权限的控制，更好的

不同程序包下的类的方法访问方式

1.导入程序包

import b.Exam2;//导入b包下的类型Exam2
import 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 }

View Code

 

静态变量随着类的创建的而存在，优先于对象存在。

静态变量（类变量）

属于类的，被所有对象所共享，优先于对象而存在的。
使用

类名.静态变量名
对象名.静态变量名//少用，容易混淆

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

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 }                

View Code

输出结果

day7.Window@7852e922
day7.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 }    

View Code

返回结果

day7.Window@7852e922
day7.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.0
10 //四舍五入为一个long数字
11 System.out.println(Math.round(44.6));//45
12 //求几次方的值
13 System.out.println(Math.pow(3,2));//9.0
14 //double [0.0,1.0)
15 double n = Math.random();
16 System.out.println(n);
17 //1‐10
18 //[最小值，最大值]
19 //(int)(Math.random()*(最大值‐最小值+1)+最小值)
20 int num = (int)(Math.random()*(10‐1+1)+1);
21 System.out.println(num);
22 }
23 }

View Code

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));