功能 面向過程 去除空格 student -1 結束 man count int end

1.面向對象的思想

面向對象是基於面向過程的編程思想.

面向過程:強調的是每一個功能的步驟

面向對象:強調的是對象,然後由對象去調用功能

特點

是一種更符合我們思考習慣的思想

可以將復雜的事情簡單化

將我們從執行者變成了指揮者

角色發生了轉換

定義一個學生類

 1 public class Student {
 2     //成員變量
 3     //姓名
 4     String name;
 5     //年齡
 6     int age;
 7     
 8     //成員方法
 9     //學習的方法
10     public void study() {
 
11         System.out.println("學習");
12     }
13     
14     //吃飯的方法
15     public void eat() {
16         System.out.println("吃飯");
17     }
18 }

定義一個手機類

 1 public class Phone {
 2     //品牌
 3     String brand;
 4     //價格
 5     int price;
 6     //顏色
 7     String color;
 8     
 9     //打電話
10     public
 
 void call(String name) {
11         System.out.println("給"+name+"打電話");
12     }
13     
14     //發短信
15     public void sendMessage() {
16         System.out.println("群發短信");
17     }
18 }

2.成員變量和局部變量的區別

在類中的位置不同

成員變量：類中，方法外

局部變量：方法中或者方法聲明上(形式參數)

在內存中的位置不同

成員變量：堆內存

局部變量：棧內存

生命周期不同

成員變量：隨著對象的創建而存在，隨著對象的消失而消失

局部變量：隨著方法的調用而存在，隨著方法的調用完畢而消失

初始化值的不同

成員變量：有默認值

局部變量：沒有默認值。必須先定義，賦值，最後使用

 1 public class DemoVariable {
 2     int x; //成員變量
 3     
 4     public void show() {
 5         int y = 0; //局部變量
 6         
 7         System.out.println(x);
 8         System.out.println(y);
 9     }
10 }

3.封裝

private關鍵字由來及其使用

private關鍵字：

是一個權限修飾符。

可以修飾成員(成員變量和成員方法)

被private修飾的成員只在本類中才能訪問。

 1 public class Student {
 2     String name;
 3     //int age;
 4     private int age;
 5     
 6     public void setAge(int a) {
 7         if(a<0 || a>200) {
 8             System.out.println("你給的年齡有誤");
 9         }else {
10             age = a;
11         }
12     }
13     
14     public int getAge() {
15         return age;
16     }
17     
18     public void show() {
19         System.out.println("姓名是："+name+",年齡是："+age);
20     }
21 }

private最常見的應用：

把成員變量用private修飾

提供對應的getXxx()/setXxx()方法

一個標準的案例的使用

 1 public class Student {
 2     private String name;
 3     private int age;
 4     
 5     public void setName(String n) {
 6         name = n;
 7     }
 8     
 9     public String getName() {
10         return name;
11     }
12     
13     public void setAge(inta) {
14         age = a;
15     }
16     
17     public int getAge() {
18         return age;
19     }
20 }

封裝的概述和好處

封裝概述

是面向對象三大特征之一

是面向對象編程語言對客觀世界的模擬，客觀世界裏成員變量都是隱藏在對象內部的，外界無法直接操作和修改。就像剛才說的年齡。

封裝原則：

將不需要對外提供的內容都隱藏起來。

把屬性隱藏，提供公共方法對其訪問。

成員變量private，提供對應的getXxx()/setXxx()方法

好處：

通過方法來控制成員變量的操作，提高了代碼的安全性

把代碼用方法進行封裝，提高了代碼的復用性

4.this關鍵字

this:代表所在類的對象引用

方法被哪個對象調用，this就代表那個對象

this關鍵字的使用

局部變量隱藏成員變量(局部變量和成員變量重名)

 1 public class Student {
 2     private String name;
 3     private int age;
 4     
 5     public void setName(String name) {
 6         //name = name;
 7         this.name = name;
 8     }
 9     
10     public String getName() {
11         return name;
12     }
13     
14     public void setAge(intage) {
15         //age = age;
16         this.age = age;
17     }
18     
19     public int getAge() {
20         return age;
21     }
22 }

5.構造方法

作用

給對象的數據進行初始化

格式

方法名與類名相同

沒有返回值類型，連void都沒有

沒有具體的返回值

修飾符 構造方法名(參數列表){

}

註意事項

如果你不提供構造方法，系統會給出默認構造方法

如果你提供了構造方法，系統將不再提供

構造方法也是可以重載的（即使用時帶參構造和無參構造可同時使用）

 1 public class Student {
 2     private String name;
 3     private int age;
 4     
 5     /*
 6     public Student() {
 7         System.out.println("構造方法");
 8     }
 9     */
10     
11     public Student() {}
12     
13     public Student(String name) {
14         this.name = name;
15     }
16     
17     public Student(int age) {
18         this.age = age;
19     }
20     
21     public Student(String name,int age) {
22         this.name = name;
23         this.age = age;
24     }
25 
26     public void show() {
27         System.out.println(name+"---"+age);
28     }
29 }

6.String類

字符串是由多個字符組成的一串數據

構造方法

public String(String original) 把字符串數據封裝成字符串對象

public String(char[] value) 把字符數組的數據封裝成字符串對象

public String(char[] value,int offset,int count) 把字符數組中的一部分數據封裝成字符串對象

直接賦值也可以是一個對象(定義一個字符串變量)

通過構造方法創建字符串對象

String s = new String(“hello”);

直接賦值創建字符串對象

String s = “hello”;

判斷功能方法

boolean equals(Object obj): 比較字符串的內容是否相同

boolean equalsIgnoreCase(String str): 比較字符串的內容是否相同,忽略大小寫

boolean startsWith(String str): 判斷字符串對象是否以指定的str開頭

boolean endsWith(String str): 判斷字符串對象是否以指定的str結尾

獲取功能方法

int length():獲取字符串的長度，其實也就是字符個數

char charAt(int index):獲取指定索引處的字符

int indexOf(String str):獲取str在字符串對象中第一次出現的索引,沒有返回-1

String substring(int start):從start開始截取字符串到字符串結尾

String substring(int start,int end):從start開始，到end結束截取字符串;包括start，不包括end

轉換功能方法

char[] toCharArray():把字符串轉換為字符數組

String toLowerCase():把字符串轉換為小寫字符串

String toUpperCase():把字符串轉換為大寫字符串

去除空格和分割功能方法

String trim()去除字符串兩端空格

String[] split(String str)按照指定符號分割字符串

7.類名作為形式參數和返回值

類名作為形式參數案例:需要的其實是該類的對象

1 class Test {
2     public void show(Person p){
3         p.eat();
4     }
5 }

類名作為返回值案例:返回的其實是該類的對象

1 class Test {
2     public Person show(){
3         Person p = new Person("小王");
4         return p;
5     }
6 }

8.StringBuilder類

String與StringBuilder的區別：

String的內容是固定的。

StringBuilder的內容是可變的。

添加功能

public StringBuilder append(任意類型):添加數據，並返回自身對象

反轉功能

public StringBuilder reverse()

 1 public class DemoStringBuilder {
 2     public static void main(String[] args) {
 3         //創建對象
 4         StringBuilder builder = new StringBuilder();                
 5         //鏈式編程
 6         builder.append("hello").append("world").append(true).append(100);
 7         
 8         System.out.println("builder:"+builder);
 9         
10         //public StringBuilder reverse()
11         builder.reverse();
12         System.out.println("builder:"+builder);
13     }
14 }

9.ArrayList集合

ArrayList<E>集合:大小可變數組的實現

<E>:是一種特殊的數據類型，泛型。

在出現E的地方我們使用引用數據類型替換即可

舉例：ArrayList<String>,ArrayList<Student>

構造方法

ArrayList()

成員方法

添加元素

public boolean add(E e):添加元素

public void add(int index,E element):在指定的索引處添加一個元素

 1 public class DemoArrayList {
 2     public static void main(String[] args) {
 3         //創建集合對象
 4         ArrayList<String> list = new  ArrayList<String>();
 5         
 6         //add(E e):添加元素
 7         list.add("hello");
 8         list.add("world");
 9         list.add("java");
10         
11         //add(int index,E element):在指定的索引處添加一個元素
12         list.add(1, "android");
13         
14         System.out.println("array:"+list);
15     }
16 }

獲取元素

public E get(int index):返回指定索引處的元素

集合長度

public int size():返回集合中的元素的個數

刪除元素

public boolean remove(Object o):刪除指定的元素，返回刪除是否成功

public E remove(int index):刪除指定索引處的元素，返回被刪除的元素

修改元素

public E set(int index,E element):修改指定索引處的元素，返回被修改的元素

10.FileWriter和FileReader

FileWirter寫數據

構造方法

FileWriter(String fileName) 傳遞一個文件名稱

成員方法

void write(String str) 往文件中寫入一個字符串。

void flush() 刷新該流的緩沖，把內存緩沖區中的數據刷新到文件中。

void close() 關閉此流，但要先刷新它。

輸出流寫數據的步驟：

1.創建輸出流對象

2.調用輸出流對象的寫數據的方法

3.釋放資源

路徑:

相對路徑：相對當前項目而言的，在項目的根目錄下(a.txt)

絕對路徑：以盤符開始的路徑(d:\\a.txt)

close()和flush()方法的區別：

flush():刷新緩沖區。流對象還可以繼續使用。

close():先刷新緩沖區，然後通知系統釋放資源。流對象不可以再被使用了。

FileWriter寫數據的5個方法

void write(String str):寫一個字符串數據

void write(String str,int index,int len):寫一個字符串中的一部分數據, index:開始索引,len:寫幾個

void write(int ch):寫一個字符數據,這裏寫int類型的好處是既可以寫char類型的數據，也可以寫char對應的int類型的值。‘a‘,97

void write(char[] chs):寫一個字符數組數據

void write(char[] chs,int index,int len):寫一個字符數組的一部分數據, index:開始索引,len:寫幾個

換行問題

windows:\r\n

linux:\n

mac:\r

換行符可以寫在第一個數據的結尾,也可以寫在第二個數據的開頭

FileReader讀數據

構造方法

FileReader(String fileName) 傳遞要讀取的文件名稱

成員方法

int read() 讀取單個字符並返回

int read(char[] cbuf) 一次讀取一個字符數組的數據，返回的是實際讀取的字符個數

輸入流讀文件的步驟：

1.創建輸入流對象

2.調用輸入流對象的讀數據方法

3.釋放資源

一次讀寫一個字符數組復制文本文件

 1 public class Demo02CopyFile {
 2     public static void main(String[] args) throws IOException {
 3         //創建輸入流對象
 4         FileReader fr  = new FileReader("Demo01FileWriter.java");
 5         //創建輸出流對象
 6         FileWriter fw = new FileWriter("Copy.java");
 7         
 8         //讀寫數據
 9         char[] chs = new char[1024];
10         int len;
11         while((len=fr.read(chs))!=-1) {
12             fw.write(chs, 0, len);
13         }
14         
15         //釋放資源
16         fw.close();
17         fr.close();
18     }
19 }

11.BufferedWriter和BufferedReader

BufferedWriter:將文本寫入字符輸出流，緩沖各個字符，從而提供單個字符、數組和字符串的高效寫入。

BufferedReader:從字符輸入流中讀取文本，緩沖各個字符，從而實現字符、數組和行的高效讀取。

 1 public class Demo01BufferedStream {
 2     public static void main(String[] args) throws IOException {
 3         //創建輸出緩沖流對象
 4         BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
 5         bw.write("hello");
 6         //bw.flush();
 7         bw.close();
 8         
 9         //創建輸入緩沖流對象
10         BufferedReader br = new BufferedReader(new FileReader("bw.txt "));
11         
12         /*
13         //一次讀寫一個字符
14         int ch;
15         while((ch=br.read())!=-1){
16             System.out.print((char)ch);
17         }
18         */
19         
20         //一次讀寫一個字符數組
21         char[] chs = new char[1024];
22         int len;
23         while((len=br.read(chs))!=-1) {
24             System.out.print(new String(chs,0,len));
25         }
26         
27         //釋放資源
28         br.close();
29     }
30 }

緩沖流的特殊功能

BufferedWriter

void newLine():寫一個換行符，這個換行符由系統決定

BufferedReader

String readLine():一次讀取一行數據，但是不讀取換行符

從文本文件中讀取數據到ArrayList集合中，並遍歷集合

例：每一行數據作為一個字符串元素

 1 public class Demo03FileToArrayListTest {
 2     public static void main(String[] args) throws IOException {
 3         //創建輸入緩沖流對象
 4         BufferedReader br = 
 5 new  BufferedReader(new FileReader("array.txt"));
 6         
 7         //創建集合對象
 8         ArrayList<String> list = new ArrayList<String>();
 9         
10         //讀取數據，每次讀取一行數據，把該行數據作為一個元素存儲到集合中
11         String line;
12         while((line=br.readLine())!=null) {
13             list.add(line);
14         }
15         
16         //釋放資源
17         br.close();
18         
19         //遍歷集合
20         for(int i=0; i<list.size(); i++) {
21             String s = list.get(i);
22             System.out.println(s);
23         }
24     }
25 }

Java學習周記week02