本文例項講述了Java訪問許可權原理與用法。分享給大家供大家參考，具體如下：

構造者模式思想

進行初始化，解決了多個構造器過載，構造器引數過多記不住的情況。

package day7;//宣告一個程式包
class Employee{
  private String name;
  private int no;
  private int age;
  private String sex;
  private String address;
  //alt + shift + s
  
  public int getNo() {
    return no;
  }
/*  public Employee() {
  }*/

  public Employee setNo(int no) {
    this.no = no;
    return this;
  }
  public String getName() {
    return name;
  }
  public Employee setName(String name) {
    this.name = name;
    return this;
  }
  public int getAge() {
    return age;
  }
  public Employee setAge(int age) {
    this.age = age;
    return this;
  }
  public String getSex() {
    return sex;
  }
  public Employee setSex(String sex) {
    this.sex = sex;
    return this;
  }
  public String getAddress() {
    return address;
  }
  public Employee setAddress(String address) {
    this.address = address;
    return this;
  }
/*  public Employee(String name,int no,int age,String sex,String address) {
    this.name = name;
    this.no = no;
    this.age = age;
    this.sex = sex;
    this.address = address;
  }*/
  public void show() {
    System.out.println(no+","+name+","+age+","+sex+","+address);
  }
}
public class TestEmployee {

  public static void main(String[] args) {
/*    Employee tom = new Employee("Tom",12,33,"男","上海");
    tom.show();*/
    /*構造者模式思想 ：進行 初始化。解決了 多個構造器過載 ，構造器 引數過多 記不住的情況*/
    Employee tom = new Employee().setNo(11).setAddress("北京").setAge(33).setSex("男").setName("Tom");
    tom.show();
  }

}

包

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 資料型別 變數名;
}

package day7;
class Child{
static int count;
}
public class TestChild {
public static void main(String[] args) {
Child a = new Child();
Child b = new Child();
//count被所有物件共享
a.count ++;
b.count ++;
System.out.println(a.count);
System.out.println(b.count);
}
}

靜態變數隨著類的建立的而存在，優先於物件存在。

靜態變數（類變數）

屬於類的，被所有物件所共享，優先於物件而存在的。
使用

類名.靜態變數名
物件名.靜態變數名//少用，容易混淆

靜態變數和例項變數的區別

1.靜態：類載入的時候就載入了，就建立了，就分配空間預設初始化了

例項：物件建立的時候，才能建立；
2.靜態：屬於類的，存在於方法區中的。
例項：屬於物件。存在於堆中。
3.靜態：宣告週期很長，類銷燬的時候，才回釋放。
例項：物件銷燬，會釋放。

靜態變數的應用場合

當資料共享時，使用。
當不需要物件，或無法建立物件時使用。

靜態塊

在類中定義

static{
　　作用：初始化類的，給類變數初始化，靜態變數
}

區域性程式碼塊

定義：在方法中定義

public void show(){
　　{
　　　　區域性程式碼塊
　　　　作用：用來控制區域性變數生命週期和使用範圍。
　　}
}

靜態方法

靜態方法中只能訪問靜態成員。
靜態方法中不能使用this，super關鍵字。super可能訪問到非靜態的成員。

靜態方法和例項方法的區別

1.靜態：屬於類，用類名直接呼叫
例項: 屬於物件呼叫。
2.靜態：只能直接訪問靜態成員（靜態變數，靜態方法）
例項：可以直接訪問靜態的和非靜態的
3.靜態：不能使用this，super。
例項：可以使用this，super。

應用場合

當不用建立物件訪問，形式簡單或者不能建立物件，那麼就要用靜態的方法了

靜態匯入

匯入的是類中的靜態成員，匯入之後可以直接使用。

格式

import static 包名.類名.靜態變數名（方法）;

單例模式

對類只能建立一個物件

餓漢模式

類載入時，靜態變數就儲存了一個物件

package day7;
class Window{
  private static Window win = new Window();
  private Window() {
  }
  public static Window getInstance() {
  return win;
  }
}
public class TestWindow {
  public static void main(String[] args) {
    Window win = Window.getInstance();
    Window win1 = Window.getInstance();
    System.out.println(win);
    System.out.println(win1);
  }
}

輸出結果

day7.Window@7852e922
day7.Window@7852e922

懶漢模式

類載入時，沒有指定物件，只有在應用的時候才去建立物件，多執行緒的環境時，推薦使用餓漢式，因為是線
程安全的。

package day7;
class Window{
  private static Window win = null;
  private Window() {
}
public static Window getInstance() {
  if(win == null) {
    win = new Window();
  }
  return win;
  }
}
public class TestWindow {
public static void main(String[] args) {
Window win = Window.getInstance();
Window win1 = Window.getInstance();
System.out.println(win);
System.out.println(win1);
}
}

返回結果

day7.Window@7852e922
day7.Window@7852e922

API之Math類

常用方法

package day7;
public class TestMath {
public static void main(String[] args) {
// Math
System.out.println(Math.abs(‐33.4));//33.4
//大於等於44.6的最小整數‐》double
System.out.println(Math.ceil(44.6));//45.0
//小於等於44.6的最大整數‐》double
System.out.println(Math.floor(44.6));//44.0
//四捨五入為一個long數字
System.out.println(Math.round(44.6));//45
//求幾次方的值
System.out.println(Math.pow(3,2));//9.0
//double [0.0,1.0)
double n = Math.random();
System.out.println(n);
//1‐10
//[最小值，最大值]
//(int)(Math.random()*(最大值‐最小值+1)+最小值)
int num = (int)(Math.random()*(10‐1+1)+1);
System.out.println(num);
}
}

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

更多關於java演算法相關內容感興趣的讀者可檢視本站專題：《Java面向物件程式設計入門與進階教程》、《Java資料結構與演算法教程》、《Java操作DOM節點技巧總結》、《Java檔案與目錄操作技巧彙總》和《Java快取操作技巧彙總》

希望本文所述對大家java程式設計有所幫助。