Java基礎（三）

Java基礎（三）

一：Java包機制

? 解決命名沖突 – >同一個專案中不同包中可以有相同名的類

? 按分類將類放在不同的包下

二：方法

1：方法的定義與使用

• 方法的組成

  修飾符 回傳值型別 方法名(引數型別 引數名1,引數型別 引數名2,．．．．．．){
      執行陳述句
      ………
      return 回傳值;
  }
  

• 修飾符

  • 訪問控制修飾符：

  

  • 非訪問控制修飾符：

     - abstract : 抽象方法修飾符，抽象方法無具體實作，
     - static ：靜態方法控制符，靜態方法是屬于整個類的類方法，可以使用類名.方法名呼叫，一般用來制作工具類，
         		注意：static方法只能呼叫static方法和使用static變數，
     - final ： 最終方法控制符，標記該方法不能被其子類重寫，
     - native ： 本地方法控制符，其它高級語言書寫的程式，
     - synchronized ：同步方法控制符，用于控制多執行緒程式中的協調和同步，
    

• 命名規范

  駝峰命名法：一至多個單詞組成，首單詞小寫，其余單詞首字母大寫

  示例： permute(), isPalindrome(), indexOf(), firstIndexOf() 
  

• 方法示例

  String info;
  
  public static void print(){
      System.out.println("---");
  }
  
  public int getIndex(){
      Demo1.print();
      return -1;
  }
  
  public int getIndex(char c){
      return info == null ? -1 : info.indexOf(c);
  }
  

2：可變引數的傳遞

? Java中方法傳值可以有不定量引數：

public int getSumOfScores(int ... score){
	for (int i : score){
        
    }
}

? 注意：一個方法只能有一個可變引數

? 接受多個不同引數時，可變引數需在引數串列最后

? 原因：因為引數個數不定，所以當其后邊還有相同型別引數時，Java無法區分傳入的引數屬于前一個可變引數還是后邊的引數

public int getSumOfScores(int ... scores, int score){
	這樣是不行的
}

-->
    
public int getSumOfScores(int score, int ... scores){

}

3：方法多載

? 方法名相同，引數不一致，回傳值型別可以不相同，修飾符可以不相同

舉例：
1:
public int addSum(int score1, int score2){
    
}
2:
public double addSum(double score1, double score2){
    
}
3:
public double addSum(double score){
    
}
4:與第二個沖突
public static double addSum(double score1, double score2){
    
}

/**
 * 考慮這樣需求，我們需要一個回傳資料成功的方法，用success()表示，
 *     1：只表示返會成功，不附帶其他資訊，
 *     2：表示回傳成功，并附帶操作資訊，不附帶資料
 *     3：表示回傳成功，并附帶操作資訊，附帶處理得到的資料
 */
    
public class Response {
    
    private Integer code;
    private String info;
    private Object data;
    
    public Response(){}

    public Response(Integer code, String info, Object data) {
        this.code = code;
        this.info = info;
        this.data = data;
    }
    
//    ------------------------------------------------------
    
    public static Response success(){
        return new Response(200,null,null);
    }
    
    public static Response success(String info){
        return new Response(200, info, null);
    }
    
    public static Response success(String info, Object data){
        return new Response(200, info, data);
    }
        
}

三：陣列

1：一維陣列及二維陣列

? 創建及初始化：

1:一維陣列
初始化：

直接創建申明：
int[] array = {}; == int[] array = new int[]{};
int[] array = {1,2,3};
int[] array = new int[5];

分開創建宣告：
int[] array = null;
array = new int[5];

一維陣列長度：array.length;

2：二維陣列
初始化：
int[][] array2 = {{1,2},{3,4}};
int[][] array2 = new int[5][5];

二維陣列行數：
array2.length
二維陣列列數：
array2[i].length

2：動態陣列

? 陣列容量固定 —> 動態容量 —> 擴容 —> 閾值（什么時候擴容）—> 初始化動態陣列 —> 增刪改查方法

import java.util.Arrays;

/**
 * @author Laymedown
 * 擴容機制 --> 添加元素 --> 洗掉元素 -->查找元素 -->修改元素
 * 維護一個陣列
 * 1:什么時候做
 * 2:怎么做
 * 3:擴多少
 * 4:動態陣列的初始化
 * 5:添加元素{
 *     1:放在陣列尾部
 *     2:根據指定的索引放元素
 *     3:每次添加元素到首部 --> 鏈表
 * }
 * 6:洗掉元素{
 *     1:根據索引洗掉元素
 *     2:洗掉一個值{
 *         1:洗掉全部
 *         2:洗掉第一個 delete(int val, int fromIndex)
 *         3:洗掉最后一個
 *     }
 * }
 * 7:查找{
 *     1:根據索引查找元素
 *     2:根據一個值查索引 get(int val, int fromIndex)
 * }
 * 8:修改元素{
 *
 * }
 */
public class DynamicArray {

//    內部維護的一維陣列
    private int[] data;

    private static final int DEFAULT_CAPACITY = 8;

    //陣列中元素的數量
    private int size;

    public DynamicArray(){
        this(DEFAULT_CAPACITY);
    }

    public DynamicArray(int initialCapacity){
        if (initialCapacity > 0) {
            data = new int[initialCapacity];
        } else if (initialCapacity == 0){
            data = new int[]{};
        }else {
            System.out.println("初始化大小錯誤");
        }
        this.size = 0;
    }

    public void add(int value){
        if (size == data.length){
            System.out.println(" 容量錯誤");
        }else if (size == data.length - 1){
            data[size++] = value;
            grow(data.length * 2);
        }else {
            data[size++] = value;
        }
    }

    public void remove(int index){
        if (index < 0 || index >= size){
            System.out.println("索引錯誤");
            throw new IndexOutOfBoundsException(index + "");
        }
        int value = data[index];
//        for (int i = index + 1; i < size; i++) {
//            data[i - 1] = data[i];
//        }
        if (size - index + 1 >= 0) {
            System.arraycopy(data, index + 1, data, index + 1 - 1, size - index + 1);
        }
        data[--size] = 0;
    }

    public int get(int index){
        if (index < 0 || index >= size){
            System.out.println("索引錯誤");
            throw new IndexOutOfBoundsException(index + "");
        }
        return data[index];
    }

    private void grow(int newSize){
        data = Arrays.copyOf(data, newSize);
    }

    public int[] getData(){
        return data;
    }

    public int size(){
        return size;
    }
}