Java學習筆記

時間 2019-11-21

標籤 java 學習筆記欄目 Java 简体版

原文原文鏈接

一、讀輸入java

Scanner in=new Scanner(System.in);//in這個對象作讀入下一行的操做
System.out.println(in.nextLine());//System.out這個對象打印下一行

二、數組數組

其中全部的元素都具備相同的數據類型

int []s=new int[maxn];//數組定義  new建立的數組會獲得默認的0值 建立maxn個int型數組
int []s={1,2,3,4};//直接初始化數組 能夠不用給出大小

有成員函數length可直接使用
    
    數組變量是  ！**數組的管理者**！而非數組自己！
    
    數組必須建立出來交給數組變量管理，數組變量之間的賦值是**管理權限**的賦予，
    數組變量之間的比較是判斷**是否管理同一個數組**
    eg.   s是有maxn個元素的數組的管理者

三、包裹類型框架

基礎類型       包裹類型
        boolean       Boolean
        char          Character
        int           integer
        double        Double

能夠經過包裹類型獲取該類型的最大最小值，判斷是不是字母什麼的能夠有更多的功能擴展dom

四、Math類ide

Math.abs(-12);//12
    Math.pow(2,3);//8.0 浮點運算
    Math.random();//生成0~1之間的隨機數  能夠*100 獲取0~100之間的隨機數
    Math.round();//四捨五入

五、字符串函數

字符串變量並不存放字符串，也不是字符串全部者，它是**字符串的管理者**
    Java的字符串是」不可變「對象，全部對字符串的操做都是產生一個新的字符串，
    而不是對原來的字符串進行修改
    
    String的變量是對象的管理者
    eg.    String s=new String("a string");//建立了一個String的對象，並初始化
            //建立了這個對象的管理者s 讓s管理這個對象
    輸入字符串，in.next；//讀入一個單詞,以空格爲界  in.nextLine();讀入一整行
    
    字符串的比較:
    if(input=="bye")  比較的是 是否指向的是同一個String對象 很大可能return false
                       由於input和"bye"是兩個不一樣的字符串
    if（input.equals("bye") 纔是比較內容是否相同
    
    對字符串的操做：
    s.charAt(index);//返回在index上的單個字符 0~length()-1
    //注意 不能用for-each循環來遍歷字符串  for(char c:s){}不行
    //for-each只適合於數組或者可枚舉類型
    s.substring(n);//獲得從n號位置到末尾的所有內容
    s.substring(b,e);//b號位置到e號位置以前的內容 左閉右開
    s.indexOf(c);//獲得c字符所在位置，-1表示不存在
    s.indexOf(c,n);//從n號位置開始找
    s.indexOf(t);//找到字符串t所在位置 返回值爲子串開始的index
    s.lastIndexOf();//從右邊開始找
    
    eg.要找一個串中的第二個3  String s="0123453";
       int loc=s.indexOf('3');
       s.indexOf('3',loc+1);
    
    s.startsWith(t);//s是不是以字符串t開頭的
    s.endsWith(t);
    s.trim();//把字符串兩端的空格刪掉
    s.replace(c1,c2);//全部的c1換成c2
    s.toLowerCase();//全部字符都變成小寫
    s.toUpperCase();

六、本地變量不會被自動初始化有可能會報錯，因此要記得初始化佈局

本地變量：定義在函數內部,做用域和生存期都在函數內部，
而成員變量（自動初始化爲0或null）的生存期是對象的生存期，做用域是類內部的成員函數

七、類和對象this

VendingMachine v=new VendingMachine();//對象變量是對象的管理者

v.insertMoney()中使用的成員變量是v的成員變量實際上**是經過this實現的**

this:spa

this是成員函數的一個特殊的固有的**本地變量**，它表達了調用這個函數的 **那個對象**
在成員函數內部直接調用本身的其餘函數，也能夠經過this來實現(一般會省略）

一個類的成員變量能夠是其餘類的對象設計

八、封裝：把數據和對數據的操做放在一塊兒，而且用這些操做把數據掩蓋起來（面向對象核心概念）

直接手段：
    類的全部成員變量必須是private的
    全部的public的函數，只是用來實現這個類對象或類本身要提供的服務的，而不是用來直接訪問數據。

private（類所私有的）只能用於成員變量和成員函數:

public class Display{
    private int num;
    private int getValue(){    };//不能夠在getValue函數中定義變量的時候使用private
}

注意：

只有這個 類內部（類的成員函數和定義初始化） 能夠訪問
這個限制是對類的，而不是對對象的
//private定義的變量，限制其餘類的對象訪問本類對象的這個變量，但不限制本類的其餘對象訪問奔雷的private數據

public class Fraction{
    private int a;
    private int b;
    public Fraction plus(Fraction r)
    {
        int fenzi=a*r.b+r.a*b;//這個徹底能夠實現哦，由於private的限制不是對對象的，他們都在Fraction類裏
        int fenmu=b*r.b;
        return new Fraction(fenzi,fenmu);
    }
}

九、包

十、類變量和類函數

類是描述，對象是實體
在類中所描述的成員變量，其實是位於這個類的各自的對象中的
可是若是某個成員由static關鍵字修飾，它就變成了屬於整個類的了
每一個對象均可以訪問到這些類變量和類函數而且能夠直接經過名字調用
類函數不屬於任何對象，沒法創建與調用他們的對象的關係，也就不能直接訪問任何非static的成員變量和成員函數,必需要經過對象進行調用
this表示當前本對象，類函數和對象沒有任何關係，因此類函數沒有this
經過一個類的對象對static變量進行了修改，那麼其餘對象中的這個變量的值也都被修改了，由於這個變量是類的，而不是單獨某一個對象的
能夠經過 類.static型變量 對該變量進行訪問
static變量只能被初始化一次,在第一次類的裝載的時候被初始化

十一、對象容器
究竟把什麼放進容器裏了？對象的管理者.

泛型類：eg. ArrayList 這種泛型類是一種容器
無限放東西，計算機有容量就能一直放，數組沒法實現，要用容器實現

容器類有兩個類型：容器的類型（ArrayList）、元素的類型（String)

import java,util.ArrayList;
public class NoteBook{
    private ArrayList<String> notes=new ArrayList<String> ();
    //ArrayList類中經常使用成員函數
    //notes.add(s);  notes(location,s);//把s放在原來location前面，即放在location位置，原來location位置之後的東西順序後移
    //notes.size();
    //notes.remove(index);
    //notes.toArray(a);//把這個ArrayList裏的元素都複製到a數組中，而後進行輸出,以下圖所示，能夠省略一個循環
}

十二、對象數組

當數組的元素的類型是類的時候，數組的每個元素都只是對象的管理者而非對象自己，
僅僅建立數組並不意味着建立了其中的每個對象,String[] a=new String[10]，此時對象尚未建立出來,若是是int，則會產生a[0]=0;

for-each循環

for(int k:ia){  k++;  }//沒有任何用，由於這裏的k只是原數組的複製品
對於對象數組卻有所不一樣
由於 數組管理的那塊東西 和 for-each循環裏那個東西管理的 是同一個東西，會實現修改

1三、集合容器

HashSet<String> s=new HashSet<String>();//集合不保存重複鍵值
System.out.println(s);//能夠直接輸出 [second,first]  ArrayList也能夠
//由於他們都實現了toString
public String toString(){
    return ""+s[i];
}

class Value{
    private int i;
    
}

main(){
    Value v=new Value();
    v.set(10);
    System.out.println(v);//輸出的是奇怪的東西，繼續在Value類裏實現toString纔可以輸出
                            //return ""+i;
}

注意：

集合容器中的元素不是在一塊連續的存儲空間內的，各個元素的位置是不連續且無序的，因此沒法用index去索引任何一個元素的地址**（集合是無序的）** 所以，也不能用get()來獲取某個位置的元素

1四、散列表

HashMap<Integer,String> m=new HashMap<Integer,String>();//注意不能是int,由於在容器中全部元素都必須是對象
m.put(key,value);
m.get(key);//能夠獲取到對應的value
m.keySet();//獲取Set中不重複的鍵值個數
//一樣也能夠直接用println輸出m

1五、繼承與多態

子類能夠繼承獲得父類的全部東西（構造方法除外，它是每一個類所獨有的），但並不表明所有可使用。
每一個成員有不一樣的訪問屬性

父類成員訪問屬性   在父類中的含義                   在子類中的含義
public          對全部人開放                     對全部人開放
protected       只有包內其餘類、本身和子類能夠訪問   只有包內其餘類、本身和子類能夠訪問
private         只有本身能夠訪問                  不能訪問
缺省             只有包內其餘類能夠訪問             若是子類和父類在同一個包內：只有包內其餘類能夠訪問 不然，至關於private，不能訪問

protected:包內和子類可訪問
缺省：在父類所在的包內可見，若是子類和父類不在一個包中，則也不能訪問

private型變量在子類中也是存在的，只是不能直接訪問，在子類中也不能更改他們的屬性，若是定義了一個同名變量，則是與父類裏面那個無關的獨立的一個變量

構造一個子類對象時，先回調用父類的構造函數，再調用本身的，父類空間先被初始化，而後子類空間纔會被初始化。這樣就有可能會出現問題。
若是父類的構造函數是有參構造函數，那麼子類如何給他傳參呢？？
這裏用到的是super(title); 父類構造函數會根據super中的參數去尋找它裏面合適的構造函數

關於super:

//super是用來給父類傳遞參數的
super();//一個構造函數中只能使用一次super**（由於只有一個父類呀）**，而且super要放第一行

子類和父類中都有print();時用super.print();調用父類的

多態變量

對象變量能夠保存其聲明的類型的對象，或者該類型的**任何子類型的對象**
保存**對象類型**的變量是**多態變量**（是指一個變量能夠保存不一樣類型的對象）

子類的對象能夠被看成父類的對象來使用：

賦值給父類的變量
傳遞給須要父類對象的函數
放進存放父類對象的容器裏

Java中全部對象變量都是多態的，他們能保存不止一種類型的對象

他們能夠保存聲明類型的對象，或聲明類型的子類的對象
當把子類的對象賦值給父類的變量（不是對象對對象的賦值，而是讓這兩個東西管理同一個東西）的時候——發生了向上造型
```
*C++裏面能夠作對象對對象的賦值，但Java不能*
```

Vechicle v;
Car c=new car();
v=c;
c=v;//編譯錯誤，父類的對象不能賦值給子類的變量
c=(Car)v;//v實際管理的是Car類型才行   （造型：聲明類型和動態類型（實際傳遞進去的）不符）
//這樣可能有風險 取決於v當時管理的對象是什麼 只有它管理Car類型時才能被成功造型
//造型（括號圍起來）：對象自己並無發生任何變化，當作另外一個類型來看待，不是「類型轉換」
//運行時有幾隻來檢查這樣的轉化是否合理  eg.  ClassCastException

多態

子類方法覆蓋了父類方法，但具備相同的方法名稱和參數表，仍然是父類中定義的那個方法，不過是新版本，子類對象調用執行子類本身的這個方法，父類對象執行父類的
注意是對象而非變量，由於一個類型爲父類的變量有可能指向的是一個子類的對象

函數調用的綁定：經過對象變量調用函數時，調用哪一個函數

靜態綁定：根據變量的聲明類型決定
動態綁定：根據變量的動態類型決定（默認）//運行的時候才知道是什麼類型

在成員函數中調用其餘成員函數也是經過this這個對象變量來調用的
因此全部成員函數的調用都應該看作是動態調用

覆蓋(override)

子類方法和父類方法具備相同的方法名稱和參數表的一對函數構成覆蓋關係
經過父類變量調用存在覆蓋關係導函數時，取決於**當時所管理的對象的類**的函數

Object類

全部的類都是繼承自Object的
成員函數：
```
toString();
       equals();
```

向下造型:

public boolean equals(Object obj){//以前穿傳去的是CD類型，因此下面要作一個向下造型
    CD cc=(CD)obj;
    return artist.equals(cc.artist));
}

@Override

告訴編譯器覆蓋了父類的函數，注意**括號參數類型也會不能改的哦，public也不能去掉** 會產生編譯錯誤，加了@的話

1六、抽象

抽象類（abstract)不能建立任何對象，僅僅表達接口，而不具體實現細節。可是**能夠定義變量**，要**繼承了這個抽象類的對象**才能夠賦給這個變量。

eg:

class Circle{...}
Shape c;
c=new Circle();//c實際是管理了子類的對象

抽象類中能夠實現抽象方法，也用abstract修飾，抽象方法是不徹底的，它只是一個方法簽名而徹底沒有方法體。

若是一個類有了抽象方法，這個類就**必須聲明爲抽象類**。

若是父類是抽象類，子類就必須**覆蓋(即實現）全部**在父類中的抽象方法，不然子類也成爲一個抽象類

public abstract class Shape{
    public abstract void draw(Graphics g);//注意不能有{}，否則就會報錯
}

1七、接口：規定長啥樣

接口（interface)是純抽象類
全部的成員函數都是抽象函數
全部的成員變量都是public static final

Cell是一個接口類型，Field若是想要一個Cell,此時Fox和Rabbit都實現了這個接口，從而他們能夠做爲Cell給Field使用。

public interface Cell{//interface和class是同一級別，能夠說是一種特殊的類
    void draw(Grphics g,int x,int y,ints size);
}

類用extends,接口用implements
類能夠實現不少接口
接口能夠繼承接口，可是不能繼承類
接口不能實現接口
設計程序時，要先定義接口，再實現類
任何須要在函數間傳入傳出的必定是接口而不是具體的類？？？留坑不是很懂

1八、instanceof

if(an instanceof Rabbit)//用於判斷an是否是Rabbit類型的變量

20、內嵌類型：在類或接口內部定義的自定義類型

class A{//包圍類
    static class B{ static int x;}//內部類  可添加雨多成員函數才能具有的東西，eg. static,private
    interface C{int y=0;}//內部接口
}//編譯後將產生三個文件：A.class  A$B.class A$C.class

內部類能夠訪問囿類全部成員，包括私有
要訪問內部類，須要經過囿類或囿類對象來訪問
若是要將囿類對象自身傳給內部類對象：囿類對象名.this
外部類和內部類能夠任意互訪，可是外部類要經過建立內部類的對象來訪問內部類
若 內部類 中有靜態成員，則這個內部類必須是靜態內部類纔可以經過A.B.x直接調用起鬨的靜態成員

2一、GUI圖形界面

JButton類：能夠實現一個按鈕JButton bt=new JButton("單步");
JFrame類：實現一個框架

Swing：

全部東西都是部件,放在容器中,容器管理部件的時候會使用佈局管理器(五個方位參數）,默認是BorderLayout;
採用事件監聽器的事件處理模型，某個對象實現相關接口就能夠成爲相關事件的監聽器，就能夠註冊到它想監聽的組件上。

frame.add(bt,BorderLayout.NORTH);//必定要注意指定位置，不然會覆蓋掉以前的東西
//由於參數缺省的時候默認是center,會覆蓋掉前面的

//匿名類
bt.addActionListener`(`   new ActionListener(){
    public void actionPerformed(ActionEvent e){
        ...
    }
}   `)` //ActionListener裏面只有actionPerformed()函數

在new對象的時候給出類的定義造成匿名類
匿名類能夠繼承某類，也能夠實現某接口
Swing的消息機制普遍使用匿名類

//內部類
class StepListener implements ActionListener{
    public void actionPerformed(ActionEvent e){
        ...
    }
}

bt.addActionListener(new StepListener());//注意傳進去要是實現了ActionListener的對象

定義在別的類、函數內部
能直接訪問外部類的資源，包括私有
外部是函數時，只能訪問那個函數裏final的變量

反轉控制
把一個實現了ActionListener接口的對象交給JButton（註冊），JButton就能反過來去調用裏面的actionPerformed()函數，實現相關操做。（也叫Swing的消息機制）

MVC模式

2二、異常處理

import java.util.Scanner;
class test
{
    public static void main(String[] args) {
        int []a=new int[10];
        int idx;
        java.util.Scanner in=new Scanner(System.in);
        idx=in.nextInt(); 

        try{
            a[idx]=10;
            System.out.println("hi");
        }catch(ArrayIndexOutOfBoundsException e)
        {
            System.out.println("caught");
        }
        catch(Typel e){
           ...
        }
        ...
    }
}//try-catch語句捕獲異常,後面能夠跟着不少catch

拿到異常對象以後：
String getMessage();
String toString();
void printStackTrace();

若是沒辦法處理，能夠再度拋出

catch(Exception e){
    System.err.println("An exception was thrown");
    throw e;
}//(若是在這個層面上須要處理，可是不能作最終的決定，就繼續拋出，給下一個catch處理）

什麼能扔？

任何繼承了Throwable類的對象//throws XX
Exception類繼承了Throwable
throw new Exception()
throw new Exception("HELP");//兩種形式

catch怎麼匹配？
Is-A關係
拋出自誒異常會被捕捉父類異常的catch捉到

能捕捉到任何異常：

catch(Exception e){
    System.err.println("Caught an exception");
}

若是你的函數可能會拋出異常，就必須在函數頭部加以聲明

void f() throws TooBig,TooSmall{
    ...
}

2三、I/O流

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。