Java初學者教程| Java概述

按位運算符

它是逐位計算的。無論第一個表達式計算的是什麼，都對兩邊進行檢查。四種主要的位操作符是:

• ＆-按位和，如果兩位都是1，則返回1，否則為0。
• |-按位或，如果其中一位為1，則返回1，否則為0。
• ＾-按位的xor，如果兩個比特不同則返回1，否則返回0。
• ～-位不，將1變為0，反之亦然。

例子:

public class BitwiseDemo {public static 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 = 0 a|b = 3 a^b = 3 ~a = -2

邏輯運算符

它們用於條件比較，基本上檢查它們的有效性。它們也在循環中用作終止條件的一部分。如果第一個條件足以給出最終裁決，它就不會評估第二個條件。

有3個邏輯運算符:

• & &-邏輯與，當兩個條件都為true時返回true
• ||-邏輯或，當其中一個條件的值為true時返回true
• ！- logical not，當條件計算為false時返回true

例子:

public class LogicalDemo {public static 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(”!+ !(A ==1));}}

輸出:

A ==1 && b==1假A ==1 || b==1真

賦值運算符

賦值運算符(=)用於將右邊的值賦給左邊的變量。

三元操作符(?)

if-else的替代形式。條件被放在' ?'如果求值為true則執行冒號的LHS否則將執行冒號的RHS。

例子:

public class MiscDemo {public static void main (String[] args) {int a;//賦值運算符a=1;System.out.println(“(= = 1 ?\"表達式為真\":\"表達式為假\" = \n "+ (a==1?"表達式為真":"表達式為假"));}}

輸出:

(= = 1 ?"expression is true":"expression is false" =表達式為真

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.0f
• 雙- size為8字節，默認值為0.0d

還有一些非基本數據類型，如數組，類，如字符串等。

條件語句

if - else

if-else語句由if和else兩個關鍵字組成。這是一種根據條件有兩條可能路徑的方法。也就是說，如果' if '條件操作為true，那麼它將被執行，否則代碼' else '將被執行。如果有更多可能的路徑，你可以在else if後麵加上else。同樣，嵌套的if和else也是可能的。

控製流程圖:

例子：

public class IfElseDemo {public static void main (String[] args) {int a=5,b=6;如果(a + b = = 11) System.out.println(“平等”);其他的system . out。println(“不平等”);}}

輸出:

真正的

開關

這是替代多個else-if的一種優雅方式

語法：

開關(表達式){case val:…；打破;案例瓦爾:……；打破;案例瓦爾:……；打破;默認值:……; }

在這裏，根據條件計算的答案，執行case代碼。每個case後麵必須跟著break，除非它不是按照邏輯要求的。否則，所有用例將從匹配的用例開始執行，直到遇到break或耗盡所有用例。

' default '是可選的，保存在沒有匹配捕獲時執行的代碼。

' val '在java中可以是整數，字符或字符串。

例子：

public class SwitchDemo {public static void main (String[] args) {String day="sun";switch(day) {case "mon": System.out。println(“今天是星期一”);打破;case "tues":係統退出。println(“今天是星期二”);打破;case "wed":係統退出。println(“今天是星期三”);打破;case "thurs": 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循環:

最好在知道代碼應該執行的指定次數時使用。

語法：

(初始化;終止;升級){}

• ' initialization '用於初始化用於迭代的變量。
• “終止”——包含決定迭代何時繼續的條件。
• ' update ' -我們的變量將如何更新。

例子：

public class ForDemo {public static void main (String[] args) {for(int i=0;i<5;i++) System.out。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 '用於指定誰負責循環繼續的條件。

例子：

public class DoWhileDemo {public static void main (String[] args) {int i=0;{system . out。Println (" I的當前值:"+ I);我+ +;},(我< 5);}}

輸出:

I的當前值:0 I的當前值:1 I的當前值:2 I的當前值:3 I的當前值:4

Java中的分支語句

打破

它是一個關鍵字，基本上終止當前循環並將執行移出循環

為 (.........){ 打破;} ==>執行在遇到中斷時出現在這裏

例子:

public class BreakDemo {public static void main (String[] args) {int i=0;雖然(我< 5){system . out。Println (" I的當前值:"+ I);我+ +;如果(我= = 3)休息;} system . out。println("Out of loop!");}}

輸出:

i的當前值:0 i的當前值:1 i的當前值:2脫離循環!

繼續

它是一個關鍵字，基本上終止當前迭代並將執行移動到循環的更新部分。在' while '和' do-while '中，當遇到continue時，它將忽略其餘代碼

(. .；．．．．；…)==>當遇到break時執行到這裏{繼續;｝

例子：

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("Out of loop!");}}

輸出:

i的當前值:0 i的當前值:1 i的當前值:2 i的當前值:4脫離循環!

返回

它從它的代碼塊中返回，即如果它在函數中，它將從函數中退出。

主要 (.........){ 返回;} ==>存在於程序中

例子:

公共類ReturnDemo{公共靜態void main (String[] args) {for(int i=0;i<5;i++){if(i==3)返回;system . out。Println (" I的當前值:"+ I);} system . out。println("Out of loop!");}}

輸出:

I的當前值:0 I的當前值:1 I的當前值:2

評論

注釋用於對代碼背後的邏輯進行簡要描述。它們隻是在執行時被編譯器忽略。

在java中，我們有唱行和多行注釋:

// -單行和/* ....．．．．*/ -多行

Java類

它是現實生活實體的藍圖，由數據和方法組成。基本上，它是OOPs支柱之一的封裝的實現。

關鍵字class用於在java中聲明類。根據命名約定，類名遵循每個單詞的第一個字母應該是大寫的。此外，所有代碼必須在某個類中，單個文檔可以有多個類，但隻能有一個公共類

例子：

class容器{//數據成員int權重;字符串的顏色;兩倍價格;//方法void setWeight(int w){weight=w;} void setColor(int c){color=c;} void setPrice(int p){價格=p;} void print(){System.out。Println(重量+“”+顏色+“”+價格);}}

對象

它基本上是類的物理實體，類的實例。new關鍵字用於在Heap中創建對象和分配內存。創建對象時，它會調用類的構造函數。

例子：

容器c1=new Container();

Java中的構造函數

構造函數是一個特殊的方法，用於分配內存和初始化對象。它沒有任何返回類型，它的名稱與類名相同。如果沒有顯式定義構造函數，編譯器會隱式地提供一個默認構造函數來分配內存。

具有參數的構造函數被歸類為參數化構造函數。當遇到new時，它調用構造函數。在創建對象時傳遞的參數決定了應該調用哪個構造函數。

例子:

類容器{int重量;字符串的顏色;兩倍價格;//參數化構造函數容器(int w,String c,double p) {weight=w;顏色= c;價格= p;system . out。println("我是一個參數化構造函數");} //默認構造函數Container() {System.out.}println("我是一個默認構造函數");} void print(){System.out。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紅色567.85

超級

“Super”通常與父類相關。它擴展了用於建立子-父關係的繼承的關鍵字。你可以使用super調用父類的方法、數據成員和構造函數。當使用super調用父函數的構造函數時，它應該是代碼塊中的第一行

這

' This '通常與當前類相關聯。可以調用當前類方法、數據成員和構造函數。當使用this調用當前類構造函數時，它應該是代碼塊中的第一行。

例子:

//父母類類招待所{字符串地址;字符串名稱;//參數化構造函數初始化add和name Hostel(字符串地址，字符串名稱){/*使用this指向酒店的地址和名稱如果沒有this，參數將賦值給local var類var仍然有默認值。* / this.address =地址;this.name =名稱;} //參數化構造函數初始化隻是名稱招待所(字符串名稱){this.name=name;} //方法打印地址無效printAddress(){System.out. out.}Println ("address: "+address);}} //兒童班級班級房間延伸宿舍{int number;字符串名稱;//參數化構造函數初始化地址，名稱和數字Room(字符串地址，字符串名稱，int數字){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;

靜態變量關鍵字示例

類編號{靜態int計數=0;公共無效增量(){count++;} public static void main(String args[]) {numbers obj1=new numbers();數字obj2=新數字();obj1.increment ();obj2.increment ();system . out。println("Obj1: count ="+ Obj1 .count);system . out。println("Obj2: count is="+ Obj2 .count); } }

輸出

Obj1: count is=2

Obj2: count is=2

如上圖所示，兩個對象都包含相同的變量對象。

靜態方法

• 我們可以為方法使用靜態關鍵字，例如靜態方法。
• 我們可以將靜態方法用於類，而不是類中的對象。
• 靜態方法可以使用靜態數據成員，也可以更改靜態數據成員的值。
• 不需要創建類的實例，就可以創建靜態方法
• 靜態方法的主要優點是它不需要對象。

注意事項:

• 我們不能重寫靜態方法，因為它是在運行時編譯的。
• 我們不能把抽象方法變成靜態的。
• 它不使用超級鍵。
• 靜態方法需要對象的引用來直接訪問實例變量和方法。
• 它可以訪問所有靜態變量，也可以訪問其他靜態方法。

語法

<類名稱>。<方法名稱>

靜態方法實例

公共類mall{公共靜態無效main(字符串args[]){客戶c1 =新客戶();c1.showData ();客戶c2 =新客戶();c2.showData ();/ / customer.b + +;/ / c1.showData ();}}類客戶{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++; //} }

靜態塊

• 要初始化靜態數據成員，需要使用靜態塊。
• 在裝入類時，它在主方法之前執行。
• 靜態塊隻是類內部的語句塊。
• 如果靜態塊的初始化是一個錯誤，則需要異常處理。

需要記住的要點:

• 單個類可能包含許多靜態塊。
• 靜態變量和靜態塊應該保持與它們在類中出現時相同的順序。

靜態塊的示例

公共類號{靜態int i;靜態int j;//靜態塊靜態{I = 50;J = 100;} public static void main(字符串args[]) {system.out. out.}Println(“靜態塊初始化”);system . out。println(" i的值= " + i);system . out。println(" j的值= " + j);}}

靜態類

如果一個類是嵌套類，那麼我們可以將它轉換為靜態類。它不需要外部類引用。因此，外部類的非靜態成員不能被靜態類訪問。

注意事項:

• 靜態類可以通過引用對象來訪問。
• 我們不能將頂級類用作靜態類;因此，隻有嵌套類可以轉換為靜態類。

靜態類示例

// Java程序演示如何在Java程序類中實現靜態類OuterClass{私有靜態字符串msg = "Great Learning";beplay2018官网//靜態嵌套類公共靜態類NestedClass{//隻有外部類的靜態成員//在嵌套//靜態類公共void print(){//嚐試使'message'一個非靜態//變量，將有編譯器錯誤System.out。println("來自嵌套靜態類的消息:" + msg);}}

Java中的繼承

oop的一個非常重要的支柱，它促進了代碼的可重用性，因為子程序可以從父程序繼承。Child還可以實現它自己的其他數據成員或方法。這是孩子和父母之間的is - a關係。

示例:在上麵的例子中，Room(子)繼承了Hostel(父)。

java支持4種類型的繼承:

Java不假設經典的多重繼承，因為它可能會導致歧義。但是你可以通過接口進行多重繼承。

Java中的方法重載

這基本上是一個編譯時多態性。可以有多個方法具有相同的名稱，但不同的參數列表可能在類型或參數數量上有所不同

' Method '不能僅通過改變方法的返回類型來重載。它為程序員提供了方便，並有助於理解代碼

例子：

公共類OverloadingDemo {int乘法(int a,int b){返回a*b;} //重載乘3個參數int乘(int a,int b,int c){返回a*b*c;} //重載乘以2個不同類型的參數double multiply(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中的方法重寫

這就是運行時多態性。在這裏，如果一個子類想要重寫父類的方法，例如，想要給出自己的實現，那麼它可以通過擁有與其實現完全相同的簽名來做到這一點。

例子:

class父類{void hobby () {System.out. out. classprintln(“讀書”);}}類Child擴展父類{//父類方法相同但實現不同void hobby () {System.out.println(" traveling ");}}類OverridingDemo{公共靜態無效主(字符串[]args){子ob=新子();ob.hobbies ();}}

輸出:

旅行

Java中的抽象類

如果一個方法沒有它的實現，那麼它被稱為“抽象”方法。具有一個或多個抽象方法的類稱為抽象類。它實際上在一定程度上實現了oop抽象

Abstract關鍵字用於聲明抽象類。抽象類可以有抽象方法和非抽象方法，而且不能實例化。

相反，它必須進行擴展，並且必須給出抽象方法的實現。

例子：

抽象類鍵盤{抽象void working();無效名稱(){System.out。println(“這是鍵盤組件”);}}類Hp擴展鍵盤{//實現抽象方法void working(){System.out. out.}println(“這是惠普鍵盤”);}}公共類AbstractClassDemo{公共靜態void main (String[] args) {Hp ob=new Hp();ob.working ();ob.name ();}}

輸出:

這是鍵盤組件

Java接口

它實現了100%的抽象。這裏所有的方法默認都是抽象的，因此在聲明它們時沒有必要寫abstract關鍵字

例子：

接口玩具{無效開始();空運行();}類Car實現玩具{公共無效start(){System.out。println(“汽車開始”);}公共無效運行(){係統。println(“汽車運行”);}}類InterfaceDemo{公共靜態無效主(字符串[]args) {Car ob=新車();ob.start ();ob.run ();}}

輸出:

汽車啟動汽車運行

編譯器在接口的每個方法前隱式地添加一個公共摘要

T:\>javap玩具編譯自"GFG.java"接口玩具{公共抽象void start();公共抽象空運行();

• Implements關鍵字由想要使用它的類使用，並且必須為每個方法給出定義
• 在實現接口方法時，必須指定公共訪問修飾符
• 一個類可以實現多個接口，這些接口支持某種類型的多重繼承

Java中的異常處理

異常是在運行時可能發生並擾亂程序正常流程的異常情況。因此，我們可以處理異常，以確保我們的代碼正常執行

有兩大類例外

• 檢查
  • 在編譯時檢查的異常由已檢查異常組成
  • 它們是Exception的子類，除了RuntimeException
  • 例如:IOException, ClassNotFoundException等。
• 無節製的
  • 運行時檢查的異常由未檢查異常組成
  • 它們是RuntimeException的子類。
  • 例如:arithmeexception, NullPointerException等。

基本語法:

try{}catch(異常e){}

• Java異常處理中有5個關鍵字:
  • 試一試
  • 抓
  • 最後
  • 扔
  • 拋出
• “試一試”塊包含可能引發異常的代碼。不要在try語句中寫任何額外的內容，因為如果異常發生，則異常語句將不會被執行
• “抓”塊用於捕獲try塊中的語句拋出的異常。它必須跟在try後麵，否則將給出編譯時錯誤。

例子：

public class ExceptionDemo {public static void main (String[] args) {int a=10;(int i = 3;我> = 0;我——)嚐試{System.out.println (a / i);}catch(ArithmeticException e){System.out.println(e);}}}

輸出:

3 5 10 java.lang. arithmeexception: / by 0

可以有多個catch，為了獲得所需的輸出，應該將這些catch從子對象放置到父對象。最後塊包含必須執行的代碼，無論是否拋出異常。最後一般包含文件釋放、內存清理等代碼。

例外:

公共類ExceptionDemo{靜態無效canVote(int年齡){如果(年齡<18)嚐試{拋出新的異常();}catch(異常e){System.out。Println(“你不是成年人!”);} else System.out。Println(“你可以投票!”);} public static void main (String[] args) {canVote(20);canVote (10);}}

輸出:

我終於

扔關鍵字用於顯式拋出異常，該異常通常不會拋出異常。

例外:

公共類ExceptionDemo{靜態無效canVote(int年齡){如果(年齡<18)嚐試{拋出新的異常();}catch(異常e){System.out。Println(“你不是成年人!”);} else System.out。Println(“你可以投票!”);} public static void main (String[] args) {canVote(20);canVote (10);}}

輸出:

你可以投票!你還不是成年人!

拋出基本上是說代碼可以拋出什麼樣的異常，並依賴於調用者來處理它

例子：

公共類ExceptionDemo {static void func(int a)拋出異常{System.out.println(10/a);} public static void main (String[] args) {try{func(10);func (0);}catch(異常e){System.out。Println(“不能被零除”);}}}

輸出:

1不能被0除

字符串

字符串是一個字符序列。它是java中的一個類，有兩種方法來創建字符串:

• String str = " hello ";
• String str = new String(" hello ");

我們有一個特殊的內存叫做字符串常量池在堆裏麵，

• 在第一種方式中，在堆中創建副本，如果還沒有副本，也在SCP中創建
• 在第二種方式中，複製隻在堆中創建

字符串也可以使用字符數組創建

• char [] ch ={‘h’,‘e’,‘l’,‘l’,”o '};
• String str=new String(ch);

字符串是不可變的，這意味著一旦創建它就不能被操作

有三種方法來檢查String是否相等:

• ==:檢查相同的引用
• .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));}}

輸出:

假真假真0

String有許多方法可以幫助處理字符串。其中一些是:

• 長度()
• 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中有兩種類型的包:

1. 內置包:這些包包含許多類，這些類是Java API的一部分。一些廣泛使用的包有:
   1. . lang:語言支持類，比如數學運算。
   2. io:輸入和輸出操作。
   3. java.util:實用程序類，如數據結構、日期/時間操作等。
   4. java.applet:用於創建小程序。
   5. java.awt:它由用於實現GUI組件(如菜單、按鈕等)的類組成。
   6. java.net:網絡操作。

Java中還有其他許多內置包。您可以根據您的程序選擇使用它們。

用戶定義的包:用戶，也就是您，可以定義這些包。我們使用" package "關鍵字來創建一個包。讓我們看一個簡單的例子來理解包的工作原理。

//保存為PackageDemo.java包myfirstpack;公共類PackageDemo{公共靜態無效main(字符串args[]) {System.out。println(“這是我的包。”);}}

現在，打開cmd並輸入以下命令進行編譯:

Javac -d。PackageDemo.java

上麵的命令強製編譯器創建“myfirstpack”包。“-d”關鍵字描述了保存生成的類文件的目的地。您可以使用點(.)將包保存在相同的目錄中。

接下來，輸入以下命令運行你的包:

java myfirstpack。PackageDemo

輸出:這是我的包裹。

Java中的訪問修飾符

訪問修飾符決定類、構造函數、字段、變量或方法的可訪問性或範圍。在Java中有四種類型的訪問修飾符:

1. 公共
2. 受保護的
3. Default -沒有必要的關鍵字
4. 私人

讓我們看一個關於訪問修飾符如何與類和包一起工作的表。

1. 公共訪問修飾符

在程序中任何地方都可以訪問的其他訪問修飾符中，此修飾符具有最全麵的作用域。

例子:

在A.java文件中編寫以下代碼。

包firstpack;公共類A{公共無效msg_display() {System.out。println(“beplay2018官网大學習”);在B.java文件中編寫以下代碼。包secondpack;進口firstpack。*;class 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{受保護的無效msg_display() {System.out。println(“beplay2018官网大學習”);在B.java文件中編寫以下代碼。包secondpack;進口firstpack。*;class B extends A {public static void main(String args[]) {B ob = new B();ob.msg_display ();}}

現在，依次運行以下命令以生成輸出。

1. Javac -d。A.java
2. Javac -d。B.java
3. java secondpack。B

輸出:beplay2018官网

3.默認訪問修飾符

類、方法或數據成員未定義修飾符，則采用默認的訪問修飾符。這些修飾符隻能在同一個包內訪問，而不能從包外訪問。

例子:

在A.java文件中編寫以下代碼。

包firstpack;class A {void msg_display() {System.out。println(“beplay2018官网大學習”);}}

在B.java文件中編寫以下代碼。

包secondpack;進口firstpack。*;class B {public static void main(String args[]) {A ob = new A();//編譯時間錯誤ob.msg_display();//編譯時間錯誤

現在，依次運行以下命令以生成輸出。

1. Javac -d。A.java
2. Javac -d。B.java

當類A的作用域和方法msg_display()被設置為默認時，您將得到編譯時錯誤，該方法不能從包外部訪問。

4.私有訪問修飾符

這些修飾符隻能在聲明它們的類中訪問。同一包的任何其他類都不能訪問這些成員。

例子:

我們將在同一個“firstpack”包中創建兩個類，A和B。接下來，將類a中的方法的作用域指定為private，並嚐試從類b訪問該方法。現在，查看產生的輸出。

在A.java文件中編寫以下代碼。

包firstpack;class A {private void msg_display() {System.out。println(“beplay2018官网大學習”);}}類B{公共靜態無效主(字符串ags[]) {A ob =新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。*;public class RemoveElements {public static 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, Deepak, 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(Collection co)——這個構造函數用於創建一個有序的元素列表。這些元素來自給定的輸入。

Java中的鏈表類型:

在鏈表類內部，創建的列表是雙鏈表。

雙鏈表包含一個額外的指針，或者在本例中包含一個引用。

它被稱為先前的參考。它引用前一個節點的地址。

單鏈表:

通常在任何鏈表中隻有一個引用。它被稱為單鏈表。最後一個節點，稱為“tail”，因為它是一個引用，所以有一個空值。在這個列表中，隻允許在一個方向上遍曆。

雙鏈接列表:

雙鏈表包含兩個引用變量，一個指向前一個節點地址，另一個指向下一個節點，就像每個鏈表一樣。在這種類型的List中，我們可以在任何方向遍曆它。

循環鏈表:

循環鏈表與單鏈表相同，隻是最後一個節點引用第一個節點。它克服了單鏈表的缺點，我們隻能在一個方向上遍曆它。

循環雙鏈表:

循環雙鏈表與雙鏈表相同，其中頭節點的前一個引用引用尾節點。最後一個節點引用頭節點。在這種類型的列表中，我們可以在任何方向遍曆整個列表。

什麼時候和為什麼鏈表使用數組列表?

ArrayList允許快速隨機讀訪問，因此可以在常數時間內獲取任何元素。在一個數組列表中，添加或刪除可以在任何地方完成，但最後需要將所有元素移開，以打開或填充空白。當添加的元素超過所聲明數組的容量時，將分配一個新數組，並將舊數組複製到新數組中。由於LinkedList使用雙鏈表，使用LinkedList的操作比ArrayList更快;此外，內存中不需要移位位。ArrayList類隻能作為一個列表，因為它隻實現了list。LinkedList類可以同時用作列表和隊列，因為它實現了list和Deque接口。在鏈表中，任何額外的內存都不會浪費。

我們可以使用鏈表來實現堆棧和隊列。

鏈表的缺點:

在鏈表中，與其他數據結構不同，我們不能訪問隨機元素。遍曆鏈表非常耗時。直接訪問任何元素都需要遍曆整個列表。我們存儲數據和引用，並認為這是一個節點;因此，它占用了大量的內存。

鏈表的應用:

鏈表對於實現堆棧、隊列和圖很有用。鏈表作為圖像查看器非常有用。在這種情況下，由於每個圖像都鏈接到另一個圖像，因此導航很容易。同樣，在其他應用程序中，它們可以用於在音樂播放器中導航歌曲，在web瀏覽器中導航頁麵。

如果您正在尋找其他技術領域的更多此類教程，請查看beplay2018官网偉大的學習學院。