JAVA課件總結-總彙精簡版

目錄

1. 面向對象三大特性、六大原則 1

2. java的基本數據類型以及變量定義格式、類型轉化 1

3. List、Set、Map的分類、區別以及遍歷方式 1

4. 枚舉的特性 2

5. 異常分類和處理方式 2

6. 線程的生命週期以及實現方式 2

7. 常用的字節流和字符流以及之間的區別 3

8. 三次握手四次揮手、TCP與UDP的區別 3

9. （抽象）工廠模式以及單例模式實現方式 3

10. 選擇 、插入、冒泡、遞歸的實現方式 5

11. XML 和 JSON的格式和特點以及json 的轉義方式 7

12. 國際化和Tomcat配置文件信息 7

13. SQL基本增改刪查、增加/刪除列等 8

14. JSP/JS/AJAX/Cookie/HTML/CSS 10

15. 文件/文件夾創建和遍歷 11

---

1. 面向對象三大特性、六大原則 1

面向對象程序設計：將一個對象的特徵和行爲抽象成屬性和方法封裝在類中，並利用多個對象之間的交互通信形成程序。

三大特性：

封裝：將一個對象的特徵和行爲抽象成屬性和方法封裝在類中。

繼承：子類繼承父類的屬性和方法，即子承父業。

多態：通過父類調用子類方法，即同一消息可以根據發送對象的不同而採用多種不同的行爲方式。

六大原則：

單一職責原則：一個類，最好只做一件事，只有一個引起它的變化。

開放封閉原則(OCP)：軟件的功能應該是可擴展的，而儘可能的不修改。

里氏（Liskov）替換原則(LSP)：子類必須能夠替換基類。

依賴倒置原則(DIP):依賴於抽象，即高層模塊不依賴底層模塊，二者都通依賴於抽象。/客戶類和服務類都應該依賴於抽象（接口），並且客戶類擁有接口。

接口隔離原則：使用多個小的專門的接口，而不要使用一個大的總接口。

合成複用原則（Composite Reuse Principle）：原則是儘量首先使用合成/聚合的方式，而不是使用繼承

2. java的基本數據類型以及變量定義格式、類型轉化 1

8種基本數據類型：byte、short、char、int、long、float、double、boolean

變量定義格式：(1)以字母（A-Z或者a-z）,美元符（$）、或者下劃線（_）開始;

                       （2)關鍵字不能用作標識符;

                         (3)標識符是大小寫敏感的

類型轉換：從低級到高級-----自然轉換，反向要強制類型轉換。可能精度損失，捨棄小數變整型。

3. List、Set、Map的分類、區別以及遍歷方式 1

List分爲：

ArrayList:順序表，適合更新、查詢。

LinkedList：鏈表，適合插入、刪除。

Set分爲：

HashSet：無序，不重複

LinkedHashSet：存取有序，不重複

TreeSet：自動排序，不重複

map分爲：鍵值對

HashMap：無序

LinkedHashMap：存取有序

TreeMap：自動排序

 

遍歷基本方式：（1）for循環遍歷；（2）Iterator迭代器遍歷；（3）foreach循環遍歷。

 @Test
    /**
     * @author yto_yh
     * ArrayList示例
     * 適用於查詢、修改
     * 一下遍歷方式set通用
     */
    public void test() {
        List<Integer> num= Arrays.asList(1,2,3,4,5);
        System.out.println("初始："+num);

        //Iterator迭代器遍歷
        System.out.print("第一種遍歷：");
        Iterator<Integer> it=num.iterator();
        while(it.hasNext()) {
            System.out.print(it.next()+" ");
        }

        //for循環遍歷
        System.out.print("\n第二種遍歷：");
        for(Iterator<Integer> it1=num.iterator();it1.hasNext();) {
            System.out.print(it1.next()+" ");
        }

        //forEach遍歷
        System.out.print("\n第三種遍歷：");
        for(int i:num) {
            System.out.print(i+" ");
        }

        //lambda表達式遍歷
        System.out.print("\n第四種遍歷：");
        num.forEach(i->System.out.print(i+" "));
    
        //System.out::print遍歷
        System.out.print("\n第五種遍歷：");
        num.forEach(System.out::print);
    }

4. 枚舉的特性 2

public static final 形式的常量定義的缺點：類型不安全、沒有命名空間、一致性差

創建枚舉類型要使用enum關鍵字，且都是java.lang.Enum類的子類（java.lang.Enum是一個抽象類），類型安全。

• 枚舉類的名稱一般以Enum結尾
• 可以使用==直接來比較值
• 枚舉的構造方法默認且只能是private的。
• 只能覆蓋toString方法
• 兩個方便操作enum的工具類——EnumSet 和 EnumMap。

values()：返回 enum 實例的數組，而且該數組中的元素嚴格保持在 enum 中聲明時的順序

name()：返回實例名。

ordinal()：返回實例聲明時的次序，從0開始。

getDeclaringClass()：返回實例所屬的 enum 類型。

equals()：判斷是否爲同一個對象。可以使用 == 來比較enum實例。

/**
 * @author yto_yh
 *
 */
public enum ColorEnum3 {
    AB(1,"ab"),
    BB(2,"bb"),
    CB(3,"cb"),
    DB(4,"db"),
    EB(5,"eb");
    
    private Integer ID;
    private String NAME;
    private ColorEnum3(Integer iD, String nAME) {
        ID = iD;
        NAME = nAME;
    }
    public Integer getID() {
        return ID;
    }
    public void setID(Integer iD) {
        ID = iD;
    }
    public String getNAME() {
        return NAME;
    }
    public void setNAME(String nAME) {
        NAME = nAME;
    }   
}


/**
 * @author yto_yh
 *
 */
public class TestEnum0904 {
    public static void main(String[] args) {
       for(ColorEnum3 i:ColorEnum3.values()) {
           System.out.println(i.ordinal()+" "+i.name()+" "+i.getNAME()+" "+i.getDeclaringClass()+" "+i.getNAME().equals("cb"));
       }  
    }
}

5. 異常分類和處理方式 2

異常事件的分類：

Error： Java虛擬機無法解決的嚴重問題。如：JVM系統內部錯誤、資源耗盡等。

Exception分兩種：

編譯時異常：ClassNotFoundException(沒找到類)、FileNotFoundException(文件沒找到)、SQLException(數據庫異常)

運行時異常：ArrayIndexOutOfBoundsException(數組越界異常)、

ClassCastException(類轉換異常)、NullPointerException(空指針異常)、

 ArithmeticException(算法異常)、ClassCastException(類轉換異常)

異常處理方式：(1)throws方法頭部拋出異常；(2)throw在方法內部拋出異常；(3)通過try-catch-finally語句實現

6. 線程的生命週期以及實現方式 2

線程的生命週期：創建、就緒、運行、阻塞、死亡

Lock和synchronized的不同:

1.  Lock是一個接口，而synchronized是Java中的關鍵字
2. synchronized在發生異常時，會自動釋放線程佔有的鎖；Lock在發生異常時，在finally塊中通過unLock()去釋放鎖。
3. Lock可以讓等待鎖的線程響應中斷，synchronized不行
4. 通過Lock可以知道有沒有成功獲取鎖，synchronized不行
5. Lock可以提高多個線程進行讀操作的效率

線程的實現方式：

1. 繼承Thread類創建線程
2. 實現Runnable接口創建線程
3. 使用ExecutorService、Callable、Future實現有返回結果的線程【ExecutorService、Callable、Future三個接口實際上都是屬於Executor框架。】

/**
 * @author yto_yh
 *
 */
public class MyCallable implements Callable<Object>{
    
    private String taskNum;  
    
    MyCallable(String taskNum) {  
       this.taskNum = taskNum;  
    } 
    @Override
    public Object call() throws Exception {
        // TODO Auto-generated method stub
        System.out.println(">>>" + taskNum + "任務啓動");  
        Date dateTmp1 = new Date();  
        Thread.sleep(1000);  
        Date dateTmp2 = new Date();  
        long time = dateTmp2.getTime() - dateTmp1.getTime();  
        System.out.println(">>>" + taskNum + "任務終止");  
        return taskNum + "任務返回運行結果,當前任務時間【" + time + "毫秒】";  
    }
  //實現call()方法，作爲線程執行體
/*    public Integer call(){
        int i = 5;
        for( ; i<100 ; i++){
            System.out.println(Thread.currentThread().getName() + "的循環變量i的值：" +i);
        }
        //call()方法可以有返回值
        return i;
    }
    
    public static void main(String[] args) {
      //創建Callable對象
        Callable cd = new MyCallable();
        //使用FutureTask來包裝Callable對象
        FutureTask<Integer> task = new FutureTask<Integer>(cd);
        for(int i=0 ; i<100 ; i++){
            System.out.println(Thread.currentThread().getName() + "的循環變量i的值：" +i);
            if(i==20){
                //實質還是以Callable對象來創建並啓動線程
                new Thread(task,"有返回值的線程").start();
            }
        }
        try{
            System.out.println("子線程的返回值" + task.get());
            
        }catch(Exception e){
            e.printStackTrace();
        }
*/
    }
    

/**
 * @author yto_yh
 *
 */
public class Test0903 {

    /**
     * @param args
     * @throws ExecutionException 
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // TODO Auto-generated method stub
        System.out.println("----程序開始運行----");  
        Date date1 = new Date();  
       
        int taskSize = 5;  
        // 創建一個線程池  
        ExecutorService pool = Executors.newFixedThreadPool(taskSize);  
        // 創建多個有返回值的任務  
        List<Future> list = new ArrayList<Future>();  
        for (int i = 0; i < taskSize; i++) {  
         Callable c = new MyCallable(i + " ");  
         // 執行任務並獲取Future對象  
         Future f = pool.submit(c);  
         // System.out.println(">>>" + f.get().toString());  
         list.add(f);  
        }  
        // 關閉線程池  
        pool.shutdown();  
       
        // 獲取所有併發任務的運行結果  
        for (Future f : list) {  
         // 從Future對象上獲取任務的返回值，並輸出到控制檯  
         System.out.println(">>>" + f.get().toString());  
        }  
       
        Date date2 = new Date();  
        System.out.println("----程序結束運行----，程序運行時間【"  
          + (date2.getTime() - date1.getTime()) + "毫秒】");  
    }
   }

 

7. 常用的字節流和字符流以及之間的區別 3

1. 寫出常見的字節流和字符流；

字節流：InputStream: FileInputStream/ObjectInputStream/filterInputStream

                         OutputStream: FileInputStream/ObjectInputStream/filterInputStream

字符流：Reader: FileReader/StringReader/filterReader/InputStreamReader

                          Writer: FileWriter/StringWriter/filterWriter/OutputStreamWriter

1. 字節流操作的基本單元爲字節；字符流操作的基本單元爲Unicode碼元。
2. 字節流默認不使用緩衝區；字符流使用緩衝區。
3. 字節流通常用於處理二進制數據，實際上它可以處理任意類型的數據，但它不支持直接寫入或讀取Unicode碼元；字符流通常處理文本數據，它支持寫入及讀取Unicode碼元。

8. 三次握手四次揮手、TCP與UDP的區別 3

三次握手的目的是建立可靠的通信信道，就是雙方確認自己與對方的發送與接收機能正常。

四次揮手的目的是一方發送FIN只表示自己發完了所有要發的數據，但還允許對方繼續把沒發完的數據發過來。

TCP:面向連接、提供可靠的服務、對系統資源要求較多、連接只能是點到點的。

UDP:無連接、盡最大努力交付、具有較好的實時性、UDP對系統資源要求較少、支持一對一，一對多，多對一和多對多的交互通信。

9. （抽象）工廠模式以及單例模式實現方式 3

常用的模式：工廠模式、抽象工廠模式、單例模式、代理模式、策略模式

工廠模式：建造簡單工廠類，根據傳遞參數的不同實例化對應的對象。

抽象工廠模式：建立超級工廠其中包含簡單工廠類，先選擇調用的工廠再選擇實例化的對象。

 

單例模式：

懶漢式--線程不安全

public class Singleton {     
     private static Singleton instance;      
     private Singleton (){}        
     public static Singleton getInstance() {      
            if (instance == null) {         
                instance = new Singleton();      
            }      
           return instance;      
     } 
 }

• 懶漢式--線程安全

public class Singleton {      
    private static Singleton instance;      
    private Singleton (){}      
    public static synchronized Singleton getInstance() {      
        if (instance == null) {          
            instance = new Singleton();      
        }      
    return instance;     
     }  
}

 

餓漢式--線程安全

public class Singleton {     
 private static Singleton instance = new Singleton();     
 private Singleton (){}      
 public static Singleton getInstance() {    
      return instance;      
 } 
}

雙檢鎖/雙重校驗鎖（DCL，即 double-checked locking）   ---線程安全

public class Singleton {      
    private volatile static Singleton singleton;     
    private Singleton (){}     
    public static Singleton getSingleton() {    
        if (singleton == null) {          
           synchronized (Singleton.class) {          
               if (singleton == null) {              
                   singleton = new Singleton();          
               }          
            }    
            return  singleton ;
          } 
         return  null;
    }
}

• 登記式/靜態內部類   ---線程安全

public class Singleton {      
    private static class SingletonHolder {      
        private static final Singleton INSTANCE = new Singleton();      
    }     
    private Singleton (){}      
    public static final Singleton getInstance() {     
        return SingletonHolder.INSTANCE;      
    } 
}

枚舉   ---線程安全

public enum Singleton {      
    INSTANCE;      
    public void whateverMethod() {   
  
     } 
 }

 

10. 選擇 、插入、冒泡、遞歸的實現方式 5

  public static void swap(int []arr,int a,int b){

        arr[a] = arr[a]+arr[b];

        arr[b] = arr[a]-arr[b];

        arr[a] = arr[a]-arr[b];

    }

插入：

 public static void insertionSort(int[] arr) {

        for (int i = 1; i < arr.length; i++) {

            int j = i;

            while (j > 0 && arr[j] < arr[j - 1]) {

                swap(arr,j,j-1);

                j--;

            }

        }

    }

 

選擇：

    public static void selectSort(int[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {

            int min = i;

            for (int j = i + 1; j < arr.length; j++) {

                if (arr[j] < arr[min]) {

                    min = j;

                }

            }

            if (min != i) {

                swap(arr,min,i);

            }

        }

    } 

 

冒泡：

  public static void bubbleSort(int[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {

           for (int j = 0; j < arr.length - 1 - i; j++) {

                 if (arr[j] > arr[j + 1]) {

                    swap(arr,j,j+1);

                 }

            }

        }

    }

 

遞歸之-

. 階乘

    public static long f(int n){

        if(n == 1)   // 遞歸終止條件

            return 1;    // 簡單情景

        return n*f(n-1);  // 相同重複邏輯，縮小問題的規模

}



.斐波納契數列

 public static int fibonacci(int n) {

        if (n == 1 || n == 2) {     // 遞歸終止條件

            return 1;       // 簡單情景

        }

        return fibonacci(n - 1) + fibonacci(n - 2); // 相同重複邏輯，縮小問題的規模

}



楊輝三角的取值  

 public static int getValue(int x, int y) {

        if(y <= x && y >= 0){

            if(y == 0 || x == y){   // 遞歸終止條件

                return 1;

            }else{

                return getValue(x-1, y-1) + getValue(x-1, y);

            }

        }

        return -1;

}



漢諾塔問題

 public static void moveDish(int level, char from, char inter, char to) {

        if (level == 1) { // 遞歸終止條件

            System.out.println("從" + from + " 移動盤子" + level + " 號到" + to);

        } else {

            moveDish(level - 1, from, to, inter); // 遞歸調用，縮小問題的規模         

            System.out.println("從" + from + " 移動盤子" + level + " 號到" + to);       

            moveDish(level - 1, inter, from, to); // 遞歸調用，縮小問題的規模

        }

    }

 

11. XML 和 JSON的格式和特點以及json 的轉義方式 7

XML 主要用於對有特定意義的數據保存或者傳遞,自帶描述性並具有結構化的文本。

XML特點：存儲性、傳遞性、共享性、數據有用性

DTD(Document Type Defination), XSD(XML Schema Definition)就是對屬性文件的約束。

JSON(JavaScript Object Notation(JavaScript 對象表示法):JSON 是存儲和交換文本信息的語法，類似 XML,是輕量級的文本數據交換格式.

JSON 比 XML(1)更小、(2)更快，(3)更易解析，(4)更直觀的瞭解數據。

JSON對象類型：前面永遠爲 String字符串類型 ,後面可以爲（string number object array true false null）

轉String：var  strUser =  JSON.stringify(user); 

轉對象：var  user =  JSON.parse(strUser);

12. 國際化和Tomcat配置文件信息 7

Internationalization=I18N,國際化:是使產品或軟件具有不同國際市場的普遍適應性，從而無需重新設計 就可適應多種語言和文化習俗的過程。

Globalization=G11N ,全球化：是使產品或軟件進入全球市場而進行的有關的商務活動.

Localization=L10N ,本地化：是將產品或軟件針對特定國際語言和文化進行加工，使之符合特定區域市場的過程。

 

Tomcat 是由 Apache 開發的一個 Servlet 容器，實現了對 Servlet 和 JSP 的支持，並提供了作爲Web服務器的一些特有功能。

在Tomcat中有四種部署Web應用的方式，分別是：

 1.利用Tomcat自動部署

 2.利用控制檯進行部署

 3.增加自定義的Web部署文件    (%Tomcat_Home%\conf\Catalina\localhost\AppName.xml)

 4.手動修改%Tomcat_Home%\conf\server.xml文件來部署web應用(此方法即打開%Tomcat_Home%\conf\server.xml文件並在其中增加以下元素：<Context docBase="D:\workspace\WebApp\AppName" path="/XXX" debug="0" reloadable="false" />   然後啓動Tomcat即可。 )

Tomcat一次完整的http請求：

1. 建立TCP連接；
2. web瀏覽器向Web服務器發送請求命令
3. Web瀏覽器發送請求頭信息
4. Web服務器應答
5. Web服務器發送應答頭信息
6. Web服務器向瀏覽器發送數據
7. Web服務器關閉TCP連接

 

13. SQL基本增改刪查、增加/刪除列等 8

SQL (Structured Query Language) 指結構化查詢語言.

三大範式：

1. 1NF是數據表中的每一列（每個字段）必須是不可拆分的最小單元
2. 滿足1NF後，要求表中的所有列，都必須依賴於主鍵
3. 滿足2NF後，表中的每一列只與主鍵直接相關而不是間接相關

常用的SQL約束：

1. NOT NULL約束 - 確保列不能有NULL值
2. 默認值約束 - 提供未指定時爲列的值時的默認值
3. 唯一值約束 - 確保了在一列中的所有的值是唯一的
4. 主鍵 - 唯一標識數據庫表中的每一行/記錄
5. 外鍵 - 唯一標識任何其他數據庫表中的行/記錄
6. 檢查約束 - CHECK約束可以確保列中的所有值滿足一定的條件
7. 索引 - 使用非常快速地創建和檢索數據庫中的數據。

SQL 能做什麼？

執行查詢、取回數據、插入新的記錄、更新數據庫中的數據、刪除記錄、創建新數據庫、在數據庫中創建新表、存儲過程、視圖

設置表、存儲過程和視圖的權限

DDL - 數據定義語言：CREATE、ALTER、DROP

• CREATE DATABASE - 創建新數據庫
• ALTER DATABASE - 修改數據庫
• CREATE TABLE - 創建新表
• ALTER TABLE - 變更（改變）數據庫表
• DROP TABLE - 刪除表
• CREATE INDEX - 創建索引（搜索鍵）
• DROP INDEX - 刪除索引

DML - 數據操縱語言：SELECT、INSERT、UPDATE、DELETE

• SELECT - 從數據庫表中獲取數據
• UPDATE - 更新數據庫表中的數據
• DELETE - 從數據庫表中刪除數據
• INSERT INTO - 向數據庫表中插入數據

DCL - 數據控制語言：GRANT、  REVOKE

 

創建/刪除數據庫：CREATE DATABASE DatabaseName;

                DROP DATABASE DatabaseName;



創建/刪除表：CREATE TABLE table_name(

                column1 INT auto_increment CHECK (AGE >= 18),

                column2 INT NOT NULL UNIQUE,

                columnN VARCHAR(20) DEFAULT “man”,

                PRIMARY KEY(column1 )

            );

            DROP TABLE table_name;

查詢：SELECT column1, column2, columnN FROM table_name;

      SELECT * FROM table_name [WHERE CONDITION];

WHERE條件：>, <, =,LIKE(%/_),NOT,AND,OR,IN,BETWEEN

其他條件： TOP NUM, LIMIT NUM1, NUM2,ROWNUM NUM、ORDER BY  [ASC | DESC], GROUP BY, DISTINCT、HAVING

實用函數： COUNT()、MAX()、MIN()、AVG()、SUM()、SQRT()、RAND()、CONCAT()、    Numeric()、String()

插入：INSERT INTO table_name( column1, column2,columnN)

      VALUES ( value1, value2,valueN);

更新：UPDATE table_name

      SET column1 = value1,columnN=valueN

      [ WHERE  CONDITION ];

刪除：DELETE FROM table_name

      WHERE  {CONDITION};

增加/刪除列：ALTER TABLE [表名] ADD [字段名] NVARCHAR (50) NULL

            ALTER TABLE [表名] DROP COLUMN [字段名]

 

14. JSP/JS/AJAX/Cookie/HTML/CSS 10

Cookie與Session的區別：

cookie是存儲在本地瀏覽器，而session存儲在服務器。

存儲在服務器的數據會更加的安全，不容易被竊取。但存儲在服務器也有一定的弊端，就是會佔用服務器的資源。

session 能夠存儲任意的 java 對象，cookie 只能存儲 String 類型的對象。

最基本的HTML登錄界面：

<!DOCTYPE html>  
<html lang="en">  
<head>  
    <meta charset="UTF-8">  
    <title>Login</title>  
   <!-- <link rel="stylesheet" type="text/css" href="Login.css"/>  -->
	<Style type="text/css">
		html{   
		width: 100%;   
		height: 100%;   
		overflow: hidden;   
		font-style: sans-serif;   
	}   
	body{   
		width: 100%;   
		height: 100%;   
		font-family: 'Open Sans',sans-serif;   
		margin: 0;   
		background-color: #4A374A;   
	}   
	#login{   
		position: absolute;   
		top: 50%;   
		left:50%;   
		margin: -150px 0 0 -150px;   
		width: 300px;   
		height: 300px;   
	}   
	#login h1{   
		color: #fff;   
		text-shadow:0 0 10px;   
		letter-spacing: 1px;   
		text-align: center;   
	}   
	h1{   
		font-size: 2em;   
		margin: 0.67em 0;   
	}   
	input{   
		width: 278px;   
		height: 18px;   
		margin-bottom: 10px;   
		outline: none;   
		padding: 10px;   
		font-size: 13px;   
		color: #fff;   
		text-shadow:1px 1px 1px;   
		border-top: 1px solid #312E3D;   
		border-left: 1px solid #312E3D;   
		border-right: 1px solid #312E3D;   
		border-bottom: 1px solid #56536A;   
		border-radius: 4px;   
		background-color: #2D2D3F;   
	}   
	.but{   
		width: 300px;   
		min-height: 20px;   
		display: block;   
		background-color: #4a77d4;   
		border: 1px solid #3762bc;   
		color: #fff;   
		padding: 9px 14px;   
		font-size: 15px;   
		line-height: normal;   
		border-radius: 5px;   
		margin: 0;   
	}  
	</Style>
</head>  
<body>  
    <div id="login">  
        <h1>Login</h1>  
        <form method="post">  
            <input type="text" required="required" placeholder="用戶名" name="u"></input>  
            <input type="password" required="required" placeholder="密碼" name="p"></input>  
            <button class="but" type="submit">登錄</button>  
        </form>  
    </div>  
</body>  
</html>  

AJAX:

$("#submit").click(function(){

    $.ajax({

        url:'demo.php',

        type:"POST",

        data:$('#form').serialize(),

        success: function(data) {

            $("#result").text(data);

        }

    });

});

 

15. 文件/文件夾創建和遍歷 11

 File path;

    File[] files;

    List<String> pathName=new ArrayList<String>();

    //遞歸遍歷文件夾

      public void iteratorPath(String dir) {

          path=new File(dir);

          files=path.listFiles();

          if(files!=null) {

              for(File file:files) {

                  if (file.isFile()) {

                      pathName.add(file.getPath()+""+file.getName());

                }else if(file.isDirectory()) {

                    iteratorPath(file.getAbsolutePath());

                }

              }

          }

       }


      //創建文件夾

      public String CreateIteratorPath(String dir) {

          path=new File(dir);

          if (!path.exists()) {

              path.mkdirs();

          }

          return path.getAbsolutePath();

       }