到目前為止，Java被用於開發許多應用程序，如移動和基於web的應用程序、企業應用程序、大數據技術等。多年來，Java取得了顯著的發展，並擁有光明的未來。廢話不多說，讓我們從Java教程開始。
- Java是什麼?
- Java的曆史
- Java的特性
- 應用程序的Java
- JDK、JRE和JVM的區別
- 安裝Java
- 在Windows環境下設置Java JDK環境路徑
- Java Hello World程序
- 變量
- 運營商在Java中
- Java中的原始數據類型
- 條件語句
- 循環
- Java中的分支語句
- 評論
- Java類
- 對象
- 構造函數在Java中
- 超級
- 這
- Java靜態關鍵字
- 在Java中繼承
- Java中的方法重載
- Java中的方法重寫
- Java中的抽象類
- 在Java接口
- Java中的異常處理
- 字符串
- 包
- 訪問修飾符
- 鏈表
Java是什麼?
Java是一種高級的、健壯的、麵向對象的編程語言，最初是由Sun Microsystems(現在是Oracle的子公司)在1995年開發的。
它遵循的原則是WORA(編寫一次，隨處運行)——在java程序編譯後，您可以在java支持的平台上運行任意次數的java程序。不需要重新編譯。
平台是可以運行程序的任何硬件或軟件環境。Java被稱為平台，因為它有一個運行時環境(JRE)和API。
你也可以學習免費證書的印地語Java編程課程
Java的曆史
- 1991年:Java首次為數字有線電視行業設計
- 它最初被稱為綠隊。它是由詹姆斯·高斯林和他的團隊成員邁克·謝裏丹和帕特裏克·諾頓設計的
- 後來，它根據詹姆斯·高斯林辦公室外的橡樹樹更名為橡樹
- 1995年:根據球隊以前喝咖啡的印尼島嶼，Oak更名為爪哇島
- Java被《時代》雜誌評為“1995年十大最佳產品”之一。
- 1996年:JDK 1.0發布
讓我們進入本Java教程的下一個主題，討論Java的特性和應用程序。
Java的特性
- 簡單:它非常容易學習，因為語法類似於以前存在的語言，如C和c++。它去掉了複雜且很少使用的特性，如顯式指針、操作符重載等。
- 麵向對象的: Java是基於模擬現實世界問題的對象。它支持麵向對象語言的四個支柱，即繼承、多態性、抽象和封裝。
- 平台無關的:它有自己的虛擬機，並將代碼轉換為字節碼，可以在Java支持的平台上運行。
- 可移植性:由於Java是平台獨立的，所以在一個平台上編寫的任何Java字節碼都可以輕鬆地攜帶到另一個平台上。
- 擔保: Java要安全得多，因為它有自己的盒子負責處理它的執行。它不支持指針和多重繼承，這可能導致歧義或導致程序崩潰。
- 健壯的:Java是健壯的，這意味著強大，因為它具有強大的內存管理、自動垃圾收集、異常處理和類型檢查機製。
- 效率它的效率要高得多，因為它使用了JIT(即時)編譯器，基本上利用了兩個世界的優點，即編譯器和解釋器。
- 分布:Java幫助我們使用RMI(遠程方法調用)和EJB(企業Java bean)創建分布式應用程序。使用這些Java特性，您可以通過從web上的任何機器調用這些方法來訪問文件。Internet Explorer是分布式應用程序的一個例子。
- 多線程: Java支持線程，它基本上允許多個任務並發執行而不占用太多內存。
- 動態:Java是一種支持動態加載類的動態語言。使用Java，您可以適應支持動態內存分配的不斷發展的環境，減少內存浪費並提高應用程序的性能。
應用程序的Java
據Sun Microsystems公司稱，目前有許多設備運行Java。以下是一些例子:
- 桌麵應用程序:acrobatreader, Media Player, Antivirus等。
- Web應用程序:JSP、Spring、Hibernate、Servlet、Struts等。
- 移動應用程序:Android, Java ME, Kotlin等。
- 企業應用程序:銀行應用程序。EJB用於創建這些應用程序。
- 大數據技術:Hadoop
- 測試:硒
- 科學應用:MATLAB
- 遊戲應用程序:2 d和3 d
- 嵌入式係統
- 機器人
這樣的例子不勝枚舉。目前有許多應用程序在Java上運行。Java後來成為當今世界廣泛使用的編程語言之一。上工作基於Java的項目也會幫助你理解Java的應用。
現在，讓我們進入實際內容，從在係統上安裝Java的過程開始。
JDK、JRE和JVM的區別
- JVM: Java虛擬機
- 這是一個虛擬(抽象)機，保存所有java執行
- 它在現實中並不存在。
- 它還管理堆內存、垃圾收集器等。
- JRE: Java運行時環境
- 它負責運行預編譯的java程序
- 它包含所有文件和庫，以促進java代碼的運行
- 這對正在開發中的公司沒有幫助。
- JDK: Java開發工具包
- 這是一個幫助開發Java應用程序的軟件。
- 它基本上是JRE+開發工具
安裝Java
現在您已經對Java有了基本的了解，讓我們繼續在您的係統中安裝Java。
步驟1:您需要安裝Java JDK第一。打開網頁瀏覽器的搜索引擎，在搜索欄中輸入“Java JDK下載”。接下來，從Oracle單擊“Java SE Downloads”鏈接，如下所示。
為了更容易訪問，請單擊此Java JDK下載鏈接下載。
您將被重定向到Java SE下載的官方網頁。
步驟2:下一步，點擊“JDK下載”鏈接，下載Java SE Development Kit。
您將被重定向到以下頁麵:
步驟3:正如您在上麵的圖像中所看到的，最新的Java SE版本是16。現在，向下滾動到各種平台的下載鏈接。有Linux、macOS和Windows。選擇您當前使用的平台。我使用Windows，我將演示如何在Windows平台上設置Java。
如上圖紅色突出顯示的，點擊“Windows x64安裝程序”下載按鈕，下載Java JDK for Windows。接受許可協議，您的文件將被下載。
步驟4:下載完軟件後，打開文件運行安裝程序。將出現一個安裝向導窗口。選擇“Next”以進一步進入安裝過程。
步驟5:現在，您將被要求選擇安裝軟件的目標文件夾。如果你不想改變位置，你可以簡單地點擊“下一步”按鈕。如果您希望更改，隻需點擊“更改”按鈕並選擇您想要的位置。我建議不要更改，因為您需要為Java設置一個環境路徑變量，我將在下一節的後麵解釋這一點。
Java將安裝在您的計算機上。安裝完成後，最終的窗口將出現如下所示:
在Windows環境下設置Java JDK環境路徑
設置JAVA環境路徑變量將在您的係統上全局安裝JAVA，您可以在計算機或係統的任何地方使用JAVA程序。
步驟1:打開“控製麵板”，點擊:係統和安全>係統>高級係統設置。屏幕上會彈出一個窗口，如下圖所示:
步驟2:在“係統變量”下，選擇“路徑”，然後點擊“編輯”按鈕。
步驟3:接下來，點擊' New '按鈕添加Java JDK的bin路徑，如下所示:
步驟4:現在，打開安裝JDK的文件夾，並打開“bin”文件夾。
複製上麵的路徑並粘貼到path變量中，點擊“OK”，如下圖所示:
步驟5:之後，在“係統變量”下，點擊“新建”，添加以下路徑:
現在，點擊“OK”按鈕。已創建Java Home路徑。現在，單擊“OK”按鈕，Java JDK路徑就成功完成了。
現在可以跨係統執行Java程序。要驗證Java是否成功安裝，打開命令提示符並輸入以下命令:
java - version
您將在命令提示符中得到Java版本信息，如下所示:
Java Hello World程序
公共類MyFirstCode{公共靜態void main (String[] args){//打印到控製台System.out。println(“Hello World !”);}}- 凡是加粗的都是關鍵詞，都是一些有固定含義的詞
- ' Class '用於在Java中聲明類
- ' Public '是一個訪問修飾符，允許所有人可見
- ' Static '不需要調用object，而JVM調用main
- ' Void '表示函數不會返回任何東西
現在，既然我們對代碼有了一定的了解，下麵是運行代碼的步驟:
- 設置好環境後，打開cmd
- 要編譯，輸入javac MyFirstCode.java
- 要運行，輸入java MyFirstCode
這將打印您的輸出:Hello World!
變量
- 變量是存儲數據的內存位置的名稱。
- 語法:數據類型varname = val;
例子：
公共類VariableDemo{公共靜態void main (String[] args) {//var聲明和初始化int roll_num=23;字符串first_name =“亞當”;//隻是聲明int標記;/ /後初始化標誌= 89;system . out。println("Hi I am "+first_name+" roll_no "+roll_num+" and I scores "+marks);}}輸出：
嗨，我是亞當·羅爾，23號，我得了89分
命名約定
- 變量名應該以字母、$或下劃線(_)開頭
- 第一個字符之後可以跟字母或數字的任何組合
- 變量名不能與任何關鍵字相同，因為它們是為了特殊目的而保留的
- 變量名區分大小寫
- 例如:valid- apple， _name， $address1
- 例如:無效- 123apple， *roll， @email
有3種變量類型年代在Java中
實例變量
- 在任何方法之外但在類內部聲明的變量
- 是否可以被類的所有方法訪問而不考慮其訪問說明符
- 類的每個對象都獲得自己的variable的原始副本
靜態變量
- 也稱為類變量
- 變量聲明為靜態，在內存中維護一個副本，並由類的所有對象共享
- 可以使用類名classname.var_name直接調用它們
- 非靜態方法不能訪問或操作靜態變量
局部變量
- 在方法中定義的變量屬於這一類。
- 它們可以在聲明它的作用域中訪問。
- 它們隱藏在方法之外。
例子:
//實例變量static int j=200;//靜態變量void方法(){int k=300;//本地變量}}}運營商
一元操作符
- 它需要一個操作數
- 我們有兩個主要的運算符，即自增和自減，每個都有後綴和前綴的兩種變體
- 增量—取值增加1
- 後綴:先賦值，再遞增
- 前綴:先增加後賦值
- 減量—將該值減去1
- 後綴:先賦值再減值
- 前綴:先減後賦值
例子:
公共類UnaryDemo{公共靜態void main (String[] args) {int a,b,c,d;a = b = c = d = 5;+ +;+ + b;c——;——d;system . out。println (" = " +);system . out。println (" b = " + b); System.out.println("c= "+c); System.out.println("d= "+d); } }輸出：
b= 6 c= 4 d= 4
算術運算符
- 它包括所有的二進製算術運算，如加、減、乘、除等。
- 另一個加法運算符是模數(%)，它給出餘數。
例子:
公共類arithmathematico{公共靜態void main (String[] args) {int a,b,c,d;= 6 + 5;b = 6;c = 6 * 5;d = 6/5;system . out。println (" = " +);system . out。println (" b = " + b);system . out。println("c= "+c); System.out.println("d= "+d); } }輸出:
b= 1 c= 30 d= 1
運營商轉變
- 兩種變化-左移和右移
- 左移:對指定值左移位
- 正確的轉變:對指定值向正確方向移動位
例子:
公共類ShiftDemo{公共靜態void main (String[] args) {int a,b;a = b = 8;< < = 2;b > > = 2;system . out。println (" = " +);system . out。println (" b = " + b);}}輸出:
A = 32 b= 2
關係運算符
- 它包含用於比較的運算符
- 有檢查不等式的運算符，例如<，>，<=，>=
- 對於相等檢查，我們有兩個操作符，即==和!=
例子:
公共類RelationalDemo{公共靜態void main (String[] args) {int a,b,c;= 1;b = 2;c = 1;system . out。println(“< < b”+ (b));system . out。println(“> b”+ (> b));system . out。println(“< = b”+ (< = b)); System.out.println("a>=c "+ (a>=c)); System.out.println("a!=b "+ (a!=b)); System.out.println("a==c "+ (a==c)); } }輸出:
Ab假A <=b真A >=c真A !=b真a==c真
按位運算符
它是通過一點一點計算的。無論第一個表達式的計算結果是什麼，兩邊都被檢查。四種主要的位運算符是:
- ＆-位和，如果兩個位都為1，則返回1，否則為0。
- |-位或，如果其中一個位為1，則返回1，否則為0。
- ＾-位xor，如果兩個位不相同則返回1，否則返回0。
- ～-位不，這將改變1為0，反之亦然。
例子:
公共類BitwiseDemo{公共靜態void main (String[] args) {int a,b;= 1;b = 2;system . out。Println ("a&b = "+ (a&b));system . out。Println ("a|b = "+ (a|b));system . out。Println ("a^b = "+ (a^b));system . out。println("~a = "+ (~a)); } }輸出:
a^b = 3 ~a = -2
邏輯運算符
它們用於條件比較，基本上檢查它們的有效性。它們還在循環中用作終止條件的一部分。如果第一個條件足以給出最終判定，它就不會對第二個條件進行評估。
有3個邏輯運算符:
- & &- logical AND，當兩個條件都為true時返回true
- ||- logical OR，當其中一個條件的值為true時返回true
- ！-邏輯不，當條件計算結果為false時返回true
例子:
公共類LogicalDemo{公共靜態void main (String[] args) {int a,b;= 1;b = 2;system . out。Println ("a==1 && b==1 "+ (a==1 && b==1));system . out。Println ("a==1 || b==1 "+ (a==1 || b==1));System.out.println(”!“+ ! (= = 1));}}輸出:
A ==1 && b==1假A ==1 || b==1真
賦值運算符
賦值運算符(=)用於將右邊的值賦給左邊的變量。
三元操作符(?)
if-else的替代形式。Condition放在' ?'如果求值為true，則執行冒號的LHS，否則執行冒號的RHS。
例子:
公共類MiscDemo{公共靜態void main (String[] args) {int a;/ /賦值運算符= 1;System.out.println(“(= = 1 ?\"expression is true\":\"expression is false\" = \n "+ (a==1?"expression is true":"expression is false"));}}輸出:
(= = 1 ?"expression is true":"expression is false" = expression is true
Java中的原始數據類型
人們在現實生活中要處理不同類型的數據。為了處理它們，我們需要不同類型的容器或數據類型作為存儲。在java中，有8個原始數據類型:
- 字節- size為1字節，默認值為0
- int- size為4字節，默認值為0
- 短- size為2字節，默認值為0
- 長- size為8字節，默認為0L
- 字符size為2字節，默認值為' \u0000 '
- 布爾- size為1位，默認為false
- 浮動- size為4字節，默認為0.;f
- 雙- size為8字節，默認為0.0d
也有一些非基元數據類型，如數組，類，如字符串等。
條件語句
if - else
if-else語句由if和else兩個關鍵字組成。這是一種根據條件有兩條可能路徑的方法。例如，' if '條件操作為true，那麼它將被執行，否則代碼' else '將被執行。你可以用多個else if，後麵跟著else if，如果有更多可能的路徑。同樣，嵌套的if和else也是可能的。
控製流圖:
例子：
公共類IfElseDemo{公共靜態void main (String[] args) {int a=5,b=6;如果(a + b = = 11) System.out.println(“平等”);其他的system . out。println(“不平等”);}}輸出:
真正的
開關
這是替換多個else-if的一種優雅方式
語法：
開關(表達式){case val:…；打破;案例val:……；打破;案例val:……；打破;默認值:……; }在這裏，根據條件求值的結果，執行case代碼。每個case後麵都必須有break，除非邏輯要求不這樣做。否則，所有用例將從匹配的用例開始執行，直到遇到中斷或耗盡所有用例。
' default '是可選的，它保存在沒有匹配捕獲時應該執行的代碼。
' val '在java中可以是整數、char或String。
例子：
public class SwitchDemo {public static void main (String[] args) {String day="sun";switch(day) {case "mon": System.out。println(“今天是星期一”);打破;例“麵前”:system . out。println(今天是星期二);打破;“結婚”:system . out。println(“今天是星期三”);打破;例“碰頭”:system . out。println("Today is thursday"); break; case "fri": System.out.println("Today is friday"); break; case "sat": System.out.println("Today is saturday"); break; case "sun": System.out.println("Today is sunday"); break; default : System.out.println("day is invalid!"); } } }輸出:
今天是星期天
循環
三個主要的循環是for, while和do while
java for循環:
最好在知道代碼應該執行的指定次數時使用。
語法：
(初始化;終止;升級){}- ' initialization '用於初始化被用於迭代的變量。
- “終止”——包含確定迭代何時繼續的條件。
- ' update ' -我們的變量將如何更新。
例子：
public class ForDemo {public static void main (String[] args) {for(int i=0;i<5;i++)Println (" I的當前值:"+ I);}}輸出:
I當前值:0 I當前值:1 I當前值:2 I當前值:3 I當前值:4
while循環java
當我們知道指定的表達式時最好使用它，該表達式取決於代碼應該執行的值。
語法：
While(表達式){}' expression '用於指定負責循環繼續的條件。
例子：
公共類WhileDemo{公共靜態void main (String[] args) {int i=0;雖然(我< 5){system . out。Println (" I的當前值:"+ I);我+ +;}}}輸出:
I當前值:0 I當前值:1 I當前值:2 I當前值:3 I當前值:4
Do-while循環
當我們知道無論條件如何，至少代碼必須執行一次時，最好使用它。
語法：
Do {}while(表達式);' expression '用於指定負責循環繼續的條件。
例子：
公共類DoWhileDemo{公共靜態void main (String[] args) {int i=0;{system . out。Println (" I的當前值:"+ I);我+ +;},(我< 5);}}輸出:
I當前值:0 I當前值:1 I當前值:2 I當前值:3 I當前值:4
Java中的分支語句
打破
它是一個關鍵字，基本上終止當前循環並將執行移出循環
為 (.........){ 打破;} ==>執行在遇到中斷時到達這裏例子:
公共類BreakDemo{公共靜態void main (String[] args) {int i=0;雖然(我< 5){system . out。Println (" I的當前值:"+ I);我+ +;如果(我= = 3)休息;} system . out。println(“循環!”);}}輸出:
i的當前值:0 i的當前值:1 i的當前值:2 Out of loop!
繼續
它是一個關鍵字，基本上終止當前迭代並將執行移動到循環的更新部分。在' while '和' do-while '中，當遇到continue時，它將忽略其餘代碼
(. .；．．．．；…)==>在遇到break時執行到這裏{continue;｝例子：
public class ContinueDemo {public static void main (String[] args) {for(int i=0;i<5;i++){if(i==3) continue;system . out。Println (" I的當前值:"+ I);} system . out。println(“循環!”);}}輸出:
i的當前值:0 i的當前值:1 i的當前值:2 i的當前值:4跳出循環!
返回
它從它的代碼塊中返回，也就是說，如果它在函數中，它將從函數中退出。
主要 (.........){ 返回;} ==>存在於程序中例子:
public class ReturnDemo {public static void main (String[] args) {for(int i=0;i<5;i++){if(i==3) return;system . out。Println (" I的當前值:"+ I);} system . out。println(“循環!”);}}輸出:
I當前值:0 I當前值:1 I當前值:2
評論
注釋用於對代碼背後的邏輯進行簡要描述。它們隻是在執行時被編譯器忽略。
在java中，我們有單行注釋和多行注釋:
// -單行和/* ....．．．．*/ -多行
Java類
它是一個現實生活實體的藍圖，由數據和方法組成。基本上，它是封裝的實現，封裝是OOPs的支柱之一。
關鍵字class用於在java中聲明類。根據命名約定，類名遵循每個單詞的第一個字母都應該是大寫的。此外，所有代碼必須在某個類中，單個文檔可以有多個類，但隻能有一個公共類
例子：
類容器{//數據成員int權重;字符串的顏色;兩倍價格;//方法void setWeight(int w){weight=w;} void setColor(int c){color=c;}無效setPrice(int p){價格=p;}無效打印(){係統。println(重量+ " " +顏色+ " " +價格);}}對象
它基本上是類的物理實體，類的實例。new關鍵字用於創建對象和在Heap中分配內存。創建對象時，它調用類的構造函數。
例子：
c1 =新容器容器();構造函數在Java中
構造函數是一個特殊的方法，用於分配內存和初始化對象。它沒有任何返回類型，它的名稱與類名相同。如果沒有顯式定義構造函數，編譯器隱式地提供一個默認構造函數來分配內存。
具有參數的構造函數被歸類為參數化構造函數。當遇到new時，它調用構造函數。在創建對象時傳遞的參數決定了應該調用哪個構造函數。
例子:
類容器{int權重;字符串的顏色;兩倍價格;//參數化構造函數Container(int w,String c,double p) {weight=w;顏色= c;價格= p;system . out。println(“我是一個參數化的構造函數”);} //默認構造函數Container() {System.out.println(“我是一個默認構造函數”);}無效打印(){係統。println(weight+" "+color+" "+price); } } public class ConstructorDemo { public static void main (String[] args) { Container c1=new Container(); Container c2=new Container(10,"red",567.85); c1.print(); c2.print(); } }輸出:
我是一個默認構造函數，我是一個參數化構造函數0 null 0.0 10 red 567.85
超級
' Super '通常與父類相關。它擴展了用於建立父子關係的繼承的關鍵字。可以使用super調用父方法、數據成員和構造函數。當使用super調用父類的構造函數時，它應該在代碼塊的第一行
這
' This '通常與當前類相關。您可以使用此函數調用當前類方法、數據成員和構造函數。當使用它調用當前類構造函數時，它應該在代碼塊的第一行。
例子:
//父類類招待所{字符串地址;字符串名稱;//參數化的構造函數來初始化add和name Hostel(String address,String name){/*使用此參數指向酒店的地址和名稱，如果沒有此參數，則參數將賦值給本地var，而類var仍然具有默認值。* / this.address =地址;this.name =名稱;} //初始化參數化的構造函數名稱招待所(字符串名稱){this.name=name;} //打印地址的方法void printAddress(){System.out.}println(地址:+地址);}} //兒童班級班級房間延伸宿舍{int號;字符串名稱;Room(String地址，String名稱，int number){super(name); //calling parent's constructor this.address=address; this.name=name; this.number=number; } //method to print all details of room void printRoomDetails(){ System.out.println("name : "+name); super.printAddress(); System.out.println("room no. : "+number); } } class Demo { public static void main (String[] args) { Room r1=new Room("12th street,NY","CS Block ",43); r1.printRoomDetails(); } }輸出:
姓名:CS街區地址:紐約第12街房間號。: 43
Java靜態關鍵字
關鍵字
關鍵字也稱為保留字，表示預定義的動作。關鍵詞主要用於一些內部流程。我們不能使用關鍵字作為對象和變量名。在這種情況下，如果使用關鍵字作為對象或變量名，將會得到編譯時錯誤。關鍵字有很多種類型。我們將在這個博客中看到靜態關鍵詞。
靜態關鍵字
靜態關鍵字是關鍵字的一種類型。靜態關鍵字表示屬於特定類型本身的成員，而不是屬於該類型的實例。
這意味著為靜態成員創建一個實例，並用於類的所有實例。
可以為方法、變量、塊以及嵌套類創建關鍵字。
靜態變量
- 如果任何變量被用作靜態變量，那麼該變量被稱為靜態變量。
- 如果使用任何變量來指示對象的公共屬性，那麼該變量就是靜態變量。
- 例如:國家代表人口，城市代表客戶，等等。
- 它主要用於管理內存。
- 當變量獨立且對所有對象通用時，使用該變量。
點需要注意
- 類包含靜態變量;因此，使用可以訪問它的類名不需要對象的引用。
- 在類級別，可以聲明靜態變量。
- 它不需要任何對象初始化來訪問。
語法
靜態data_type variable_name;
靜態變量關鍵字的示例
類編號{static int count=0;公共無效增量(){count++;} public static void main(String args[]) {numbers obj1=new numbers();methoda =新號碼();obj1.increment ();obj2.increment ();system . out。println(其中Obj1:數= " + obj1.count);system . out。println(“methoda:數= " + obj2.count); } }輸出
其中Obj1:數= 2
methoda:數= 2
如上圖所示，兩個對象都包含相同的變量對象。
靜態方法
- 我們可以為方法使用靜態關鍵字來使用靜態方法這樣的方法。
- 我們可以對類使用靜態方法，而不是對類中的對象。
- 靜態方法可以使用靜態數據成員，並可以更改靜態數據成員的值。
- 不需要創建類的實例，就可以創建靜態方法
- 靜態方法的主要優點是它不需要對象。
點需要注意:
- 我們不能覆蓋靜態方法，因為它是在運行時編譯的。
- 我們不能把抽象的方法變成靜態的。
- 它不使用超級鍵。
- 靜態方法需要對象的引用才能直接訪問實例變量和方法。
- 它可以訪問所有靜態變量，也可以訪問其他靜態方法。
語法
<類名稱>。<方法名稱>
靜態方法實例
公共類mall{公共靜態void main(String args[]){客戶c1 =新客戶();c1.showData ();客戶c2 =新客戶();c2.showData ();/ / customer.b + +;/ / c1.showData ();}}類Customer {int a;//初始化為零靜態int b;//隻有當class被加載時才初始化為零，而不是為每個創建的對象。Customer(){//構造函數遞增靜態變量b b++; } public void showData(){ System.out.println("Value of a = "+a); System.out.println("Value of b = "+b); } //public static void increment(){ //a++; //} }靜態塊
- 要初始化靜態數據成員，使用靜態塊。
- 在裝載類時，它在主方法之前執行。
- 靜態塊隻是類內部的語句塊。
- 如果靜態塊的初始化是一個錯誤，則需要異常處理。
指出,記住:
- 單個類可以包含多個靜態塊。
- 靜態變量和靜態塊應該保持它們在類中出現的相同順序。
靜態塊的示例
公共類號{static int i;靜態int j;//靜態塊靜態{I = 50;j = 100;} public static void main(String args[]) {system.out.}println(“靜態初始化塊”);system . out。println(" i的值= " + i);system . out。println("Value of j = " + j);}}靜態類
如果一個類隻是嵌套類，那麼我們可以將它轉換為靜態類。它不需要外部類引用。因此，外部類的非靜態成員不能被靜態類訪問。
點需要注意:
- 靜態類可以通過引用對象來訪問。
- 我們不能將頂層類用作靜態類;因此，隻有嵌套類才能轉換為靜態類。
靜態類的示例
// Java程序演示如何//實現Java程序中的靜態類OuterClass {private static String msg = "Great Learning";beplay2018官网//靜態嵌套類公共靜態類NestedClass{//隻有外層類的靜態成員//可以直接訪問嵌套//靜態類公共void print(){//嚐試將'message'作為非靜態//變量，將會出現編譯錯誤System.out。println("來自嵌套靜態類的消息:" + msg);}}在Java中繼承
OOPs非常重要的支柱之一，它促進了代碼的可重用性，因為子代碼可以從父代碼繼承。Child還可以實現它自己的附加數據成員或方法。這是孩子和父母之間的is - a關係。
示例:我們在上麵的Room(子)繼承自Hostel(父)的示例中這樣做了。
java支持4種類型的繼承:
由於可能造成的模糊性，Java不假定經典的多重繼承。但是可以通過接口進行多重繼承。
Java中的方法重載
這基本上是一個編譯時多態性。可以有多個具有相同名稱但不同形參列表的方法，形參列表的類型或實參數量可能不同
僅僅通過改變方法的返回類型，' Method '不能被重載。它為程序員提供了便利，並有助於理解代碼
例子：
public class OverloadingDemo {int multiply(int a,int b){return a*b;} //帶有3個參數的重載乘法int乘法(int a,int b,int c){返回a*b*c;} //帶有兩個不同類型參數的重載乘法雙乘法(int a,double b){返回a*b;} public static void main (String[] args) {OverloadingDemo ob=new OverloadingDemo();System.out.println (ob.multiply(3、5));System.out.println (ob.multiply(3、5、3));System.out.println (ob.multiply(3、5.5));}}輸出:
15 45 16.5
Java中的方法重寫
這就是運行時多態性。在這裏，如果一個子類想要覆蓋父類的方法，例如，想要給出自己的實現，那麼它可以通過擁有與其實現完全相同的簽名來實現。
例子:
類Parent{void interests () {System.out. class。println(“讀書”);}}類Child擴展了Parent{//與Parent相同的方法但不同的實現void interests () {System.out.println(" traveling ");}}類OverridingDemo{公共靜態void main (String[] args){子ob=新子();ob.hobbies ();}}輸出:
旅行
Java中的抽象類
如果一個方法沒有它的實現，那麼它被稱為“抽象”方法。具有1個或多個抽象方法的類稱為抽象類。它實際上在一定程度上實現了OOPs抽象
Abstract關鍵字用於聲明抽象類。抽象類可以有抽象和非抽象方法，而且它不能被實例化。
相反，它必須被擴展，抽象方法必須被賦予它們的實現。
例子：
抽象類鍵盤{抽象void working();無效的名字(){system . out。println(“這是鍵盤組件”);}}類Hp擴展了Keyboard{//實現了抽象方法void working(){System.out. php。println(“這是hp鍵盤”);}}公共類AbstractClassDemo{公共靜態void main (String[] args) {Hp ob=new Hp();ob.working ();ob.name ();}}輸出:
這是惠普鍵盤，這是鍵盤組件
在Java接口
它強製100%的抽象。這裏所有的方法默認都是抽象的，因此在聲明它們的時候沒有必要寫抽象關鍵字
例子：
接口玩具{void start();空運行();}類Car實現了Toy{公共無效start(){System.out。println(“汽車開始”);}公共無效運行(){係統。println(“汽車運行”);}}類InterfaceDemo{公共靜態void main (String[] args) {Car ob=new Car();ob.start ();ob.run ();}}輸出:
汽車啟動汽車運行
編譯器隱式地在接口的每個方法前麵添加一個公共抽象
T:\>javap Toy編譯自“GFG.java”接口玩具{公共抽象void start();公共抽象空間運行();- Implements關鍵字由想要使用它的類使用，並且必須為每個方法給出定義
- 在實現接口方法時，必須指定公共訪問修飾符
- 一個類可以實現多個接口，這些接口支持某種類型的多重繼承
Java中的異常處理
異常是在運行時可能發生的異常情況，它會擾亂程序的正常流程。因此，我們可以處理異常，以確保我們的代碼正常執行
有兩大類例外
- 檢查
- 那些在編譯時被檢查的異常由被檢查異常組成
- 除了RuntimeException，它們都是Exception的子類
- 例如:IOException, ClassNotFoundException等。
- 無節製的
- 在運行時被檢查的異常包括未檢查異常
- 它們是RuntimeException的子類。
- 示例:arith婧exception, NullPointerException等。
基本語法:
try{}catch(異常){}- Java異常處理有5個關鍵字:
- 試一試
- 抓
- 最後
- 扔
- 拋出
- “試一試”塊包含可能引發異常的代碼。不要在try中寫入任何額外的內容，因為如果發生異常，異常之後的語句將不會被執行
- “抓”塊用於捕獲try塊中語句拋出的異常。它必須遵循try，否則將給出編譯時錯誤。
例子：
公共類ExceptionDemo{公共靜態void main (String[] args) {int a=10;(int i = 3;我> = 0;我——)嚐試{System.out.println (a / i);}捕捉(ArithmeticException e) {System.out.println (e);}}}輸出:
3 5 10 java.lang. arith婧exception: / by 0
可以有多個捕獲，應該從子捕獲到父捕獲，以便獲得所需的輸出。最後塊包含無論是否拋出異常都必須執行的代碼。最後一般包含文件釋放、內存清理等代碼。
例外:
公共類ExceptionDemo{靜態無效canVote(int年齡){if(年齡<18)try{拋出新的異常();}(異常e) {system . out。Println(“你還不是成年人!”);} system . out。println(“你可以投票!”);} public static void main (String[] args) {canVote(20);canVote (10);}}輸出:
我終於成功了
扔關鍵字用於顯式拋出異常，而該異常通常不會拋出異常。
例外:
公共類ExceptionDemo{靜態無效canVote(int年齡){if(年齡<18)try{拋出新的異常();}(異常e) {system . out。Println(“你還不是成年人!”);} system . out。println(“你可以投票!”);} public static void main (String[] args) {canVote(20);canVote (10);}}輸出:
你可以投票!你還不是成年人!
拋出基本上是說代碼可以拋出哪種類型的異常，並依賴於調用者來處理它
例子：
public類ExceptionDemo {static void func(int a)拋出異常{System.out.println(10/a);} public static void main (String[] args) {try{func(10);func (0);}(異常e) {system . out。Println(“不能除零”);}}}輸出:
1不能被0除
字符串
字符串是一個字符序列。它是java中的一個類，有兩種方法來創建字符串:
- String str = " hello ";
- String str = new String(" hello ");
我們有一個特殊的內存叫做字符串常量池在堆裏麵，
- 第一種方法是在堆中創建副本，如果副本還不存在，則在SCP中創建
- 在第二種方法中，複製隻在堆中創建
字符串也可以使用char array創建
- char [] ch ={‘h’,‘e’,‘l’,‘l’,”o '};
- 字符串str =新的字符串(ch);
字符串是不可變的，這意味著一旦創建它就不能被操作
有三種方法來檢查字符串是否相等:
- ==:檢查相同的引用
- .equals():檢查相同的內容
- .compareTo():按字典順序比較內容
- 返回+ve num: str1>str2
- 返回-ve num: str1
- 返回0:str1==str2
例子：
public class StringDemo {public static void main (String[] args) {String s1=new String("cat");字符串s2 =“貓”;字符串s3 =“貓”;System.out.println (s1 = = s2);System.out.println (s2 = = s3);System.out.println (= = s1);System.out.println (s1.equals (s3));System.out.println (s1.compareTo (s2));}}輸出:
假真假真0String有許多幫助處理字符串的方法。其中一些是:
- 長度()
- toUpperCase ()
- toLowerCase ()
- 包含()
- indexOf ()
- substring ()
- split ()
- 替換()
public class StringDemo {public static void main (String[] args) {String str="今天是星期一";System.out.println (str.length ());System.out.println (str.toLowerCase ());System.out.println (str.toUpperCase ());System.out.println (str。包含(“周一”));System.out.println (str.indexOf(周一));System.out.println (str.substring(4、8));System.out.println (str.replace(“星期一”,“周二”));}}輸出:
今天是星期一。今天是星期一。今天是星期二。對於可變字符串，java確實還有兩個類
- StringBuilder(非同步的，即非線程安全的)
- StringBuffer(同步的，即線程安全的)
在Java中包
Java中的包用於對一組類似的類和接口進行分組或組織。它提供訪問保護和命名空間管理。
簡單地說，它就像係統上的文件夾或目錄。它有助於避免名稱衝突，並編寫更好的代碼以獲得更容易的可維護性。
Java在類庫中為您提供了廣泛的包。這個庫稱為應用程序程序接口(API)。
Java中有兩種類型的包:
- 內置包:這些包包含大量的類，它們是Java API的一部分。一些廣泛使用的軟件包是:
- . lang:像數學運算這樣的語言支持類。
- io:輸入和輸出操作。
- java.util:實用類，如數據結構、日期/時間操作等。
- java.applet:用於創建小程序。
- java.awt:它由用於實現GUI組件(如菜單、按鈕等)的類組成。
- java.net:網絡操作。
Java中還有其他許多內置包。您可以根據您的程序選擇使用它們。
用戶定義的包:用戶，也就是您，可以定義這些包。我們使用“package”關鍵字創建一個包。讓我們看一個簡單的例子來理解包的工作原理。
//保存為PackageDemo.java包myfirstpack;public class PackageDemo {public static void main(String args[]) {System.out. public classprintln(“這是我的包。”);}}
現在，打開cmd並輸入以下命令進行編譯:
javac - d。PackageDemo.java
上麵的命令強製編譯器創建“myfirstpack”包。“-d”關鍵字描述了保存生成的類文件的目標。您可以使用點(.)將包保存在相同的目錄中。
接下來，輸入以下命令來運行您的包:
java myfirstpack。PackageDemo
輸出:這是我的包裹。
Java中的訪問修飾符
訪問修飾符決定類、構造函數、字段、變量或方法的可訪問性或作用域。Java中有四種類型的訪問修飾符:
- 公共
- 受保護的
- Default—不需要關鍵字
- 私人
讓我們看一個關於訪問修飾符如何與類和包一起工作的表。
| 訪問修飾符 | 同一個類 | 同一個包 | 僅按子類劃分的外部包 | 外麵的包裝 |
| 公共 | 是的 | 是的 | 是的 | 是的 |
| 受保護的 | 是的 | 是的 | 是的 | 沒有 |
| 默認的 | 是的 | 是的 | 沒有 | 沒有 |
| 私人 | 是的 | 沒有 | 沒有 | 沒有 |
- 公共訪問修飾符
在程序中任何地方都可以訪問的其他訪問修飾符中，此修飾符具有最全麵的作用域。
例子:
在A.java文件中編寫以下代碼。
包firstpack;公共類A{公共無效msg_display() {System.out。println(“beplay2018官网大學習”);在B.java文件中編寫以下代碼。包secondpack;進口firstpack。*;類B {public static void main(String args[]) {A ob = new A();ob.msg_display ();}}現在，依次運行以下命令生成輸出。javac - d。A.java javac -d。 B.java java secondpack.B
輸出:beplay2018官网
2.受保護的訪問修飾符
這些訪問修飾符可以在相同的包中訪問，也可以在不同包中的子類中訪問，它們可以應用於數據成員、方法和構造函數。
例子:
在A.java文件中編寫以下代碼。
包firstpack;公共類A{受保護的void msg_display() {System.out. public class A。println(“beplay2018官网大學習”);在B.java文件中編寫以下代碼。包secondpack;進口firstpack。*;類B擴展A{公共靜態void main(String args[]) {B ob = new B();ob.msg_display ();}}
現在，依次運行以下命令生成輸出。
- javac - d。A.java
- javac - d。B.java
- java secondpack。B
輸出:beplay2018官网
3.默認的訪問修飾符
如果沒有為類、方法或數據成員定義修飾符，則它采用默認的訪問修飾符。這些修飾符隻能在同一個包內訪問，而不能從包外訪問。
例子:
在A.java文件中編寫以下代碼。
包firstpack;類A {void msg_display() {System.out。println(“beplay2018官网大學習”);}}
在B.java文件中編寫以下代碼。
包secondpack;進口firstpack。*;類B {public static void main(String args[]) {A ob = new A();//編譯時間錯誤ob.msg_display();//編譯時間錯誤}}
現在，依次運行以下命令生成輸出。
- javac - d。A.java
- javac - d。B.java
當類A的作用域和方法msg_display()被設置為default時，您將得到編譯時錯誤，它不能從包外部訪問。
4.私人訪問修飾符
這些修飾符隻能在聲明它們的同一個類中訪問。同一包的任何其他類都不能訪問這些成員。
例子:
我們將在同一個“firstpack”包中創建兩個類A和B。接下來，將類a中的方法的作用域指定為private，並嚐試從類b訪問該方法。現在，查看生成的輸出。
在A.java文件中編寫以下代碼。
包firstpack;類A{私有void msg_display() {System.out. class A。println(“beplay2018官网大學習”);}}類B {public static void main(String ags[]) {A ob = new A();//嚐試訪問類B的私有方法"msg_display()" ob.msg_display();}}
現在，執行以下命令查看輸出結果:
javac - d。A.java
輸出:
msg_display()在A中有私有訪問權限
ob.msg_display ();
鏈表
什麼是鏈表?
鏈表是線性連接的節點的集合。你可以想象一列火車;例如，有不同的車廂，所有的車廂都是相連的。類似地，在鏈表中，各個節點由下一個節點的數據和內存位置組成。由於內存位置的存在，節點被稱為附加的。
鏈表是線性數據結構。當我們需要在鏈表的開始、結束或中間插入或刪除數據時，就會使用它們。鏈表中添加和刪除數據的過程很簡單。在創建鏈表時，不需要指定鏈表的大小。節點創建在任何有空閑內存的地方。
鏈表如何在Java中運行?
在C語言中，我們使用指針指向下一個節點的內存位置。節點不一定是並排出現的。我們可以通過地址指針訪問它們。因此，節點之間相互連接。使用內存位置從一個節點跳到另一個節點稱為指針跳。
例如，考慮第一個節點，稱為“Head”，將出現在地址中，假設是50001，而我的下一個節點位於內存位置100010。此地址與數據一起存儲在節點中。因此，我們可以使用第二個節點的地址100010訪問它。
然而，在Java中沒有指針。因此，我們使用引用來引用下一個節點的地址。在這裏，使用內存位置從一個節點跳到另一個節點稱為鏈接跳。
但是我們現在不需要聲明任何變量或引用，因為鏈表是Java中集合框架的一部分。util包。
在Java中創建鏈表:
如前所述，要在Java中創建鏈表，我們使用Java。util包並為鏈表類聲明一個對象。然後我們可以繼續添加和刪除元素，因為方法內置在LinkedList類中。
例子:用java創建一個鏈表，用於存儲質數到10。
進口java.util。*;public class PrimeNumbers {public static void main(String args[]){//創建類鏈表對象LinkedList lk = new LinkedList();//添加素數到鏈表lk.add(2);lk.add (3);lk.add (5);lk.add (7);System.out.println(路);}} 輸出：
[2,3,5,7]
向鏈表中添加元素:
我們可以在列表的開始、結束和中間添加不同的元素。例如，我想準備一個鏈表的學生在一個班基於他們的首字母。我使用add()方法將它們添加到列表中。如果我需要添加新的學生，我在列表中指定特定的索引和他們的名字，並輕鬆添加他們。鏈表中索引從0開始。
例子一個用java為班裏的學生根據姓名首字母創建鏈表的程序。
進口java.util。*;public class AddElements {public static void main(String args[]) {LinkedList lk = new LinkedList();lk.add(“行長”);lk.add(“迪帕克”);lk.add(“Krithika”);//添加索引lk.add(2，"Gagan");lk.addFirst(“Ankitha”);System.out.println(路);}} 輸出：
[Ankitha, Bindu, Deepak, Gagan, Krithika]
改變鏈表中的元素:
我們還可以更改列表中插入的元素，這可以使用set()方法來完成。每個鏈表都有索引。因此，我們希望更改的元素由它的索引來引用。因此，該方法接受一個索引和我們現在要插入到該索引的元素。例如，一個學生的名字輸入錯誤，需要更正，因此學生名的索引和正確的名字將在set()方法中獲取。
例子一個用java為班裏的學生根據姓名首字母創建鏈表的程序。
進口java.util。*;public class UpdateElements {public static void main(String args[]) {LinkedList lk = new LinkedList();lk.add(“行長”);lk.add(“迪帕克”);lk.add(“Krithika”);//添加索引lk.add(2，"Gagan");lk.addFirst(“Ankitha”);System.out.println(路);//使用索引lk.set(0，"Anitha")設置更新的元素;System.out.println(路); } } 輸出：
[Ankitha, Bindu, Deepak, Gagan, Krithika]
[Anitha, Bindu, Deepak, Gagan, Krithika]
刪除鏈表中的元素:
我們還可以在列表的開始、結束和中間刪除不同的元素。例如，考慮前麵例子中的學生列表。如果有學生離課，我們就得把他們的名字去掉。我們可以使用它們的索引或名稱本身刪除它們的名稱。我們使用remove()方法來刪除鏈表中的元素。
例子:一個用Java創建鏈表的程序，根據學生姓名的首字母從列表中刪除。
進口java.util。*;公共類RemoveElements{公共靜態void main(String args[]) {LinkedList lk = new LinkedList();lk.add(“行長”);lk.add(“迪帕克”);lk.add(“Krithika”);//添加索引lk.add(2，"Gagan");lk.addFirst(“Anitha”);System.out.println(路);lk.remove (1);System.out.println(路); lk.remove("Gagan"); System.out.println(lk); } } 輸出:
[Anitha, Bindu, Deepak, Gagan, Krithika]
[Anitha, Deepak, Gagan, Krithika]
[Anitha,迪帕克,Krithika]
LinkedList類中的其他方法包括，
1.clear()—該方法清除鏈表中的所有元素。
2.clone()—該方法返回鏈表的精確副本。
3.contains(Object O)——該方法掃描列表，如果元素存在返回' True '，如果給定元素不存在返回' False '。
4.get(int index_value) -該方法查找給定的索引並返回當前元素。此方法的變體是getFirst()和getLast()，前者返回列表的第一個元素，後者返回最後一個元素。
5.indexOf(Object o)——該方法接受給定元素的對象並返回索引。這個方法的變體是lastIndexOf()。該方法返回從最後一個位置開始的元素索引。
6.listIterator(int index_value)——該方法返回從給定索引處的元素開始的整個鏈表。
鏈表中的構造函數:
在鏈表類中，我們需要聲明對象，因此調用構造函數。在鏈表類中有不同類型的構造函數，它們是，
LinkedList()——該構造函數用於創建空列表。
LinkedList(集合co)——這個構造函數用於創建有序的元素列表。這些元素來自給定的輸入。
Java中的鏈表類型:
在鏈表類內部，創建的列表是一個雙鏈表。
雙鏈表包含一個額外的指針，在本例中是一個引用。
它被稱為以前的參考。它引用前一個節點的地址。
個鏈表:
通常，任何鏈表中隻有一個引用。它被稱為單鏈表。最後一個節點稱為“tail”，它的值為空，因為它是一個引用。在此列表中，隻允許在單個方向上遍曆。
雙鏈接列表:
雙鏈表包含兩個引用變量，一個指向前一個節點地址，另一個指向下一個節點，就像每個鏈表一樣。在這種類型的List中，我們可以向任何方向遍曆它。
循環鏈表:
循環鏈表與單鏈表相同，隻是最後一個節點引用第一個節點。它克服了單鏈表的缺點，我們隻能沿著一個方向遍曆它。
循環雙鏈表:
循環雙鏈表與雙鏈表相同，其中頭的前麵引用引用尾節點。最後一個節點引用頭節點。在這種類型的列表中，我們可以向任何方向遍曆整個列表。
什麼時候和為什麼鏈表使用數組列表?
ArrayList允許快速的隨機讀訪問，因此您可以在常量時間內獲取任何元素。在數組列表中，添加或刪除操作可以在任何地方進行，但最後需要將所有元素移到另一邊，以便打開或填補空白。當添加的元素超過所聲明數組的容量時，將分配一個新數組，並將舊數組複製到新數組。由於LinkedList使用雙鏈表，使用LinkedList的操作比ArrayList快;此外，內存中不需要移位位。ArrayList類可以作為列表的唯一原因是它隻實現list。LinkedList類既可以作為列表也可以作為隊列，因為它實現了list和Deque接口。在鏈表中，任何額外的內存都不會浪費。
我們可以使用鏈表來實現棧和隊列。
鏈表的缺點:
在鏈表中，與其他數據結構不同，我們不能訪問隨機元素。遍曆鏈表非常耗時。直接訪問任何元素都需要遍曆整個列表。我們存儲數據和引用，並將其視為節點;因此，它會占用大量的內存。
鏈表的應用:
鏈表對於實現堆棧、隊列和圖形非常有用。鏈表作為圖像查看器非常有用。在這種情況下，由於每個圖像都鏈接到另一個圖像，導航很容易。同樣，它們也可以用於在音樂播放器中導航歌曲，在網頁瀏覽器中導航頁麵，以及其他應用程序。
如果您正在尋找其他技術領域的更多此類教程，請查看beplay2018官网很好的學習學院。
