201871010119-帖佼佼《面向對象程序設計（java）》第四周學習總結
| 項目html |
內容java |
| 這個做業屬於哪一個課程數據庫 |
https://www.cnblogs.com/nwnu-daizh/編程 |
| 這個做業的要求在哪裏數組 |
https://www.cnblogs.com/nwnu-daizh/p/11435127.htmldom |
| 做業學習目標ide |
|
第一部分：總結第四章理論知識（20分）函數
一、面向對象程序設計概述：面向對象程序設計（OOP）是一種新的程序設計思惟，這種方法更接近人類處理現實世界問題的天然表示方法。oop
（1）對象是面向對象編程的核心，是具體實體，具備明肯定義的狀態和行爲。post
（2)對象的三個主要特徵：
1）行爲:能夠對對象施加哪些操做或者可使用哪些方法；
2）狀態：當施加那些操做或者方法時，對象應該如何應對；
3）標識:如何辨別具備相同行爲和狀態的不一樣對象。
二、類（class）
（1）類是具備相同屬性和行爲的一組對象的集合；
（2）類是描述對象的模板，它定義一類對象所擁有的數據和能完成的操做，在面向對象的程序設計中，類是構造程序的基本單位；
（3）每一個類由一組結構化的數據（稱做實例域）和在其上的一組操做構成。
三、如何識別類：
（1）過程化程序設計，必須從頂部的main函數開始編寫程序；
（2）oop的思路，首先從設計類開始，而後在每一個類裏面添加方法；
（3）識別類簡單規則是在問題分析過程當中尋找名詞，而類的方法則對應動詞。
四、類和對象的關係：
（1）類是對象的原型，對象是類的實例，類是同類對象的抽象；
（2）全部屬於同一個類的對象都具備相同的特徵和操做。
五、類之間的關係：
（1） 依賴：若是一個類中的方法操做了另外一個類的對象，那麼這個類就依賴於另外一個類；
（2）聚合：類A的對象包含類B的對象；
（3）繼承：表示一個特定類和一個 通常類之間的關係。
通常來講， 若是類A繼承了類B，那麼類A 不只有類B的方法與狀態，還有屬於本身的 狀態與方法。
六、表達類關係的UML符號：
七、預約義類的使用：
（1）已學過的預約義類：Math類、math類、String類、Scanner類；
（2）要使用預約義類的方法，只需知道方法名和參數便可，無需瞭解它的內在實現過程；
（3）使用預約義類須要在程序開始處用import命令導入該類所在的包路經。
八、對象與對象變量：
（1）在oop中，要想使用對象，就必須首先構造對象，並初始化對象的狀態，而後經過對象調用類中的方法；
（2）Java中，用構造器構造並初始化對象；
（3）構造器是類中一個特殊的方法，該方法與類名相同。不須要提供返回值；
（4）構造並初始化對象的格式：
new 構造器名（參數）
九、對象的初始化實例：
（1）Date類，定義在Java標準類庫的Java.util包中；
（2）初始化Date類對象的實例：
new Date（）；
System.out.println(new Date())；
（3）能夠在類中一個方法用於新建立的對象：String s = new Date（）.toString()；
十、對象變量：
（1）若是要屢次使用初始化的變量，可將初始化後的變量放在一個對象變量中；
格式： Date birthday = new Date（）；
（2）對象變量保存對象後，可用對象變量引用對象；
System.out.println(birthday.toString());
（3）可將一個對象變量設置爲NULL，表示該對象變量未引用任何對象。
十一、更改器方法和訪問器方法：
（1）一個類中對實例域進行修改的方法，更改器前面加set；
（2）一個類中對實例域進行訪問的方法，前綴get。
十二、用戶自定義類：
（1）類的定義包括兩部份內容：聲明和類體
（2）類體由兩部分構成：
一爲實體域（或成員變量）定義；二爲方法定義。
（3）域的定義：
1）實例域：類定義時實例域部分所定義的變量；
2）局部變量：方法體中定義的變量和方法的參數；
3）實例域的隱藏性：局部變量與實例域名字相同時，則實例域被隱藏，即在這個方法內暫時失效。
4）實例域的有效性：在整個類內部有效，而局部變量只在定義它的方法內有效。
5）私有實例域的更改器和訪問器：有時須要得到或設置私有實例域的值，此時需提供下面三項內容：
a）一個私有的數據庫；
b）一個共有的域訪問器方法；
c）一個共有的域訪問器方法；
6）final實例域：
能夠將實例域定義爲final，此類域構建對象時時必須進行初始化；即必須確保在構造器執行以前，這個域的值被設置，而且在後面的操做中，不能再對它的值進行修改，即該域無修改器。
final修飾符多用於基本數據類型域，或不可變類的域；
7）方法定義：
a）包括方法聲明和方法體；
b）方法的聲明：名字，類型和參數等屬性的說明：方法的類型描述的數返回值類型；
c）方法體由局部變量和Java語句構成；一個類中能夠有多個方法具備相同的名字，不一樣的類型，不一樣的參數，這種狀況叫重載；
1三、構造器：用來構造並初始化對象。
（1）構造器的名字必需要與它所在類名字相同；
（2）每一個包能夠由一個以上的構造器；
（3）構造器能夠由一個，一個以上的參數；
（4）構造器沒有返回值；
（5）構造器老是被new運算符調用；
1四、（1）靜態域：絕大多數面向對象程序設計語言中，靜態域被稱爲類域。
若是將域定義爲static，每一個類中只有一個這樣的域。而每一個對象對於全部的實例域卻都有本身的一份拷貝。
（2）main方法：main方法不對任何對象進行操做。靜態的main方法將執行並建立程序所須要的對象。
（3）靜態常量：靜態變量用的少，可是靜態常量用的多。
(4).靜態方法：用修飾的方法叫靜態方法或類方法,靜態方法可經過類名或對象來調用,而其餘方法只能經過對象來調用。靜態方法不能操做對象,不能在靜態方法中訪問實例域。但靜態方法能夠訪問自身類中的靜態域。能夠認爲靜態方法是沒有this參數的方法,而在一 個非靜態方法中,this參數是表示這個對象/對象構造器的隱式參數。
1五、對象的定義：使用一個類建立一個對象時，即建立了一個類的實例域。只有經過對象才能夠訪問該域的公共實例域，調用類中共有的方法；
1六、類的導入：一個類能夠直接使用它所在的包中的全部類，也可使用來自其餘包中的全部public類。
（1）靜態導入：import語句不只能夠導入類，還增長了靜態導入方法和靜態域的功能；
（2）將類放如包中：首先用package語句指明報的名字，且該語句應爲程序的第一條語句，而後纔是定義類的語句；
（3）若是源文件不使用package語句指明包名，源文件的類將屬於默認包。
（4）當一個源文件中使用了package語句時，那麼這個包中全部的類文件的都必須放在與包名相匹配的目錄中；
（5）當程序中所使用的類位於不一樣包時，起源問價和類文件必須以下組織；
1七、包做用域：
（1）類中標記爲public的部分能夠被任意類使用；
（2）類中標記爲private的部分只能在類中使用；
（3）若是沒有爲類、方法或實例域指定訪問控制修飾符public或private，這部分能夠被同一包中的全部方法訪問；
（4）若是實例域不標記爲private，將默認爲包可見，這樣作會破壞類的封裝性。
1八、類路徑：
（1）類存儲在文件系統的子目錄中，類得路徑必須與包名匹配；
（2）在命令行方式下，設置類路徑，使用-classpath選項指定類路徑。
第二部分：實驗部分
實驗名稱：實驗三 類與對象的定義及使用
1. 實驗目的：
(1) 熟悉PTA平臺線上測試環境；
(2) 理解用戶自定義類的定義；
(3) 掌握對象的聲明；
(4) 學會使用構造函數初始化對象；
(5) 使用類屬性與方法的使用掌握使用；
(6) 掌握package和import語句的用途。
3. 實驗步驟與內容：
實驗1 任務1（10分）
package sheji;
import java.util.Scanner;
public class ID {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("請輸入身份證號18位！");
Scanner in = new Scanner(System.in);
String ID = in.nextLine();
String s1,s2,s3;
int i = 6;
s1 = ID.substring(i, i+4);
s2 = ID.substring(i+4, i+6);
s3 = ID.substring(i+6, i+8);
System.out.println(s1+"-"+s2+"-"+s3);
}
}
運行結果以下：
實驗1 任務2（25分）
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;
public class students {
private static ArrayList<Student> list;
public static void main(String[] args) {
// TODO Auto-generated method stub
list = new ArrayList<>();
Scanner in = new Scanner(System.in);
try {
readFile("studentfile.txt"); //讀如文件 studentfile.txt的信息
System.out.println("請選擇操做，1按姓名，2按學號，3退出"); //首先在控制檯輸出 ：請選擇操做，1按姓名，2按學號，3退出
int i;
while ((i = in.nextInt()) != 3) //讀出並轉換下一個表示整型的字符序列
{
switch (i) //switch語句控制菜單
{
case 1: //按學生的姓名查找
System.out.println("請輸入姓名"); //在控制檯上輸出：請輸入姓名
String name = in.next(); //定義一個String類對象name，表示下一行字符串
Student student = findStudentByName(name); //經過姓名查找學生的信息
if (student == null) {
System.out.println("沒找到"); //if語句判斷，若是學生的信息爲空，則在控制檯輸出： 沒找到
} else {
System.out.println(student.toString()); //不然，調用toString方法輸出學生的信息
}
System.out.println("請選擇操做，1按姓名，2按學號，3退出");
break; //退出當前的循環
case 2:
System.out.println("請輸入學號"); //按學生的學號查找
String id = in.next(); //定義一個String類對象id，表示下一行字符串
Student student1 = findStudentById(id); //經過學號查找學生的信息
if (student1 == null) { ////if語句判斷，若是學生的信息爲空，則在控制檯輸出： 沒找到
System.out.println("沒找到");
} else {
System.out.println(student1.toString()); //不然，調用toString方法輸出學生的信息
}
System.out.println("請選擇操做，1按姓名，2按學號，3退出");
break;
default:
System.out.println("輸入有誤");
System.out.println("請選擇操做，1按姓名，2按學號，3退出");
break;
}
}
} catch (IOException e) {
// TODO 自動生成的 catch 塊
e.printStackTrace();
}finally {
in.close(); //最後關閉0
}
}
public static void readFile(String path) throws IOException {
FileReader reader = new FileReader(path); //
BufferedReader br = new BufferedReader(reader);
String result; //定義一個String類對象 result
while ((result = br.readLine()) != null) { //while循環
Student student = new Student();
student.setName(result.substring(13));
student.setID(result.substring(0,12)); //從第十三位開始，調用result對象的substring方法獲得一個新的字符串
list.add(student);
}
br.close();
}
public static Student findStudentByName(String name) { //經過姓名找學生的信息
for (Student student : list) {
if (student.getName().equals(name)) { //用equals方法檢測兩個字符串是否相等
return student;
}
}
return null;
}
public static Student findStudentById(String Id) { //經過學號查找學生的信息
for (Student student : list) {
if (student.getID().equals(Id)) { //用equals方法檢測兩個字符串是否相等
return student;
}
}
return null;
}
}
class Student {
private String name; //String類對象name的私有的實例域
private String ID; //String類對象ID的私有的實例域
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getID() {
return ID;
}
public void setID(String iD) {
ID = iD;
}
@Override
public String toString() {
// TODO 自動生成的方法存根
return "姓名是：" + name + "學號是：" + ID; //獲得查找學生的信息
}
}
運行結果以下：
實驗2 測試程序1（10分）
import java.time.*;
/**
* This program tests the Employee class.
* @version 1.13 2018-04-10
* @author Cay Horstmann
*/
public class EmployeeTest //帶有public修飾的EmployeeTest類，其包含了main方法
{
public static void main(String[] args)
{
// fill the staff array with three Employee objects
Employee[] staff = new Employee[3]; //構造了一個Employee數組，並填入了三個僱員對象
staff[0] = new Employee("Carl Cracker", 75000, 1987, 12, 15);
staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
staff[2] = new Employee("Tony Tester", 40000, 1990, 3, 15);
// raise everyone's salary by 5%
for (Employee e : staff) //利用Employee類的raiseSalary方法將每一個僱員的薪水提升5%
e.raiseSalary(5);
// print out information about all Employee objects
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
+ e.getHireDay()); //調用getName方法、getSalary方法以及getHireDay方法將每一個僱員的信息打印出來
}
}
class Employee //Employee類
{
private String name; //三個僱員對象的私有實例域
private double salary;
private LocalDate hireDay;
public Employee(String n, double s, int year, int month, int day)
{
name = n;
salary = s;
hireDay = LocalDate.of(year, month, day);
}
public String getName()
{
return name;
}
public double getSalary()
{
return salary;
}
public LocalDate getHireDay()
{
return hireDay;
}
public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}
}
運行結果以下：
（2）
import java.time.LocalDate;
public class Employee {
private String name; //實例域定義
private double salary; //實例域定義
private LocalDate hireDay; //實例域定義
public Employee(String n, double s, int year, int month, int day) //構造器的定義
{
name = n;
salary = s;
hireDay = LocalDate.of(year, month, day);
}
public String getName() //實例域name的訪問器方法
{
return name;
}
public double getSalary() //實例域Salary的訪問器方法
{
return salary;
}
public LocalDate getHireDay() ////實例域HireDay的訪問器方法
{
return hireDay;
}
public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}
}
運行結果以下：
（3）代碼以下：
public class EmployeeTest
{
public static void main(String[] args)
{
// 用三個employee對象填充staff數組
Employee[] staff = new Employee[3];
staff[0] = new Employee("Carl Cracker", 75000, 1987, 12, 15);
staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
staff[2] = new Employee("Tony Tester", 40000, 1990, 3, 15);
// raise everyone's salary by 5% 給每人漲5%的工資
for (Employee e : staff) //進行foreach循環
e.raiseSalary(5);
// print out information about all Employee objects
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
+ e.getHireDay());
}
}
運行結果以下：
l 參考教材104頁EmployeeTest.java，設計StudentTest.java，定義Student類，包含name（姓名）、sex（性別）、javascore（java成績）三個字段，編寫程序，從鍵盤輸入學生人數，輸入學生信息，並按如下表頭輸出學生信息表：
姓名 性別 java成績
public class StudentTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Student[] staff = new Student[3]; //構造了一個Employee數組，並填入了三個僱員對象
staff[0] = new Student("lulanxi", "female", 99);
staff[1] = new Student("luhaonan", "male", 98);
staff[2] = new Student("luyuxuan", "male", 97);
for (Student e : staff)
System.out.println("name=" + e.getName() + ",sex=" + e.getSex() + ",javascore="
+ e.getJavascore()); //調用getName方法、getSex方法以及getJavascore法將每一個僱員的信息打印出來
}
}
class Student //Employee類
{
private String name; //三個僱員對象的私有實例域
private String sex;
private int javascore;
public Student(String n, String s, int score)
{
name = n;
sex = s;
javascore = score;
}
public String getName()
{
return name;
}
public String getSex()
{
return sex;
}
public int getJavascore()
{
return javascore;
}
}
運行結果以下：
實驗2 測試程序2（5分）
/**
* This program demonstrates static methods.
* @version 1.02 2008-04-10
* @author Cay Horstmann
*/
public class StaticTest
{
public static void main(String[] args)
{
// fill the staff array with three Employee objects
Employee[] staff = new Employee[3]; //構造了一個Employee數組，並填入了三個僱員對象
staff[0] = new Employee("Tom", 40000);
staff[1] = new Employee("Dick", 60000);
staff[2] = new Employee("Harry", 65000);
// print out information about all Employee objects
for (Employee e : staff)
{
e.setId();
System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
+ e.getSalary()); ////調用getName方法、getId方法以及getSalary方法將每一個僱員的信息打印出來
}
int n = Employee.getNextId(); // calls static method 經過類名調用這個方法，只須要訪問類的靜態域
System.out.println("Next available id=" + n); //將其輸出在控制檯上
}
}
class Employee //Employee類
{
private static int nextId = 1; //靜態方法訪問自身的靜態域
private String name; //私有域
private double salary;
private int id;
public Employee(String n, double s)
{
name = n;
salary = s;
id = 0;
}
public String getName()
{
return name;
}
public double getSalary()
{
return salary;
}
public int getId()
{
return id;
}
public void setId()
{
id = nextId; // set id to next available id
nextId++;
}
public static int getNextId()
{
return nextId; // returns static field
}
public static void main(String[] args) // unit test
{
Employee e = new Employee("Harry", 50000);
System.out.println(e.getName() + " " + e.getSalary()); //輸出在控制檯上
}
}
運行結果以下：
實驗2 測試程序3（5分）
/**
* This program demonstrates parameter passing in Java.
* @version 1.01 2018-04-10
* @author Cay Horstmann
*/
public class ParamTest
{
public static void main(String[] args)
{
/*
* Test 1: Methods can't modify numeric parameters
*/
System.out.println("Testing tripleValue:");
double percent = 10; //採用按值調用，而後再調用如下方法
System.out.println("Before: percent=" + percent);
tripleValue(percent);
System.out.println("After: percent=" + percent);
/*
* Test 2: Methods can change the state of object parameters
*/
System.out.println("\nTesting tripleSalary:");
Employee harry = new Employee("Harry", 50000);
System.out.println("Before: salary=" + harry.getSalary());
tripleSalary(harry);
System.out.println("After: salary=" + harry.getSalary());
/*
* Test 3: Methods can't attach new objects to object parameters
*/
System.out.println("\nTesting swap:");
Employee a = new Employee("Alice", 70000); //按引用調用實現交換兩個僱員對象狀態的方法，可是並沒改變存儲在a和b中的對象引用
Employee b = new Employee("Bob", 60000);
System.out.println("Before: a=" + a.getName());
System.out.println("Before: b=" + b.getName());
swap(a, b);
System.out.println("After: a=" + a.getName());
System.out.println("After: b=" + b.getName());
}
public static void tripleValue(double x) // doesn't work
{
x = 3 * x; //假定一個方法，將一個參數的值 增長到三倍，可是percent的值依舊是10
System.out.println("End of method: x=" + x);
}
public static void tripleSalary(Employee x)
// works，對象引用做爲參數，實現一個僱員的薪水提升兩倍的操做，當調用harry = new Employee（。。。）；tripleSalary(harry);實現改變對象參數的方法
{
x.raiseSalary(200);
System.out.println("End of method: salary=" + x.getSalary());
}
public static void swap(Employee x, Employee y) //編寫交換兩個僱員對象狀態的方法
{
Employee temp = x; //swap方法的參數x和y被初始化爲兩個對象引用的拷貝。
x = y;
y = temp;
System.out.println("End of method: x=" + x.getName());
System.out.println("End of method: y=" + y.getName());
}
}
class Employee //simplified Employee class
{
private String name;
private double salary;
public Employee (String n, double s)
{
name = n;
salary = s;
}
public String getName()
{
return name;
}
public double getSalary()
{
return salary;
}
public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}
}
運行結果以下：
實驗2 測試程序4（5分）
import java.util.*;
/**
* This program demonstrates object construction.
* @version 1.02 2018-04-10
* @author Cay Horstmann
*/
public class ConstructorTest {
public static void main(String[] args)
{
// fill the staff array with three Employee objects
Employee staff = new Employee[3]; //構建一個Employee類數組，並定義三個僱員對象
staff[0] = new Employee("Harry", 40000);
staff[1] = new Employee(60000);
staff[2] = new Employee();
// print out information about all Employee objects
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
+ e.getSalary()); //調用getName方法、getId方法以及getSalary方法將每一個僱員的信息打印出來
}
}
class Employee //在執行構造器以前，先執行賦值操做，調用方法對域進行初始化，使每一個僱員有一個id域
{
private static int nextId;
private int id;
private String name = ""; // instance field initialization
private double salary;
// static initialization block
static
{
Employee generator = new Random();
// set nextId to a random number between 0 and 9999
nextId = generator.nextInt(10000);
}
// object initialization block
{
id = nextId;
nextId++;
}
// three overloaded constructors
public Employee(String n, double s) //一般使用單個字符命名參數
{
name = n;
salary = s;
}
public Employee(double s)
{
// calls the Employee(String, double) constructor
this("Employee #" + nextId, s);
}
// the default constructor
public Employee()
{
// name initialized to ""--see above
// salary not explicitly set--initialized to 0
// id initialized in initialization block
}
public String getName()
{
return name;
}
public double getSalary()
{
return salary;
}
public int getId()
{
return id;
}
}
運行結果以下：
實驗2 測試程序5（5分）
實驗4.6代碼
import com.horstmann.corejava.*; //將類放入一個包中，將包的名字放在源文件的開頭，包中定義類的代碼以前
// the Employee class is defined in that package
import static java.lang.System.*;
/**
* This program demonstrates the use of packages.
* @version 1.11 2004-02-19
* @author Cay Horstmann
*/
public class PackageTest
{
public static void main(String[] args)
{
// because of the import statement, we don't have to use
// com.horstmann.corejava.Employee here
Employee harry = new Employee("Harry Hacker", 50000, 1989, 10, 1); //
harry.raiseSalary(5); //按值調用
// because of the static import statement, we don't have to use System.out here
out.println("name=" + harry.getName() + ",salary=" + harry.getSalary()); //將其輸出在控制檯上
}
}
實驗4.6運行結果：
實驗4.7代碼
package com.horstmann.corejava;
// the classes in this file are part of this package
import java.time.*;
// import statements come after the package statement
/**
* @version 1.11 2015-05-08
* @author Cay Horstmann
*/
public class Employee //Employee類放置在com.horstmann.corejava包中
{
private String name;
private double salary;
private LocalDate hireDay;
public Employee(String name, double salary, int year, int month, int day)
{
this.name = name;
this.salary = salary;
hireDay = LocalDate.of(year, month, day);
}
public String getName()
{
return name;
}
public double getSalary()
{
return salary;
}
public LocalDate getHireDay()
{
return hireDay;
}
public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}
}
運行結果以下：
第三部分：實驗總結
經過本週的實驗課，以及老師實行的翻轉課堂教育，對Java的學習有了更深一步得了解，老師佈置的設計題，只能作出來一個，第二個基本思路都不清楚。在課下在助教的視頻講解下，有點進步，這一章主要講解類與對象，包括面向對象程序設計的概述，使用預約義類，用戶自定義類，靜態域與靜態方法，方法參數，對象構造等內容。Java學習已經進行到第四周，可是在代碼的設計上仍是沒有明顯的提高，在課下空餘時間，我會盡力解決不會的問題，在代碼的設計仍是理解方面努力。經過看翁愷老師的視頻講解先把基礎的內容很好的掌握。
- 1. 201871010119-帖佼佼《面向對象程序設計（java）》第十週學習總結
- 2. 201871010119-帖佼佼《面向對象程序設計（java）》第八週學習總結
- 3. 201871010119-帖佼佼《面向對象程序設計（java）》第7周學習總結
- 4. 201871010119-帖佼佼《面向對象程序設計（java）》第一週學習總結
- 5. 201871010119-帖佼佼《面向對象程序設計（java）》第十一週學習總結
- 6. 201871010119-帖佼佼《面向對象程序設計（java）》第六—七週學習總結
- 7. 201871010112-梁麗珍《面向對象程序設計（java）》第四周學習總結
- 8. 徐思201771010132《面向對象程序設計（java）》第十四周學習總結
- 9. 201871010124-王生濤《面向對象程序設計（java）》第四周學習總結
- 10. 201871010121-王方《面向對象程序設計（Java）》第四周學習總結
- 更多相關文章...
- • PHP 面向對象 - PHP教程
- • Lua 面向對象 - Lua 教程
- • 算法總結-歸併排序
- • 使用Rxjava計算圓周率
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 201871010119-帖佼佼《面向對象程序設計（java）》第十週學習總結
- 2. 201871010119-帖佼佼《面向對象程序設計（java）》第八週學習總結
- 3. 201871010119-帖佼佼《面向對象程序設計（java）》第7周學習總結
- 4. 201871010119-帖佼佼《面向對象程序設計（java）》第一週學習總結
- 5. 201871010119-帖佼佼《面向對象程序設計（java）》第十一週學習總結
- 6. 201871010119-帖佼佼《面向對象程序設計（java）》第六—七週學習總結
- 7. 201871010112-梁麗珍《面向對象程序設計（java）》第四周學習總結
- 8. 徐思201771010132《面向對象程序設計（java）》第十四周學習總結
- 9. 201871010124-王生濤《面向對象程序設計（java）》第四周學習總結
- 10. 201871010121-王方《面向對象程序設計（Java）》第四周學習總結