java簡單複習（雜）

終于把基礎的大緻學的差不多了不夠的不深的以後再來補。今天照着視訊複習一遍，也算是個小總結純粹記錄到時候自己回頭過來看看不是幹貨都是濕貨。

continue: 跳過本次循環語句，繼續下一次循環。

continue的作用範圍： 隻能适用于循環語句。

一旦執行了continue語句，那麼在循環體内continue之後的循環 語句跳過執行。

break: 用于結束一個循環語句或者是一個switch語句.

break作用範圍： 隻能用于循環語句或者是switch語句。

return 直接結束函數

可以看看這個比較特殊剛複習到都忘了 break還可以配合辨別

*outer:for(int j = 0 ; j<2; j++){ // j=0  j=1
inner:for(int i = 0 ; i<3 ; i++){ //i=0
    System.out.println("hello world");
    break outer; //結束目前所在的循環。 如果配合辨別的使用，可以作用于外層的for循環。
            }//意思就是說 結束目前的外部outer

冒泡算法：

public static void sort(int[] buffer) {
        for (int i = 0; i < buffer.length-1; i++) {
            for (int j = i+1; j < buffer.length; j++) {
                if(buffer[j]<buffer[i]) {
                    int temp=buffer[j];
                    buffer[j]=buffer[i];
                    buffer[i]=temp;
                }
            }
        }
    }

複習到了算法冒泡是最基礎的排序算法明天整理下其他的常用算法吧之前學的都忘了重拾一下

函數的重載: 在一個類中出現了兩個或兩個以上的同名函數稱作為函數的重載。

函數重載的作用：一個函數名可以應對各種不同類型的參數。

函數重載的要求

1. 函數名一緻。

2. 形參清單不一緻（形參的個數不一緻或者是形參對應的類型不一緻）

3. 與傳回值類型無關。

函數重寫：子父類出現了同名的函數稱作為函數的重寫。

函數重寫必須要是在繼承的關系才存在的。

函數重寫的需求： 父類的功能無法滿足子類的需求。

函數重寫的要求
    1. 子父類的函數名與形參清單必須一緻。
    2. 子類的權限修飾符必須 要大于或者等于父類的權限修飾符。
    3. 子類的傳回值類型必須要小于或者等于父類的傳回類型。
    4. 子類抛出的異常類型必須要小于或者等于父類抛出的異常類型。

記住： println 裡面都是預設調用toString（）

封裝多态繼承都是基礎

繼承的時候：父類私有的成員不能被繼承。

簡單看一個封裝的栗子：

//封裝的步驟：
    //1. 私有化要封裝的屬性。
    //2. 根據需求提供對應的get或者是set方法。
class Member{

    private String name;

    private String sex;



    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSex(String sex){
        if("男".equals(sex)||"女".equals(sex)){
            this.sex = sex;
        }
    }

    public String getSex(){

        return sex;
    }


}

instanceof 判斷指定的對象是否屬于某種類别。

instanceof 使用前提：判斷的對象與類别必須存在繼承或者實作的關系。

instanceof 使用格式：

對象 instanceof 類别。

有多态才可能使用到instanceof關鍵字，

主要的應用場景：資料類型強轉之前的判斷。

class Animal{}
class Dog extends Animal{}
public class One {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Animal animal=new Dog();
        if(animal instanceof Dog) {
            System.out.println("Yes");
        }

    }
}

輸出 Yes

多線程栗子：

/*
線程：

多線程的存在的意義： 解決了一個程序允許多個任務可以同時執行。

多線程的建立方式：

    方式一:  繼承Thread。
        1. 自定義一個類繼承Thread.
        2. 重寫Thread的run方法，把自定義線程的任務代碼放在run方法上。
        3. 建立Thread類的子類對象，并且調用start方法開啟線程。


    方式二： 實作Runnable接口。。
        1. 自定義一個類實作Runnable接口.
        2. 實作Runnable的run方法。把自定義線程的任務代碼放在run方法上。
        3. 建立Runnable實作類的對象。
        4. 建立Thread的對象，然後把Runnable實作類的對象作為參數傳遞。
        5. 調用Thread對象的start方法開啟線程。

java中的同步機制：

出現線程安全問題的根本原因：
    1. 存在兩個或者兩個以上的線程共享着資源。
    2. 操作資源的代碼塊必須有語句。


    1. 同步代碼塊

        同步代碼塊的格式：
            synchronized(鎖對象){
                需要被同步的代碼塊...
            }
    同步代碼塊要注意的細節：
        1.鎖對象可以是任意的對象。
        2. 鎖對象必須 是多線程共享的資源。否則鎖不住。
        3. 沒有線程安全問題的時候不要使用鎖，因為會導緻效率降低。
        4. 調用sleep方法并不會釋放鎖對象，但是調用wait方法的線程就會釋放鎖對象。

    2. 同步函數
            修飾符 synchronized 傳回值類型 函數名(形參清單..){

            }
    注意： 
        1. 同步函數的鎖對象是不能任意的，非靜态同步函數的鎖對象是this對象，靜态函數的鎖對象是目前位元組碼對象。
        2. 同步函數的鎖不能由你指定，是固定的。

 */
class MyThread2 implements Runnable{

    @Override
    public void run() {
        for(int i = 0 ; i < 100 ; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }

}




class MyThread extends Thread{

    @Override
    public void run() {
        //把自定義線程的任務代碼代碼寫在這裡。。
        for(int i = 0 ; i < 100 ; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
     }
}

public class Demo14  {

    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        thread1.start(); //開啟了自定義的線程。線程一旦開啟就會執行run方法中的代碼塊。


        MyThread2 thread2 = new MyThread2();
        //建立Thread的對象
        Thread t = new Thread(thread2);
        //調用Thread對象的start方法
        t.start();

    }
}

集合栗子：

/*

集合

單例集合
----------| Collection 單列集合的根接口
----------------| List 如果是實作了List接口集合類具備的特點： 有序，可重複。
-------------------| ArrayList   底層使用Object數組實作的。 特點： 查詢速度快，增删慢。
-------------------| LinkedList  底層是使用了連結清單資料資料結構實作的。 特點： 查詢慢，增删快。
-------------------| Vector(了解)   底層使用Object數組實作的， 實作與ArrayList是一樣，隻不過是線程安全的，操作效率低。

----------------| Set  如果是實作了Set接口集合類具備的特點： 無序，不可重複。
------------------| HashSet  底層使用的是哈希表實作的。  
------------------| TreeSet  底層使用二叉數實作。 

雙列集合：
--------| Map  (隻需要把Map接口的方法全部練習一次即可。)
-----------| HashMap  底層使用的是哈希表實作的。  
-----------| TreeMap   底層使用二叉數實作
-----------| HashTable（了解）

 */
class Book{

    String name;

    double price;

    public Book(String name, double price) {
        super();
        this.name = name;
        this.price = price;
    }

    @Override
    public int hashCode() {
        return this.name.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        Book b  = (Book)obj;
        return this.name.equals(b.name);
    }


    @Override
    public String toString() {
        return "[書名："+ this.name+" 價格："+this.price+"]";
    }
}

public class Demo15 {

    public static void main(String[] args) {
        //不允許重複的書名存在。
        HashSet<Book> books = new HashSet<Book>();
        books.add(new Book("深入javaweb",34));
        books.add(new Book("java神書",78));

        //修改書名
        Iterator<Book> it = books.iterator();
        while(it.hasNext()){
            Book b = it.next();
            if(b.name.equals("java神書")){
                b.name = "java程式設計思想";
            }
        }

        //為什麼修改名字之後不能删除了呢?
        books.remove(new Book("java神書",78));

        System.out.println("集合的元素："+ books);




    }

}

/*
從鍵盤輸入一個字母組成字元串，分别統計每個字母出現的次數(10分)
要求輸出的效果按照字母的順序輸出  a(7)b(5)...
*/
public class Demo16 {

    public static void main(String[] args) {
        System.out.println("請輸入一段字元串：");
        Scanner  scanner = new Scanner(System.in);
        String line = scanner.next();
        char[] arr = line.toCharArray();    //先把字元串轉換成字元數組。
        TreeMap<Character, Integer> map = new TreeMap<Character, Integer>(); 
        for(char c : arr){
            if(map.containsKey(c)){ //map集合已經包含了該字元
                int count = map.get(c);
                map.put(c, count+1);
            }else{  //沒有包含
                map.put(c, 1);
            }
        }
        System.out.println(map);


    }

}

輸出：

三元運算符的格式：

布爾表達式?值1:值2 true 為值1 false為值2

構造代碼塊：是用來初始化類的建立一個類執行一次

靜态構造代碼塊：類加載到記憶體的時候就執行而且就執行一次

/*
構造代碼塊：給對象進行統一的初始化工作。

應用場景： 如何建立任意對象的時候都需要調用某個方法為該對象進行初始化時，這時候就可以使用構造代碼塊。

靜态代碼塊:

靜态代碼塊是靜态代碼塊所屬的類被加載到記憶體的時候執行的。


靜态代碼塊的應用場景： 以後主要用于準備一個項目的初始化工作。 
    比如： 從配置配置檔案中讀取資料庫使用者名與密碼。


 */

class Baby{

    int id;

    String name;

    //構造代碼塊的代碼其實是在構造函數中執行的。 
    {

        cry();
    }

    static{
        System.out.println("靜态代碼塊執行了...");
    }

    public Baby(int id, String name) {
        this.id = id;
        this.name = name;

    }

    public Baby(){

    }

    public void cry(){
        System.out.println("哭...");
    }

    @Override
    public String toString() {
        return " 編号："+this.id+" 姓名："+ this.name;
    } 
}




public class Demo9 {

    public static void main(String[] args) {
        Baby b1 = new Baby();
        Baby b2 = new Baby(110, "狗娃");
    }

}

記憶體分析：

/*
 多态： 父類的引用類型變量指向了子類的對象，或者是接口的引用類型變量指向接口實作類的對象。 

應用： 
    1. 多态應用于形參類型的時候，可以接收更多類型的參數，
        sort(List  list)
        sort(ArrayList list)
        sort(LinkedList list)

    2. 多态用于傳回值類型的時候可以傳回更多類型的參數。

疊代器的作用： 用于擷取集合中的元素。     

 内部類： 

内部類的好處： 内部類可以直接通路外部類的成員。

 */

interface MyList{

    List subList(int fromIndex, int toIndex);
}






public class Demo12 {

    public static void main(String[] args) {    
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(10);
        list.add(19);
        list.add(12);
        list.add(6);

        Iterable<Integer> it = (Iterable<Integer>) list.iterator();
    }
}

匿名内部類：
/*
匿名對象：沒有引用類型變量指向的對象就稱作為匿名對象。

匿名内部類：沒有類名的類就稱作為匿名内部類。

匿名内部類使用前提： 必須存在繼承或者實作關系。

因為匿名内部類沒有類名，是以建立匿名内部類對象的時候就必須要借助與它父類的名字或者它父接口的名字來建立。 
但是匿名内部類隻不過是沒有類名，其他的一概成員都是具備的。


匿名内部類的應用場景： 主要是作為參數傳遞使用。

 */

interface Dao{

    public void add();
}

class Outer{

    public void print(){
        new Dao(){ //這裡不是建立接口 的對象，是建立了Dao實作類的對象，但是這個類是一個匿名内部類而已，沒有類名借用了父接口 的名字而已。
            //大括号中就寫匿名内部類的成員。
            int  num =10;

            @Override
            public void add() {
                System.out.println("添加學生 ..");
            }
        }.add();

    }
}




public class Demo13 {

    public static void main(String[] args) {

        /*Outer outer = new Outer();
        outer.print();*/

        JButton button = new JButton("aa");
        button.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("aaa");

            }
        });


    }

}

/*
 匿名對象： 沒有引用類型變量指向的對象就稱作為匿名對象。

匿名對象的主要作用： 簡化書寫。

匿名對象主要用于兩種應用場景：
    1. 如果一個對象的方法隻會調用一次的時候，然後該對象就不再使用了，這時候就就可以使用匿名對象。
    2. 作為參數傳遞。
 */
    BufferedReader bufferedReader = new BufferedReader(new FileReader("F:\\a.txt"));

java簡單複習（雜）

繼續閱讀

neo4j之cypher使用文檔

Dijkstra--簡易版（最短路徑）

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

NOSQL安全攻擊

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

登入plsql 報錯 the account is locked --使用者被鎖

Effective Java 8:通用程式設計

SequoiaDB巨杉資料庫C++驅動概述

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method

hdu7108哈希