2. 程式人生 > 其它 >Java基礎-11總結Eclipse使用，API,Object類

Java基礎-11總結Eclipse使用，API,Object類

阿新 • • 發佈：2022-05-04
1:Eclipse的概述使用(掌握)

1:Eclipse的安裝

2:用Eclipse寫一個HelloWorld案例，最終在控制檯輸出你的名字

A:建立專案

B:在src目錄下建立包。cn.itcast

C:在cn.itcast包下建立類。HelloWorld

D:在HelloWorld下有一個方法。public static void main(String[] args) {}

E:在main方法中有一個輸出語句。System.out.println("你的名字");

3:Eclipse空間的基本配置

A:程式的編譯和執行的環境配置(一般不改)

window -- Preferences -- Java

編譯環境：Compiler 預設選中的就是最高版本。

執行環境：Installed JREs 預設會找你安裝的那個JDK。建議配置了Java的環境變數。

問題：

低編譯，高執行。可以。

高編譯，低執行。不可以。

建議，編譯和執行的版本一致。

B:如何去掉預設註釋?

window -- Preferences -- Java -- Code Style -- Code Templates

選擇你不想要的內容，通過右邊Edit編輯。

注意：請只刪除註釋部分，不是註釋部分的不要刪除。

C:行號的顯示和隱藏

顯示：在程式碼區域的最左邊的空白區域，右鍵 -- Show Line Numbers即可。

隱藏：把上面的動作再做一次。

D:字型大小及顏色

a:Java程式碼區域的字型大小和顏色：

window -- Preferences -- General -- Appearance -- Colors And Fonts -- Java修改 -- Java Edit Text Font

b:控制檯

window -- Preferences -- General -- Appearance -- Colors And Fonts -- Debug -- Console font

c:其他檔案

window -- Preferences -- General -- Appearance -- Colors And Fonts -- Basic -- Text Font

E:窗體給弄亂了，怎麼辦?

window -- Reset Perspective

F:控制檯找不到了，怎麼辦?

Window--Show View—Console

4:常用快捷鍵

A:格式化 ctrl+shift+f

B:匯入包 ctrl+shift+o

如果該類僅僅在一個包中有，就自己顯示了

如果該類在多個包中有，會彈出一個框框供你選擇

C:註釋

單行：註釋 ctrl+/，取消註釋再來一次。

多行：ctrl+shift+/,ctrl+shift+

D:程式碼上下移動

選中程式碼alt+上/下箭頭

E:檢視原始碼

選中類名(F3或者Ctrl+滑鼠點選)

5:如何提高開發效率

A:自動生成構造方法

a:無參構造方法 在程式碼區域右鍵--source--Generate Constructors from Superclass

b:帶參構造方法 在程式碼區域右鍵--source--Generate Constructors using fields.. -- finish

B:自動生成getXxx()/setXxx()方法

在程式碼區域右鍵--source--Generate Getters and Setters...

提供了對應的快捷鍵操作。

alt+shift+s

按下帶有下劃線的那個字母即可。

C:如何繼承抽象類和實現介面。

D:Override的作用

表示該方法是重寫父類的。如果方法宣告和父類不匹配，就會報錯。

6:通過講解的快捷鍵和提高開發效率的一些內容完成如下內容

自定義學生類:Student

成員變數；

姓名

年齡

構造方法：

無參

帶參

成員方法：

getXxx()/setXxx()

在給出一個show()方法，顯示類的所有成員資訊。

然後，寫一個測試類，對學生的程式碼進行測試。

 StudentDemo
package cn.itcast_01;
public class Student {
 // 姓名
 private String name;
 // 年齡
 private int age;
 public Student(String name, int age) {
 super();
 this.name = name;
 this.age = age;
 }
 public Student() {
 super();
 }
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public int getAge() {
 return age;
 }
 public void setAge(int age) {
 this.age = age;
 }
 public void show() {
 System.out.println("姓名：" + name + ",年齡:" + age);
 }
}
package cn.itcast_01;
/*
 * 測試類
 */
public class StudentDemo {
 public static void main(String[] args) {
 // 建立物件
 Student s1 = new Student();
 s1.setName("風清揚");
 s1.setAge(30);
 System.out.println(s1.getName() + "---" + s1.getAge());
 s1.show();
 // 建立物件
 Student s2 = new Student("林青霞", 27);
 System.out.println(s2.getName() + "---" + s2.getAge());
 s2.show();
 }
}

7:刪除專案和匯入專案

刪除專案

選中專案 – 右鍵 – 刪除

從專案區域中刪除

從硬碟上刪除

匯入專案

在專案區域右鍵找到import

找到General，展開，並找到

Existing Projects into Workspace

點選next,然後選擇你要匯入的專案

注意：這裡選擇的是專案名稱

8:要注意的幾個小問題

如何檢視專案所在路徑

選中 -- 右鍵 -- Properties -- Resource -- Location

匯入專案要注意的問題

專案區域中不可能出現同名的專案(新建或者匯入)

自己隨意建立的資料夾是不能作為專案匯入的

修改專案問題

不要隨意修改專案名稱

如果真要修改，不要忘記了配置檔案.project中的

<name>把這裡改為你改後的名稱</name>

9:大家接收檔案的注意事項

A:專門建立一個資料夾用於接收專案，不要隨意放置。

B:同一個專案再次接收的時候，先去存放目錄把原始專案刪除，然後重新儲存，最後重新整理專案即可。

C:每天對照我寫的專案，自己也建立一個練習專案

舉例：我的專案名稱 day11_eclipse

你就建立一個專案名稱 day11_eclipse_test

10:Eclipse中程式碼的高階(Debug)除錯

作用：

除錯程式

檢視程式執行流程

如何檢視程式執行流程

要想看程式流程，就必須設定斷點。

什麼是斷點：

就是一個標記，從哪裡開始。

如何設定斷點：

你想看哪裡的程式，你就在那個有效程式的左邊雙擊即可。

在哪裡設定斷點：

哪裡不會點哪裡。

目前：我們就在每個方法的第一條有效語句上都加。

如何執行設定斷點後的程式：

右鍵 -- Debug as -- Java Application

看哪些地方：

Debug：斷點測試的地方

在這個地方，記住F6，或者點選也可以。一次看一行的執行過程。

Variables：檢視程式的變數變化

ForDemo：被檢視的原始檔

Console：控制檯

如何去斷點：

a:再次雙擊即可

b:找到Debug檢視，Variables介面，找到Breakpoints，並點選，然後看到所有的斷點，最後點選那個雙叉。

package cn.itcast_03;
/*
 * 通過debug檢視程式執行流程
 * 請大家也做一遍。
 */
public class ArgsDemo {
 public static void main(String[] args) {
 int a = 10;
 int b = 20;
 System.out.println("a:" + a + ",b:" + b);
 change(a, b);
 System.out.println("a:" + a + ",b:" + b);
 int[] arr = { 1, 2, 3, 4, 5 };
 change(arr);
 System.out.println(arr[1]);
 }
 public static void change(int a, int b) {
 System.out.println("a:" + a + ",b:" + b);
 a = b;
 b = a + b;
 System.out.println("a:" + a + ",b:" + b);
 }
 public static void change(int[] arr) {
 for (int x = 0; x < arr.length; x++) {
 if (arr[x] % 2 == 0) {
 arr[x] *= 2;
 }
 }
 }
}
package cn.itcast_03;
public class ForDemo {
 public static void main(String[] args) {
 // 定義求和變數
 int sum = 0;
 for (int x = 1; x < 6; x++) {
 sum += x;
 }
 System.out.println("sum:" + sum);
 }
}

2:API的概述(瞭解)

(1)應用程式程式設計介面。

(2)就是JDK提供給我們的一些提高程式設計效率的java類。

3:Object類(掌握)

(1)Object是類層次結構的根類，所有的類都直接或者間接的繼承自Object類。

(2)Object類的構造方法有一個，並且是無參構造

這其實就是理解當時我們說過，子類構造方法預設訪問父類的構造是無參構造

(3)要掌握的方法：

A:toString()

返回物件的字串表示，預設是由類的全路徑+'@'+雜湊值的十六進位制表示。

這個表示其實是沒有意義的，一般子類都會重寫該方法。

如何重寫呢?過程我也講解過了，基本上就是要求資訊簡單明瞭。

但是最終還是自動生成。

package cn.itcast_02;
public class Student {
 private String name;
 private int age;
 public Student() {
 super();
 }
 public Student(String name, int age) {
 super();
 this.name = name;
 this.age = age;
 }
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public int getAge() {
 return age;
 }
 public void setAge(int age) {
 this.age = age;
 }
 @Override
 public String toString() {
 return "Student [name=" + name + ", age=" + age + "]";
 }
 // @Override
 // public String toString() {
 // // return super.toString();
 // // return "hello";
 // return "姓名:" + name + ",年齡:" + age;
 // }
}
package cn.itcast_02;
/*
 * public String toString():返回該物件的字串表示。
 * 
 * Integer類下的一個靜態方法：
 *  public static String toHexString(int i)：把一個整數轉成一個十六進位制表示的字串
 * 
 * 這個資訊的組成我們講解完畢了，但是這個資訊是沒有任何意義的。所以，建議所有子類都重寫該方法。
 * 怎麼重寫呢?
 *  把該類的所有成員變數值組成返回即可。
 * 重寫的最終版方案就是自動生成toString()方法。
 * 
 * 注意：
 *   直接輸出一個物件的名稱，其實就是呼叫該物件的toString()方法。
 */
public class StudentDemo {
 public static void main(String[] args) {
 Student s = new Student();
 System.out.println(s.hashCode());
 System.out.println(s.getClass().getName());
 System.out.println("--------------------");
 System.out.println(s.toString());// cn.itcast_02.Student@42552c
 System.out.println("--------------------");
 // toString()方法的值等價於它
 // getClass().getName() + '@' + Integer.toHexString(hashCode())
 // this.getClass().getName()+'@'+Integer.toHexString(this.hashCode())
 // cn.itcast_02.Student@42552c
 // cn.itcast_02.Student@42552c
 System.out.println(s.getClass().getName() + '@'
 + Integer.toHexString(s.hashCode()));
 System.out.println(s.toString());
 // 直接輸出物件的名稱
 System.out.println(s);
 }
}

B:equals()

比較兩個物件是否相同。預設情況下，比較的是地址值是否相同。

而比較地址值是沒有意義的，所以，一般子類也會重寫該方法。

重寫過程，我也詳細的講解和分析了。

但是最終還是自動生成。

package cn.itcast_03;
public class Student {
 private String name;
 private int age;
 public Student() {
 super();
 }
 public Student(String name, int age) {
 super();
 this.name = name;
 this.age = age;
 }
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public int getAge() {
 return age;
 }
 public void setAge(int age) {
 this.age = age;
 }
 @Override
 public boolean equals(Object obj) {
 if (this == obj)
 return true;
 if (obj == null)
 return false;
 if (getClass() != obj.getClass())
 return false;
 Student other = (Student) obj;
 if (age != other.age)
 return false;
 if (name == null) {
 if (other.name != null)
 return false;
 } else if (!name.equals(other.name))
 return false;
 return true;
 }
// @Override
// public boolean equals(Object obj) {
// // return true;
// //這裡要改進，根據這裡比較的成員變數來決定返回true還是false
// //這裡其實要比價的就是name和age
// //但是，name是String型別的，而String是引用型別的，所以，在這裡不能直接用==比較，應該用equals()比較
// //String的equals()方法是重寫自Object類的，比較的是字串的內容是否相同
// //this -- s1
// //obj -- s2
// //我們要使用的是學生類的特有成員變數,所以要向下轉型
// Student s = (Student)obj; //s -- obj -- s2;
// if(this.name.equals(s.name) && this.age == s.age) {
// return true;
// }else {
// return false;
// }
// }
// @Override
// public boolean equals(Object obj) {
// //為了提高效率
// if(this == obj){
// return true;
// }
// 
// //為了提供程式的健壯性
// //我先判斷一下，obj是不是學生的一個物件，如果是，再做向下轉型，如果不是，直接返回false。
// //這個時候，我們要判斷的是物件是否是某個類的物件?
// //記住一個格式：物件名 instanceof 類名
// //表示：判斷該物件名是否是該類名一個物件
// if(!(obj instanceof Student)){
// return false;
// }
// //如果是就繼續
// 
// Student s = (Student)obj;
// //System.out.println("同一個物件，還需要向下轉型並比較嗎?");
// return this.name.equals(s.name) && this.age == s.age;
// }
}
package cn.itcast_03;
/*
 * public boolean equals(Object obj):指示其他某個物件是否與此物件“相等”。 
 * 這個方法，預設情況下比較的是地址值。比較地址值一般來說意義不大，所以我們要重寫該方法。
 * 怎麼重寫呢?
 *  一般都是用來比較物件的成員變數值是否相同。
 * 重寫的程式碼優化：提高效率，提高程式的健壯性。
 * 最終版：
 *  其實還是自動生成。
 * 
 * 看原始碼：
 *  public boolean equals(Object obj) {
 *  //this - s1
 *  //obj - s2
 *        return (this == obj);
 *    }
 * 
 * ==:
 *  基本型別：比較的就是值是否相同
 *  引用型別：比較的就是地址值是否相同
 * equals:
 *  引用型別：預設情況下，比較的是地址值。
 *  不過，我們可以根據情況自己重寫該方法。一般重寫都是自動生成，比較物件的成員變數值是否相同
 */
public class StudentDemo {
 public static void main(String[] args) {
 Student s1 = new Student("林青霞", 27);
 Student s2 = new Student("林青霞", 27);
 System.out.println(s1 == s2); // false
 Student s3 = s1;
 System.out.println(s1 == s3);// true
 System.out.println("---------------");
 System.out.println(s1.equals(s2)); // obj = s2; //false
 System.out.println(s1.equals(s1)); // true
 System.out.println(s1.equals(s3)); // true
 Student s4 = new Student("風清揚",30);
 System.out.println(s1.equals(s4)); //false
 Demo d = new Demo();
 System.out.println(s1.equals(d)); //ClassCastException
 }
}
class Demo {}

(4)要了解的方法：

A:hashCode() 返回物件的雜湊值。不是實際地址值，可以理解為地址值。

B:getClass() 返回物件的位元組碼檔案物件，反射中我們會詳細講解

C:finalize() 用於垃圾回收，在不確定的時間

D:clone() 可以實現物件的克隆，包括成員變數的資料複製，但是它和兩個引用指向同一個物件是有區別的。

package cn.itcast_04;
public class Student implements Cloneable {
 private String name;
 private int age;
 public Student() {
 super();
 }
 public Student(String name, int age) {
 super();
 this.name = name;
 this.age = age;
 }
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public int getAge() {
 return age;
 }
 public void setAge(int age) {
 this.age = age;
 }
 @Override
 protected Object clone() throws CloneNotSupportedException {
 return super.clone();
 }
}
package cn.itcast_01;
/*
 * Object:類 Object 是類層次結構的根類。每個類都使用 Object 作為超類。
 * 每個類都直接或者間接的繼承自Object類。
 * 
 * Object類的方法：
 *  public int hashCode():返回該物件的雜湊碼值。
 *  注意：雜湊值是根據雜湊演算法計算出來的一個值，這個值和地址值有關，但是不是實際地址值。
 *             你可以理解為地址值。
 * 
 * public final Class getClass():返回此 Object 的執行時類
 * Class類的方法：
 * public String getName()：以 String 的形式返回此 Class 物件所表示的實體
 */
public class StudentTest {
 public static void main(String[] args) {
 Student s1 = new Student();
 System.out.println(s1.hashCode()); // 11299397
 Student s2 = new Student();
 System.out.println(s2.hashCode());// 24446859
 Student s3 = s1;
 System.out.println(s3.hashCode()); // 11299397
 System.out.println("-----------");
 Student s = new Student();
 Class c = s.getClass();
 String str = c.getName();
 System.out.println(str); // cn.itcast_01.Student
 //鏈式程式設計
 String str2  = s.getClass().getName();
 System.out.println(str2);
 }
}
package cn.itcast_04;
/*
 * protected void finalize()：當垃圾回收器確定不存在對該物件的更多引用時，由物件的垃圾回收器呼叫此方法。用於垃圾回收，但是什麼時候回收不確定。
 * protected Object clone():建立並返回此物件的一個副本。
 * A:重寫該方法
 *
 *  Cloneable:此類實現了 Cloneable 介面，以指示 Object.clone() 方法可以合法地對該類例項進行按欄位複製。 
 *   這個介面是標記介面，告訴我們實現該介面的類就可以實現物件的複製了。
 */
public class StudentDemo {
 public static void main(String[] args) throws CloneNotSupportedException {
 //建立學生物件
 Student s = new Student();
 s.setName("林青霞");
 s.setAge(27);
 //克隆學生物件
 Object obj = s.clone();
 Student s2 = (Student)obj;
 System.out.println("---------");
 System.out.println(s.getName()+"---"+s.getAge());
 System.out.println(s2.getName()+"---"+s2.getAge());
 //以前的做法
 Student s3 = s;
 System.out.println(s3.getName()+"---"+s3.getAge());
 System.out.println("---------");
 //其實是有區別的
 s3.setName("劉意");
 s3.setAge(30);
 System.out.println(s.getName()+"---"+s.getAge());
 System.out.println(s2.getName()+"---"+s2.getAge());
 System.out.println(s3.getName()+"---"+s3.getAge());
 }
}

(5)兩個注意問題；

A:直接輸出一個物件名稱，其實預設呼叫了該物件的toString()方法。

B:面試題

==和equals()的區別?

A:==

基本型別：比較的是值是否相同

引用型別：比較的是地址值是否相同

B:equals()

只能比較引用型別。預設情況下，比較的是地址值是否相同。

但是，我們可以根據自己的需要重寫該方法。

相關推薦

Java基礎-11總結Eclipse使用，API,Object類

1:Eclipse的概述使用(掌握) 1:Eclipse的安裝 2:用Eclipse寫一個HelloWorld案例，最終在控制檯輸出你的名字

java基礎知識總結 超詳細

1，JDK：Java Development Kit，java的開發和執行環境，java的開發工具和jre。 2，JRE：Java Runtime Environment，java程式的執行環境，java執行的所需的類庫+JVM(java虛擬機器)。

Java基礎11 Java集合之ArrayList原始碼解析

  從上篇Java集合的初步認識文章中，我們瞭解到 Collection 是Java集合的一大鼻祖，Collection 介面中定義了集合類的基本操作方法。在瞭解ArrayList之前，我們先來看看它的祖先Collection。

Python基礎11 List插入，刪除，替換和其他常用方法 insert() remove() pop() reverse() copy() clear() index() count()

insert() remove() pop() reverse() copy() clear() index() count() 1 #list 列表 2 3 #插入元素 4 #和追加元素不同的是，追加是追加在列表的最後一位

java基礎知識總結（續寫）

1、兩個容易搞混的C盤資料夾 2、常用基礎DOS命令（Windows+R開啟命令） 3、Java語言的三大組成塊

Java基礎知識總結

1.說說&和&&的區別。 &和&&都可以用作邏輯與的運算子，表示邏輯與（and），當運算子兩邊的表示式的結果都 為 true 時，整個運算結果才為 true，否則，只要有一方為 false，則結果為

java基礎語法(自學筆記，邊學邊更新，自用）

技術標籤：javajava 目錄 Hello world資料型別識別符號修飾符變數關鍵字參考： Hello world

java基礎知識總結（四）——控制語句、方法、以及遞迴

條件結構 　　1、if單分支結構 　　　　語法結構: 　　　　　　if(布林表示式){

java基礎_==與equals，try catch finally return ，裝箱與拆箱, 字串

一：==和equals區別 在初學Java時，可能會經常碰到下面的程式碼： 1 String str1 = new String(\"hello\");

java基礎06：變數，常量，作用域

目錄變數注意事項：變數作用域：類變數例項變數區域性變數常量;變數的命名規範

1.程式碼隨想錄-java基礎核心總結

1.java是一門靜態語言，靜態語言指的是在編譯期間就能夠制度資料型別的語言，在執行前就能夠堅持型別的正確性，一旦型別確定後就不能再更改

java基礎語法總結

java基礎語法 1.註釋、識別符號、關鍵字 2.資料型別 3.型別轉換 4.變數、常量 5.運算子

Java基礎01：註釋，識別符號，關鍵字

註釋，識別符號，關鍵字 資料型別 型別轉換 變數，常量 運算子 包機制，JavaDoc 開啟IDEA-->Empty Project

Java基礎04：變數，常量，作用域

變數 變數：是可以變化的量 一個空間，位置是確定的，裡面的東西不確定 Java是強型別語言，每個變數都必須宣告其型別

Java基礎11：包機制

## 包機制 * 為了更好地組織類，Java提供了包機制，用於區別類名的名稱空間。

Java基礎回顧：HashMap，HashTable，ConcurrentHashMap

1. java.util.HashMap jdk1.7 陣列 + 連結串列 jdk1.8 陣列 + 連結串列/紅黑樹 類圖 類繼承AbstraMap類，實現介面：Map，Clonable，Serializable

Java基礎回顧：String，StringBuilder，StringBuffer

個人筆記，網上資料以及通過原始碼總結，侵刪 1. String jdk1.8 使用char[] jdk11 使用byte[]

Java基礎學習總結

Java入門知識 一、Java的三大版本 JavaSE 標準版（桌面應用，控制檯開發...）--->基礎

Java 基礎 (IO 物件流，隨機儲存檔案流)

IO 物件流 ObjectInputStream 和 OjbectOutputSteam 用於儲存和讀取基本資料型別資料或物件的處理流。它的強大之處就是可以把Java中的物件寫入到資料來源中，也能把物件從資料來源中還原回來。

Java基礎-22總結登入註冊IO版,資料操作流,記憶體操作流,列印流,標準輸入輸出流,

1:登入註冊IO版本案例(掌握) 要求，對著寫一遍。 cn.itcast.pojo User cn.itcast.dao UserDao