Java學習第八天_ZenDei技術網路在線

1、多態中成員的特點： 1:成員變數: 編譯時期看父類，運行結果看父類 2：成員方法: 編譯時期看父類,運行結果看子類（子類把方法重寫了） 3：靜態方法: 編譯時期看父類,運行結果看父類 2.Object：根類，超類，對所有對象共性的提取,所有任何類，如果沒有書寫extends顯示繼承某個類，都默 ...

1、多態中成員的特點：
　　1:成員變數: 編譯時期看父類，運行結果看父類
　　2：成員方法: 編譯時期看父類,運行結果看子類（子類把方法重寫了）
　　3：靜態方法: 編譯時期看父類,運行結果看父類

2.Object：根類，超類，對所有對象共性的提取,所有
　　　　任何類，如果沒有書寫extends顯示繼承某個類，都預設直接繼承Object類
　　　　Object類中所定義的方法，是所有對象都具備的方法（11個方法，可以自己查一下api吧）
　　特點：
　　Object類型可以存儲任何對象：
　　作為參數，可以接受任何對象
　　作為返回值，可以返回任何對象
　　例如：
　　boolean equals(Object obj);

3.當輸出一個對象時，預設調用了 toString()方法，預設toString()方法返回：類名@對象的哈希值

1.預設實現
int hash=ren1.hashCode();
System.out.println(Integer.toHexString(hash));

//得到對象對應的位元組碼
Class classz=ren1.getClass();//Person.class 被面向對象了 Class
String name = classz.getName();
System.out.println(name);
//最後結合輸出
System.out.println(ren1.getClass().getName()+"@"+Integer.toHexString(ren1.hashCode()));

2.通常重寫toString()，返回屬性的值
public String toString(){
　　return name+","+age;
}

4.模板設計模式：在實現一個功能時，功能的一部分是確定的，一部分是不確定的，確定的部分會用到不確定的部分

　　　　　　那麼就把不確定的部分暴露出去，讓子類去實現

 1 例如：計算程式運行的時間
 2 abstract class TimeTool
 3 {
 4     public final void tongJiTime()
 5     {
 6         //在程式運行前記錄一個時間
 7         long start=System.currentTimeMillis();
 8 
 9         //功能代碼
10         fun();
11 
12          //在程式運行後記錄一個時間
13          long end=System.currentTimeMillis();
14          System.out.println("程式運行時間為:"+(end-start)+"毫秒");
15     }
16     public abstract void fun();
17 }
18 
19 class Test extends TimeTool
20 {
21     public void fun(){
22         for(int i=1;i<=3000;i++)
23         {
24             System.out.println(i);
25         }
26     }
27 }
28 class Demo4 
29 {
30     public static void main(String[] args) 
31     {
32         Test test = new Test();
33          test.tongJiTime();
34     }
35 }

5.內部類：在一個類的內部定義的類就叫內部類(把內部類看成成員),成員和成員之間可以相互使用

內部類的特點：
1.編譯後可生成獨立的位元組碼文件
2.內部類可直接訪問外部類的私有成員，為不破壞封裝
3.可為外部類提供必要的內部功能組件

6.內部類的位元組碼:外部類$內部類.class

7.什麼時候需要定義內部類？需要描述事物內部的事物

8.成員內部類：在類的內部定義，與實例變數、實例方法同級別的類
　　　　　　　外部類的一個實例部分，創建內部類對象時，必須依賴外部類對象
　
　　　特點：當外部類、內部類存在重名屬性時，會優先訪問內部類屬性
　　　　　　成員內部類不能定義靜態成員

 1 class Outer{
 2 
 3 class Inner{
 4 
 5 }
 6 }
 7 
 8 class Outer{
 9 
10 static class Inner{
11 public static void show(){}
12 }
13 }
14 
15 Outer out=new Outer();
16 Inner in=out.new Inner();

　　　　內部類訪問外部類對象: 外部類名.this

　　　 內部類訪問外部類對象中的成員，外部類名.this.成員名

9.靜態內部類:內部類屬於成員，所以可以被static修飾，內部類中的方法是靜態的，那麼內部類必須是靜態的
　　　　　　不依賴外部類對象，可直接創建或通過類名訪問，可聲明靜態成員

　　　　　　只能直接訪問外部類的靜態成員（實例成員需實例化外部類對象）
　　　　　　Outer.Inner inner=new Outer.Inner();
　　　　　　Outer.Inner.show();

10.局部內部類：定義在外部類的方法中，作用範圍和創建對象範圍僅限於當前方法
　　　　　　　局部內部類訪問外部類當前方法中的局部變數時，因為無法保障變數的生命周期與自身相同，變數必須修飾為final
　　　　　　　限制類的使用範圍(jdk1.8開始，局部內部類使用的局部變數不需要使用final 修飾)

11.匿名內部類：沒有類名的局部內部類（一切特征都與局部內部類相同）
　　　　　　特點：必須繼承一個父類或者實現一個介面
　　　　　　　　　定義類、實現類、創建對象的語法合併，只能創建一個該類的對象

　　　　　　　　　優點：減少代碼量
　　　　　　　　　缺點：可讀性較差

 1 適用於類和介面： new Object(){
 2 String name;
 3 public void show(){
 4 }
 5 }.show();
 6 
 7 Object obj= new Object(){
 8 String name;
 9 public void show(){
10 }
11 };
12 
13 
14 new inter(){
15 public void show(){
16 }
17 }.show();
18 
19 
20 inter tt=new inter(){
21 public void show(){
22 }
23 };

12.字元串: class final String extends Object

是常量，一旦定義了就不可以改變了
存儲在方法區的常量池
已經存在的字元串，再定義時直接使用已經存在的
重寫了equals()方法
String s=new String("hello");//產生兩個對象，堆、池中各存儲一個

　　charAt(6)
　　indexOf()
　　lastIndexOf()
　　contains()
　　equals()
　　equalsIgnoreCase()‘/
　　startsWith()
　　endsWith();

13.字元串獲取：
　　獲取字元串的長度
　　int length()
　　獲取某一個位置上的字元
　　char charAt(int index)
　　獲取字元在字元串中的位置
　　如果要找的字元或者字元串不存在，返回值為-1
　　int indexOf(char ch)//返回字元在字元串中第一次出現的位置
　　int indexOf(int ch, int fromIndex)//第二個參數用於指定開始找的位置

　　int indexOf(String str) //獲取一個字元串在字元串中出現的位置
　　int indexOf(String str, int fromIndex)//第二個參數用於指定開始找的位置

　　int lastIndexOf(char ch)//最後一次出現的位置
14.字元串判斷：
　　判斷是否包含一個字元串
　　boolean contains(CharSequence s)
　　判斷兩個字元串的內容是否相同
　　boolean equals(Object anObject)
　　忽略大小寫判斷兩個字元串的內容是否相同
　　boolean equalsIgnoreCase(String anotherString)
　　判斷是否以某字元串開頭
　　boolean startsWith(String prefix)
　　判斷是否以某字元串結尾
　　boolean endsWith(String suffix)
15.字元串轉換：將字元數組轉換成字元串
　　1:使用構造方法
　　　String(char[] value)
　　　String(char[] value, int offset, int count)
　　2:使用靜態方法
　　　static String copyValueOf(char[] data)
　　　static String copyValueOf(char[] data, int offset, int count)
　　　將字元串轉成字元數組
　　　char[] toCharArray()

16.將位元組數組轉成字元串
　　　String(byte[] bytes)
　　　String(byte[] bytes, int offset, int length)
　　　String(byte[] bytes, String charsetName)//使用指定的編碼將位元組數組轉換成字元成
　　　將字元串轉成位元組數組
　　　byte[] getBytes()

　　　將基本數據類型轉換成字元串
　　　String.valueOf()
17.字元串替換：
　　　String replace(char oldChar, char newChar)

18.子串:
　　String substring(int beginIndex)
　　String substring(int beginIndex, int endIndex) //包含起始位置，不包含結束位置，到結束位置的前一位

19.轉換，去除空格，比較:
　　大小寫轉換
　　String toLowerCase()
　　String toUpperCase()
　　將字元串兩端的空格去掉
　　String trim()
　　按字典順序比較兩個字元串
　　int compareTo(String anotherString)
20.切割: String[] split(String)

21.可變字元串：
　　StringBuffer:可變長字元串，JDK1.0提供，運行效率慢、線程安全
　　StringBuilder:可變長字元串，JDK5.0提供，運行效率快、線程不安全

22.BigDecimal:可精確計算浮點數