JAVA基礎知識

時間 2019-11-12

標籤 java 基礎知識欄目 Java 简体版

原文原文鏈接

知識總體圖示： java

1、簡介

Java的開發語言是c語言。面試

1995年由SUN公司正式推出，Oak-橡樹是sun公司推出的第一個版本。編程

1.0-1.1-1.2（Applet、swing---GUI）-1.3-1.4-5.0（十個特性）-6-7.0-8（十個特性）-9。已經有十個版本。windows

一、版本介紹

1995年5月23日，Java語言誕生；數組

1996年1月，第一個JDK-JDK1.0誕生；bash

1996年4月，10個最主要的操做系統供應商申明將在其產品中嵌入Java技術；編程語言

1996年9月，約8.3萬個網頁應用了Java技術來製做；ide

1997年2月18日，JDK1.1發佈；模塊化

1997年4月2日，JavaOne會議召開，參與者逾一萬人，創當時全球同類會議紀錄；函數

1997年9月，JavaDeveloperConnection社區成員超過十萬；

1998年2月，JDK1.1被下載超過2,000,000次；

1998年12月8日，Java 2企業平臺J2EE發佈；

1999年6月，SUN公司發佈Java三個版本：標準版（J2SE）、企業版（J2EE）和微型版（J2ME）；

2000年5月8日，JDK1.3發佈；

2000年5月29日，JDK1.4發佈；

2001年6月5日，Nokia宣佈到2003年將出售1億部支持Java的手機；

2001年9月24日，J2EE1.3發佈；

2002年2月26日，J2SE1.4發佈，此後Java的計算能力有了大幅提高；

2004年9月30日，J2SE1.5發佈，成爲Java語言發展史上的又一里程碑。爲了表示該版本的重要性，J2SE1.5改名爲Java SE 5.0；

2005年6月，JavaOne大會召開，SUN公司公開Java SE 6。此時，Java的各類版本已經改名，以取消其中的數字「2」：J2EE改名爲Java EE，J2SE改名爲Java SE，J2ME改名爲Java ME；

2006年12月，SUN公司發佈JRE6.0；

2009年12月，SUN公司發佈Java EE 6；

2010年11月，因爲甲骨文對Java社區的不友善，所以Apache揚言將退出JCP；

2011年7月28日，甲骨文發佈Java SE 7；

2014年3月18日，甲骨文發表Java SE 8。

從今年開始，java開始每半年更新一次，分別是在每一年的3月和9月。

二、技術結構

1．環境組件

Java語言具備跨平臺的特色，java跨平臺靠的是JVM的支持。

JVM —— Java虛擬機：針對每種操做系統開發了對應的Java虛擬機，Java程序在寫好以後並非直接在計算機上運行，而先交給對應JVM去進行翻譯，JVM將代碼翻譯成當前機器可以讀懂的語言，再運行。Java虛擬機不是跨平臺的。

JVM （Java Virtual Machine）：Java虛擬機，是Java語言可以跨平臺的前提。

JRE （Java Runtime Environment）：Java運行時環境。JRE中包含JVM和核心類庫。

JDK （Java Development Kit）：Java開發工具包。JDK中包含來JRE和開發工具。

到官網下載windows版本jdk的安裝包，直接雙擊運行安裝便可。

注意：C://program files---不要安裝到這個目錄下，安裝目錄中儘可能不要出現空格或者特殊符號。否則容易出現不可預估的異常。

2．技術結構

JAVASE —— 標準版 —— J2SE

JAVAEE —— 企業版 —— J2EE

JAVAME —— 移動版 —— J2ME

JAVACARD —— 智慧卡

3．經常使用命令

javac

javac 要編譯的文件名.class/包名.文件名.class

例如：

javac cn.xjd.Test.java
javac Text.java

javac -d 編譯完成以後的存放路徑要編譯的Java文件

javac -d E:\\ Demo.java

java

java calss文件名

java Test

java -cp class文件的存放路徑 class文件的文件名

java -cp F:\\cn.com Demo

4．環境變量（environment variable）

給操做系統來指定一系列的運行參數的量。

①JAVA_HOME=JDK的安裝路徑

②Path=%JAVA_HOME%\bin;

③CLASSPATH=. 表示指定運行目錄的。「.」表示當前目錄。在JDK1.7之後這個變量能夠再也不設置。

以下圖所示，爲JAVA_HOME的配置方法，Path也是同樣的，在系統變量和用戶變量中配置都可。

三、入門程序(HelloWorld)

public class Demo {
  public static void main(String[] args){
    System.out.println(「Hello World ~~~」);
  }
}

注意：

1. Java程序必須放到.java的文件中。

2. class的文件名和類名對應，每個類在編譯完成產生一個對應的class文件。

3. 一個類用public修飾，稱之爲是一個公共類，公共類要求類名和Java的文件名一致。一個java文件中能夠寫多個類，可是隻能有一個公共類。

2、基礎知識

一、關鍵字（keywords）

是指Java中一些賦予了特殊含義的單詞。

Java中一共有50個關鍵字，其中2個保留字：const ，goto。

另外還有三個直接量：true、false、null。這三個官方已經將其從關鍵字的行列刨除了，可是仍是具備關鍵字的特性，只是名字發生了改變。

關鍵字的考點跑不過直接量和保留字，全部的關鍵字都是小寫的。你們留心。

用於定義數據類型的關鍵字
class	interface	byte	short	int	long
float	double	char	boolean	void	enum
用於定義流程控制的關鍵字
if	else	switch	case	default	while
do	for	break	continue	return
用於定義訪問權限修飾符的關鍵字
private	protected	public
用於定義類、函數、變量修飾符的關鍵字
abstract	final	static	synchronized
用於定義類與類之間關係的關鍵字
extends	implements
用於定義創建實例、判斷實例的關鍵字
new	this	super	instanceof
用於異常處理的關鍵字
try	catch	finally	throw	throws
用於包的關鍵字
package	import
其餘修飾符關鍵字
native	strictfp	transient	volatile	assert

我在網上看到不少的面試練習題，都是關於定義數據類型值關鍵字的，最經典的以下：

下面幾個不是Java中的關鍵字？

A.true B.false C.null D.int

答案是ABC這三個選項。

二、標識符（IDentifier）

在程序中自定義的名稱。

1．定義規則

1.能夠由字母、數字、_、$組成（雖然可使用$命名，可是儘可能減小使用）。

int a;
int a2;
int a_2;
int a_2$;

2.不容許以數字開頭。

3.不容許使用關鍵字。

4.見名知義。

5.嚴格區分大小寫。Demo demo

例如：

int ILoveJava;
int $20;
int Hello_World;
//這些都是正確的，更變態的名字「_____」這在java中是容許的。
int _______;

2．駝峯命名法

1>類名/接口名

是由多個單詞組成，每一個單詞的首字母要大寫。

例如：

public class PlayGame{}
class HelloWorld{}

2>變量名/方法名

由多個單詞組成，第一個單詞的首字母小寫，其他單詞的首字母大寫。

例如：

public class Person{
  public void playGame(){}
}

3>包名

由多個單詞組成，每一個單詞之間用 . 隔開，全部單詞一概小寫。

例如：

package cn.xjd.example
public class Person{
  public void playGame(){}
}

4>常量名

由多個單詞組成，每一個單詞之間用 _ 隔開，全部單詞一概大寫。

例如：

package cn.xjd.example
public class Person{
  private static final int DEFAULT_CAPACITY=0;
  public void playGame(){}
}

例題

這個地方會有一個比較坑的題，並且是明坑：

下面那些能夠做爲Java標識符使用？

A.Class B.String C.main D.com.cn.list

答案是ABC。

三、註釋

解釋說明程序的文字。

1．分類

1>單行註釋

單行註釋也叫短註釋，是程序中註釋一行代碼。

格式：// 註釋文字

package cn.xjd.example

//這裏能夠加註釋
public class Person{
  //這裏能夠加註釋
  private static final int DEFAULT_CAPACITY=0;
  //這裏能夠加註釋
  public void playGame(){
    //這裏能夠加註釋
  }
}

2>多行註釋

多行註釋也叫塊註釋，一次將程序中的多行註釋掉。

格式：/*註釋文字*/

3>文檔註釋

文檔註釋能夠將其中的註釋文字提取出來造成HTML格式API文檔。

格式：/**註釋文字*/

使用javadoc命令能夠將文檔註釋內容提取出來，可以使用此命令的類必定要是公共類。

命令格式：javadoc -d 表示存放的目錄提取的Java文件

2．做用

解釋程序，輔助排錯。

四、常量（constants）

一共有6類常量，整數、小數、字符、字符串、布爾、空。

1．整數常量

全部的整數。好比：四、100。

2．小數常量

全部的小數。好比：3.五、 80.1

3．字符常量

將一個字母、數字或者符號用‘’來標識起來的時候，構成了一個字符常量。好比：‘a’、 ‘+’。

4．字符串常量

將一個或者多個字符用「」來標識起來，就造成了字符串常量。好比：「abc」、「」。

5．布爾常量

用於表示邏輯值。只有true、false。

6．空常量

只有一個值null。

五、進制

進制是一種計數方式。Java中經常使用的進制有：二進制、八進制、十進制、十六進制。

1．二進制(Bin：Binary：0b)

單位取值範圍：0-1，規則：滿二進一。從JDK1.7開始，容許在程序中去標識一個二進制數字，以0b做爲開頭。例如：0b00011 、0B11001。

2．八進制(Oct：Octal：0)

單位取值範圍：0-7，規則：滿八進一。八進制須要以0做爲開頭標識。例如：06 、012。

3．十進制(Dec：Decimal)

單位取值範圍：0-9，規則：滿十進一。十進制做爲咱們經常使用的進制方式，不須要任何標識做爲開頭，也是Java中的默認進制。

4．十六進制(Hex：Hexagondecimal：0x)

單位取值範圍：0-9，A-F（表示的是10-15），規則：滿十六進一，例如：9+1=a f+1=10 。十六進制須要以0x做爲開頭標識，例如：0x2三、0Xab。常見於內存地址。

5．進制轉換

1>10轉2

十進制向二進制轉化：不斷地除以2而後取餘，將餘數倒排。

2>2轉10

二進制向十進制轉化：從低位次開始，每位上乘以2的位次次冪，而後求和。

3>2轉8

二進制向八進制轉化：從低位次開始，每三位化爲一組產生一個八進制數字，最高位不足三位，補0。三變一的過程。

4>8轉2

八進制向二進制轉化：一變三的過程。

5>2轉16

二進制向十六進制轉化：四變一的過程。

6>16轉2

十六進制向二進制轉化：一變四的過程。

6.進制轉換圖

六、變量（variable）

1．定義

用於記錄或者存儲數據的容器。

2．聲明變量

Public class A{

  Public static void main(String[] args){

    //定義變量格式：

    int i;

    int i=5;

    int i,j,k;

    int i=3,j=4,k=5;

  }

}

3．特色

1.須要指明數據類型。

2.變量在哪兒定義就在哪兒使用。

3.變量必須先定義後使用。

4.變量必須先給值後使用。

注意：聲明和初始化時兩個過程。

3、數據類型（data type）

一、基本數據類型

8種基本數據類型。各個基本類型之間是平等的，不存在大小和父子類的關係。它們之間的大小隻是從存儲數據所佔用的空間來比較的。

1．數值型

1.在Java中，整數默認是int，小數默認爲double。

2.若是一個整數超過了int的取值範圍，須要加上L做爲結尾標識是一個long類型的數據。

3.Float類型的小數結尾必須以f做爲標識。

4.注意科學技術法。

1>整數型

四種類型：byte、short、int、long。

①byte

字節型：佔1個字節的空間，取值範圍：-27~27-1，即： -128~127 ，一共256個存儲空間。這個須要死記。

byte=127;

byte=-128;

②short

短整型：佔2個字節的空間，取值範圍：-215~215-1 ，即：-32768~32767，一共65356個空間。

③int

整型：佔4個字節的空間，取值範圍：-231~231-1，即： -2.1*1010^2.1*1010。

Java中整數默認爲int類型。

從JD1.7開始，容許在數字之間插入「_」做爲間隔，在編譯的時候會自動省略「_」。

    int i=0b0011;

    int i=0x23;

    int i =100_000_000; //表示：100000000

④long

長整型：佔8個字節的空間，取值範圍：-263~263-1，即：-9*1018~9*1018。要求以L做爲結尾進行標識。通常在使用的過程當中，最好使用大寫L，由於小寫的容易和數字1混淆。

long l = 5L;//（大寫後綴）

long l=5l;//（小寫後綴）

2>浮點型

①float

單精度：佔4個字節的空間，取值範圍：-2127~2127，即：-3.4*1038~3.4*1038。要求以f做爲結尾進行標識。

float f = 3.2f;

②double

雙精度：佔8個字節的空間，取值範圍：21023~21023，即：-10308~10308。Java中小數默認爲double類型。

//正確寫法

double d = 4.6;  

double d2 = 6.3d;

double d3 = 3.8D;

double d =3e4;->double d = 30000.0;//十進制的科學計數法的表現形式。

double d=3p2;//十六進制的科學計數法的表示形式。

3>科學計數法

十進制的科學計數法：

3.1 * 1010

double d = 3.1e10;

十六進制的科學計數法：

3 * 25

double d2 = 0x3p5;

注意：Java中的數值類型都是有符號的。

2．字符型

1>char

字節型：佔2個字節的空間，取值範圍： 0~216-1 ，即：0~65535。不容許定義空字符。

char c = 'a';

char c = '中';  

char c = ''; //不容許定義空字符

char c='\t';

默認值：’\u0000’:表示’’。以\u開頭表示這個字符是他對應的UTF-8的編碼。

字符能夠按照碼錶對應成數字。

編碼：

阿斯科瑪表：ASC11，0-127。

西歐碼錶：ISO8859-1,0-255。

GB2312：前256位都只佔1個字節，2個字節表示一個漢字。

GBK

Unicode編碼體系：UTF-8，收錄了常見語言的常見字符。3個字節表示一個字符。又叫萬國碼表。

Java的默認編碼是UTF-8。

全部的碼錶所有兼容西歐碼錶，因此前256位全都只佔1個字節。

2>轉義字符

轉義字符：\，基本全部的編程語言中\都是轉義字符。

\’ 單引號 \\ 反斜槓 \」雙引號 \t 製表符 \r-return回車符 \n---newLine 換行符。

從JDK1.7開始，\r和\n功能一致。

3．布爾型

1>boolean

true/false 大小如今沒作限定。大小根據操做系統和JDK版本不一樣而定。默認值是false。

boolean b = true;

二、引用數據類型（略）

1．分類

類:class，接口:interface，數組:[],原生類Arrays，枚舉。

三、數據類型的轉換

1．隱式類型轉換

隱式類型轉換又叫作自動類型轉換。

整轉小，小轉大。

byte b = 10;
int i = b;

規律一：小類型能夠自動轉化爲大類型。

float f = 4.2f
double d = f;
int i = 10;
float f = i;

規律二：整數能夠自動的轉化爲小數,可能會出現精度損失問題。

long l = 9L;
float f = l;
float f = -25;//true
float f = 25.0; //false
char c = '大';
int i = c;
double = i;

規律三：char能夠自動轉化爲int。

char c = '大';
int i = c;
long l = c;
double = i;
char c = 98;//true
short s= 'b';//true
char c='b';
short s= c;//false

由於兩句話是分開編譯的，因此範圍沒法肯定。

char c =-1;//編譯報錯

隱式轉換的規律能夠用下圖表示：

char c = 98;//---能夠
short s = 'g';//---能夠
char c = 98;
short s = c;

在代碼編譯期間，JVM會檢查數據的類型和聲明的類名是否一致或者兼容。若是在賦值的時候數據是一個變量，不會去檢查這個變量的值而是檢查變量的類型和聲明的數據類型是否兼容。

float f = 30;//---true
float f = 30.0f;
long l = '中';//---true
long l = 100;//---true---若是一個整數在int的取值範圍內，能夠不用添加L做爲結尾

2．顯式類型轉換

顯式類型轉換又叫作強制類型轉換。

若是大類型賦值給一個小類型或者是把一個小數賦值給一個整數的時候就要使用顯式轉換。

當把大類型的轉換爲小的類型的時候，須要強制轉換。

當把浮點型數據轉換爲整型變量的時候，須要強制類型的轉換。小數轉換成整數的時候，不是四捨五入，而是捨棄掉小數部分，所以，小數轉換整數的時候，也會產生精度損失。

int i = 10;
byte b = (byte)i;
double d = 3.99;
int i = (int)d; //-> 3 -> 小數在強制轉換爲整數的時候會捨棄全部的小數位。
int i = 200;
byte b = (byte)i;//---能夠

注意：在計算機中，絕大部分小數是沒有辦法精確表示的。

4、運算符

分六類：算數運算符、賦值運算符、比較/關係運算符、邏輯運算符、位運算符、三元/三目/條件運算符。

一、算術運算符

七個運算符：+加、-減、*乘、/除、%取模、++自增、--自減、+字符串拼接。

Java是一門強類型的語言，對每種數據類型都嚴格劃分了數據類型。

int i =4350/1000*1000; //i結果爲4000
//兩個int類型參與運算，結果也是int類型。

1．規則

1. byte/short在運算的時候會自動的提高爲int，而後進行運算，運算結果爲int。

2. 同一個類型參與運算，結果的類型與參與運算的類型一致。

這裏有個點就是int以前的類型，在參加運算的時候會轉爲int類型，因此是兩個int類型參加運算，結果爲int類型，沒錯，和第一條不衝突。

3. 若是運算過程當中有大類型參與了運算，結果必定是大類型。

4. 因爲絕大部分小數在轉化成二進制的時候是無限小數，因此double類型在存儲小數的時候也沒有辦法精確存儲，所以也沒有辦法來精確運算。

5. 整數/0 ：ArithmeticException（算數異常）。

任意非0數字/0.0或者是任意小數/0 結果爲Infinity（無窮大）。

0/0.0結果爲NaN-> Not a Number（非數字）NaN和任何值都不相等包括其自己。

判斷一個對象是不是NaN只有一個方法isNaN();。

2．%（取模運算/取餘）

5 % 3 = 2 1 % 4 = 1 -8%3=-2 8%-3=2 -8%-3=-2

肯定結果符號：

在作取餘運算的時候，先按正數進行取餘，而後看%左邊數字的符號，若是%左邊的數字是正數，那麼結果就是正數，反之則爲負。

例如：

3.2 % 2 = 1.2 5.4%1.7=0.3 -3.5%1.7=-0.1

3．++/--

至關於在原來的基礎之上自增/自減1。

++ 在變量名以前，表示先自增，自增完成以後纔會參與其餘運算。

++ 在變量名以後，表示先拿變量的原來的值參與運算，而後再自增。

例如：

int i = 5;
//int j = ++i; -> i = i + 1; -> int j = i; -> j = 6;
int j = ++i * 2;// -> i = 6, j = 12;
int i = 5;
// int j = i++; -> 表示先把5拿出來，i自增爲6，而後把5賦值給j
int j = i++ * 2; -> i = 6, j = 10;//->先把i的值5取出來參與乘法運算，而後i自增
int i = 3;
// int j = i++ + ++i; -> i = 5, j = 8;
int j = ++i + i++; //-> i = 5, j = 8

注意：byte/short類型能夠參與++/--運算，並且運算完成以後依然是原來的類型，Java在底層已經進行了強制轉換。

byte b=127;
b++;//值爲-128

4．+字符串拼接

「a」+」b」 --->」ab」 2+3+」a」--->」5a」

String s = "a";
s = s + "b"; //-> s = 「ab」

能夠利用+將兩個字符串進行拼接，或者也能夠利用+將任何數據與字符串進行拼接。

二、賦值運算符

十二個運算符：=（等於）、+=（加等）、-=（減等）、*=（乘等）、/=（除等）、%=（取餘等）、&=（與等）、|=（或等）、^=（異或等）、<<=（左移等）、>>=（右移等）、>>>=（無符號右移等）。

注意：除了=之外，其他的賦值運算符要求這個變量必須有初始值。

byte/short能夠參與賦值運算，運算結果還是原類型。

例如：

byte b =25;
b += 5;

int i = 5;
i += i -= i *= 3;// --->-5
i += i -= i *= i++;// ---> i = -15
i+= i -= i *= i ++ * 2;//--->i=-40
i = 5+ (5 - ( 5 * 5));

三、關係運算符

關係運算符又叫比較運算符。

七個運算符：==等於、!= 不等於、>(大於) 、<（小於）、>=（大於等於）、<=（小於等於）、instanceof（判斷對象於實例的關係）。

int i = 4;
int j = 5;
i == j; //-> false
i != j; //-> true
i > j; //-> false

1．instanceof

用於判斷對象是不是否對應類的實例的。

"abc" instanceof String; //-> true

運算完成以後結果是一個boolean類型的值。

四、邏輯運算符

六個運算符：&與（And）、|或（Or）、!非(Not)、^異或、&&短路與、||短路或。

1．&運算規則：

true&true=true;
true&false=false;
false&true=false;
false&false=false;

見false爲false。

2．|運算規則：

true|true=true;
 true|false=true;
 false|true=true;
 false|false=false;

見true爲true。

3．!運算規則：

!true=false;
!false=true;

非否便是，非是即否。

4．^運算規則：

true^true=false;
 true^false=true;
 false^true=true;
 false^false=false;

相同則爲false，不一樣則爲true。

5．&&運算規則：

對於&&而言，若是前邊的表達式的結果爲false，則後邊的表達式就再也不運算。

6．||運算規則：

對於||而言，若是前邊的表達式的結果爲true，則後邊的表達式就再也不運算。

int i = 3,j = 4,k = 5;
boolean b = i > j && k++ > 3||i++ > 2;
System.out.println(i);
System.out.println(j);
System.out.println(k);

注意：短路特性能夠提升代碼的運算速度。

五、位運算符

7個運算符號：

&（與）、|（或）、 ^（異或）、<<（左移）、>>（右移）、>>>（無符號右移）、~（取反）。

注意：位運算針對的是整數，運算的是數據的補碼。能夠利用&來判斷是不是奇偶數。

1．原、反、補碼

數據在計算機中是以補碼形式來存儲的。最高位是一個符號位：若是是正數，最高位爲0，若是是負數，最高位爲1。對於正數而言，原反補三碼一致。負數的反碼是在原碼的基礎上，最高位不變，其他位0變1,1變0，負數的補碼是在反碼的基礎上+1。

6- 00000000 00000000 00000000 00000110---原碼/反碼/補碼

-6 - 10000000 00000000 00000000 00000110---原碼

11111111 11111111 11111111 11111001---反碼

11111111 11111111 11111111 11111010---補碼

11111111 11111111 11111111 11101101---補碼

11111111 11111111 11111111 11101100---反碼

10000000 00000000 00000000 00010011---原碼--- -19

2．與或非運算規則

奇數^偶數=奇數

a ^ b ^ b = a;   
b ^ b ^ a = a;

1>交換兩個數的值

int i = 3, j = 5;

方式一：第三方變量（經常使用）

int k = i;
i = j;
j = k;

方式二：加減法

i = i + j;
j = i - j;
i = i - j;
//簡化形式
i+=j;j=i-j;i-=j;

方式三：異或（效率更高）只針對整數運算。

i = i ^ j;
j = i ^ j; //----> j = i ^ j ^ j; -> j = i;
i = i ^ j; //----> i = i ^ j ^ i; -> i = j;
//簡化形式
i ^= j; j ^= i; i ^= j;

3．位移運算規則

注意:

Java中全部的數值類型的數據都是有符號的。

baty/short參加左移和右移和無符號右移結果爲int。

一個數字右移幾位就是將這個數字除以2的幾回方，而後取整。

取反快捷運算：~i= - i - 1

六、三元運算符

三元運算符又叫三目運算符，還可叫作條件運算符。

1．格式

邏輯值？表達式1 ：表達式2;

例如：

int i = 4, j = 7;
int k = i > j ? i : j;
System.out.println(k);//結果爲j。

2．執行順序：

若是邏輯值爲true的話，執行表達式1,；反之執行表達式2。

①三元表達式在運算完成以後必須有一個結果。

//不容許，運算完成以後，沒有結果。
A > b ? System.out.println( a ) : System.out.println( b );

②表達式1和表達式2的結果必須是相同類型或相容。

double d = a > b ? a * 2 : a * 2.5;

③在三元表達式造成嵌套的時候，儘可能添加()來提升代碼的可讀性

int max = a > b ? ( a > c ? a : c ) : ( b > c ? b : c );

面試題

下面的代碼有什麼問題？

int i = 3 , j = 4;
System.out.println( i > j ? true : false );

語法上沒有什麼問題， i > j ? true : false和i < j 的結果是同樣的，在代碼上形成了冗餘。

練習

判斷是不是一個奇數？

int i=10;
boolean bo =i%2==0;

成績>=90，顯示輸出A；成績>= 80，顯示輸出B；成績>= 60，顯示輸出C；成績< 60，顯示輸出D。

能夠本身練習如下這道題。

八、運算優先級

大致上是先進行一元運算，而後是二元運算，再是三元運算，最後是=。

一元運算：！、++/--、~、

二元運算：算數、比較、邏輯、位。

我的總結的大致優先級以下：

（）、！、++/--、~、算數（*、/、%、+、-）、比較、邏輯（先或後與）、位（<<、>>、>>>、&、|、^）三元、賦值。

5、流程控制

一、順序結構

是指代碼是從上到下從左到右依次運行的。

二、分支結構

分支結構分爲判斷結構和選擇結構。

1．判斷結構

1>if

格式：if( 邏輯值 ){ code;}

若是邏輯值爲true，執行對應的代碼塊，反之則不執行。

注意：if後面的{}。只有一句代碼的時候能夠省略。

代碼示例：

import java.util.Scanner;//導包語句，位置要在class以外。
public class IfDemo {
  public static void main(String[] args){
    Scanner s = new Scanner(System.in);
    int i = s.nextInt();
    if(i > 10){//if語句
      System.out.println("hahah~~~");
    }
  }
}

練習：判斷三個數中的最大數。

這是一個經典練習，能夠本身作一下。

2>if-else

格式：if(邏輯值){Code1;} else {Code2;}

若是邏輯值爲true，執行Code1；反之執行Code2。

//判斷奇偶
import java.util.Scanner;
public class IfElseDemo {	
	public static void main(String[] args){
		Scanner s = new Scanner(System.in);		
		int i = s.nextInt();		
		if(i % 2 == 1){
			System.out.println(i + "is an odd number .");
		} else {
			System.out.println(i + "is an even number .");
		}	
	}	
}

練習

輸入三個數，獲取最大值

import java.util.Scanner;
public class Test1{
	public static void main(String[] args){
		Scanner s=new Scanner(System.in);
		int num1=s.nextInt();
		int num2=s.nextInt();
		int num3=s.nextInt();
		int max;
		if(num1>num2){
			if(num1>num3){
				max=num1;
			}else{
				max=num3;
			}
		}else{
			if(num2>num3){
				max=num2;
			}else{
				max=num3;
			}
		}
		System.out.println(max+" is max.");
	}
}

3>If-else if-else

格式：

if(邏輯值1){
Code1;
} else if(邏輯值2){
Code2;
}...else {
Code;
}

若是邏輯值1爲true，執行Code1；若是邏輯值1爲false，則判斷邏輯值2是否爲true，若是邏輯值2是true，則執行Code2。

import java.util.Scanner;
public class IfElseIfDemo {
	public static void main(String[] args){	
		Scanner s = new Scanner(System.in);		
		double score = s.nextDouble();
    If(score > 100||scpre < 0){
 System.out.println(erres);
}else if(score >= 90){
			System.out.println("A");
		} else if(score >= 80 ){
			System.out.println("B");
		} else if(score >= 60){
			System.out.println("C");
		} else {
			System.out.println("D");
		}	
	}
}

練習

輸入一個月份，輸出月份對應的季節 3-5-Spring 6-8-Summer 9-11-Autumn 12-2-Winter

import java.util.Scanner;
public class Test2{
	public static void main(String[] args){
		Scanner s=new Scanner(System.in);
		int month=s.nextInt();

		String season = "";
		if(month>=13||month<=0){
			season ="Wrong month !";
		}else if(month>=3&&month<=5){
			season ="Spring";
		}else if(month>=6&&month<=8){
			season = "Summer";
		}else if(month>=9&&month<=11){
			season ="Autumn";
		}else{
			season ="Winter";
		}
		System.out.println(season);
	}
}

2．選擇結構

1>Switch

格式

switch(表達式){
case 選項1: code1; break;
case 選項2: code2; break;
……
default: code;break;
}

注意

表達式的值只能是byte/short/char/int四種類型，JDK1.7開始，支持對String進行選擇，從JDK1.5開始容許表達式的結果是枚舉常量。

break對多行case代碼有影響。

若是case以後沒有break，那麼從匹配的case開始，依次往下執行，直到遇到break或者是switch語句結束。

若是每一個case以後都有break的話，case之間的順序不影響最後的結果；即便有一個case沒有break，這個時候case之間的順序會影響最後的結果。

明坑題

int i = s.nextInt();
// int j ;
switch(i){
  case 1 : int j = 0; 
  case 2 : j += 1; // 編譯報錯  可能還沒有聲明變量j
  case 3: j += 3; 
  default : System.out.println(j); 
}

練習

計算器一個符號和兩個數字 - 5 9-> 5 - 9 = -4

import java.util.Scanner;
public class SwitchCaseExer {
	public static void main(String[] args){	
		Scanner s = new Scanner(System.in);		
		String symbol = s.nextLine();
		int i = s.nextInt();
		int j = s.nextInt();		
		switch(symbol){
			case "+" : 
				System.out.println(i + j);
				break;
			case "-" :
				System.out.println(i - j);
				break;
			case "*" :
				System.out.println(i * j);
				break;
			case "/" :
				System.out.println(i / j);
				break;
			default:
				System.out.println("No this operation !");
		}	
	}
}

三、循環結構

三個要素：循環變量，循環條件，變量改變。

儘可能不要使用浮點型來做爲循環條件，由於小數在計算機中不可以精確存儲。

1．while

1>格式

while(判斷循環變量){
code;
}

2>執行邏輯

public class WhileDemo {
	public static void main(String[] args){	
		int i = 1;
		while(i <= 5){
			System.out.println("Hello");
			i++;
		}		
	}
}

練習

從控制檯輸入一個數字，求1-這個數字的和

import java.util.Scanner;
public class WhileExer1 {
	public static void main(String[] args){	
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();		
		/*
		int i = 1;
		int sum = 0;		
		while(i <= n){
			sum = sum + i;
			i++;
		}
		*/
		int sum = 0;
		while(n > 0){
			sum += n;
			n--;
		}		
		System.out.println(sum);		
	}
}

輸出500之內8的倍數

int i = 0;
		while(i <= 500){
			System.out.println(i);
			i += 8;
		}		
		/*
		while(i <= 500){
		
			if(i % 8 == 0){
				System.out.println(i);
			}
			i++;
		}
		*/

輸入一個數字，輸出這個數字是幾位數---3463-4

Scanner s = new Scanner(System.in);
		int number = s.nextInt();		
		int i = 0;		
		while(number != 0){
			number /= 10;
			i++;		
		}		
		System.out.println(i);

輸入一個數字，輸出各位數字之和--- 3463 - 16

Scanner s = new Scanner(System.in);
		int number = s.nextInt();		
		int sum = 0;
		while(number != 0){
			sum += (number % 10);
			number /= 10;
		}		
		System.out.println(sum);

輸入一個數字，輸出這個數的二進制。

Scanner s=new Scanner(System.in);
		int num =s.nextInt();
		String str="";
		while(num!=0){
			
			str= num % 2 + s;
			num/=2; 
		}
		System.out.println(str);

求PI的計算次數

public static void main(String[] args) {
		
		int i=0;
		int base =1;	
		double PI = 0;
		double sign =1.0;		
		while(PI >3.1415927 || PI < 3.1415926){
			
			PI = PI + 4 * sign/ base;
			i++;
			
			sign *= -1;
		
			base += 2;
		}
		System.out.println(i);
	}

2．do-whlie

1>格式

do{
Code;
}while(邏輯值);

2>執行邏輯

int i = 20;
		/*
		while(i <= 10){
System.out.println(i);
			i++;
}
		*/
		do{
			System.out.println(i);
			i++;
		}while(i <= 10);

注意：do--whlie循環中代碼塊至少執行一次。

3．for

1>格式

for(定義循環變量;循環條件的判斷;循環變量的改變){
Code；
}

2>執行邏輯

當循環變量改變相對比較規律的時候，建議使用for循環。

當不知道循環次數的時候，建議使用while。

While循環，循環變量定義在循環外，循環結束以後循環變量依然可使用；for循環的循環變量是定義在for循環裏邊的，循環結束以後，循環變量不能繼續使用。

for(int i = 1; i <= 5; i++){
			System.out.println("Hello");
		}
		*/
		int sum = 0;
		for(int i = 1; i <= 100; i++){
			sum += i;
		}

練習

求一個數二進制的1的個數。

一個int 類型的整數由32 個二進制位組成，每一個二進制位的值要麼爲0 要麼爲1。要求讀入一個int 類型的整數n，計算它的32 個二進制位中總共有多少位爲1？

public static void main(String[] args) {

		Scanner s=new Scanner(System.in);
		int number =s.nextInt();
		s.close();
		
		int j=0;
		for (int i = 0; i < 32; i++) {
			if((number &1)==1){
				j++;
			}
			number >>=1;
		}
		System.out.println(j);
	}

4．循環的嵌套

循環結構中包含了其餘的循環結構，造成了循環的嵌套。

循環嵌套能夠實現也下功能：

public class ForDemo2 {
	public static void main(String[] args){
		/*
			*****
			*****
			*****
			*****
		*/
		
		for(int j = 1; j <= 4; j++){
			for(int i = 1; i <= 5; i++){
				System.out.print("*");
			}
			System.out.println();
		}
			
		/*
			*
			**
			***
			****
			*****
			row: 1 -> 5
			*: 1 -> i
		*/
		
		for(int i = 1; i <= 5; i++){			
			for(int j = 1; j <= i; j++){
				System.out.print("*");
			}
			System.out.println();			
		}
		
		
		/*
			*****
			****
			***
			**
			*
		*/
		
		for(int i = 5; i > 0; i--){
			
			for(int j = i ; j > 0; j--){
				System.out.print("*");
			}
			System.out.println();
		}
		
		/*
			----*
			---**
			--***
			-****
			*****
			row:1-5
			" ": 1 -> 5 - i
			*: 1 -> i
		*/
		for(int i = 1; i <= 5; i++){			
			for(int j = 1; j <= 5 - i; j++){
				System.out.print(" ");
			}			
			for(int j = 1; j <= i; j++){
				System.out.print("*");
			}			
			System.out.println();
		}		
		/*
			*****
			 ****
			  ***
			   **
			    *
			row:5 -> 1
			" ": 5 - i -> 1
			* : i -> 1
		*/
		for(int i = 5; i > 0; i--){
			
			for(int j = 5 - i; j > 0; j--){
				System.out.print(" ");
			}			
			for(int j = i; j > 0; j--){
				System.out.print("*");
			}			
			System.out.println();			
		}			
	}
}

練習

九九乘法表

1*1=1

1*2=2 2*2=4

1*3=3 2*3=6 3*3=9

for(int i = 1; i <= 9; i++){			
			for(int j = 1; j <= i; j++){
				System.out.print(j + "*" + i + "=" + i * j + "\t");
			}			
			System.out.println();
		}

百錢買百雞

3 文錢能夠買1只公雞，2 文錢能夠買一隻母雞，1 文錢能夠買3 只小雞。用100 文

錢買100 只雞，那麼各有公雞、母雞、小雞多少隻？

水仙花數

所謂水仙花數，是指一個三位數abc，若是知足a3+b3+c3=abc，則abc 是水仙花數。（善用%）

5．break和continue

1>break

做用於選擇結構和循環結構，表示終止當前的一層語句。

2>continue

只能做用於循環結構，表示跳出當前的一次循環繼續下次循環。

這兩個關鍵字必須結合相應的語句使用個，單獨存在沒有意義，所以單獨存在的時候編譯報錯。

Java中，不容許廢話存在，存在廢話就會編譯報錯。

3>循環標號

Java中支持對循環進行標號。

當須要一次性跳出多層循環的時候，可使用標號形式，可是不推薦使用，由於下降了程序的閱讀性。

A:for(int i = 0 ; i < 3; i++){		//A爲標號
			B:for(int j = 0; j < 4; j++){
				for(int k = 1; k < 6; k++){				
					if(k == 3){
						break A;
					}
                    If(k==1)
                        continue B;					
					System.out.println(i + "," + j + "," + k);
				}
			}
		}

練習

判斷質數

一個數除了1和自己不能整除其餘的數。（使用Math.sqrt()注意2和3的判斷。）

分解質因數

100 = 2 * 2 * 5 * 5; 18 = 2 * 3 * 3;

import java.util.Scanner;
public class Exer{
	public static void main(String[] args){
		Scanner s=new Scanner(System.in);
		int number = s.nextInt();
		while(number!=1){
			for(int i=2;i<=number;i++){
				if(number%i==0){
					System.out.println(i);
					numbber/=i;
					break;
				}
			}
		}
	}
}

6、數組（Array）

分爲一維數組和二維數組。

一、一維數組

1．定義

存儲一組同一個類型數據的容器叫作數組。

數組對每個存入的數字都會自動編號，編號是從0開始的，這個編號叫下標。

2．格式

聲明數組的格式有三種。

1.數據類型[] 數組名 = new 數據類型[表示數組能存放的元素個數];

適用於一些知道元素個數而不知道具體元素的場景。

int[] arr = new int[5]; 表示定義了一個能存儲5個int類型的數據的數組。

int arr[];//容許先聲明，再初始化。
arr = new int[3];
int[] arr1 = new int[5];
arr[2] = 15; int i = arr[2];
System.out.println(arr[2]);

2.數據類型[] 數組名 = new 數據類型[]{元素1，元素2，……，元素n};

同時也就規定了數組的大小就是元素的個數。

int[] arr = new int[]{3,5,1,2,5};
int[] arr1;//容許先聲明再初始化。
arr1 = new int[]{3,5,1,2,4,7}
arr[3] = 10;

注意：數組一旦定義好，大小不可變

3.數據類型[] 數組名 = {元素1，元素2，……，元素n};

int[] arr = {2,6,4,7,9};

3．內存

這裏有必要先提一下，java JVM的內存。

Java將內存分爲了五塊：棧內存，堆內存，方法區，本地方法棧，寄存器。

注意：內存的初始化過程在程序以前，內存在初始化完成以後纔會賦值。

對於基本類型而言，傳值傳的是實際值，對於引用類型而言傳值傳的是地址。

1>棧內存

存儲變量，執行代碼塊的。

①變量是存儲在棧內存中的。

②變量在棧內存中用完以後當即移除，釋放內存空間，提升內存的利用率。

③變量在棧內存中不會自動賦予默認值。

2>堆內存

存儲對象。對象在堆內存中會自動的賦予一個默認值。對象在使用完成以後，不會當即移除，而是在不定的某個時刻被回收。

①默認值

byte/short/int 默認值是0。

long 的默認值是0L。

float的默認值是0.0f。

double的默認值是0.0。

char 的默認值是‘\u0000’。

boolean 的默認值是false。

全部的引用類型的默認值所有都是null。

3>棧堆關係

ArrayIndexOutBoundsException ：數組下標越界異常。

編譯沒有問題，說明語法沒有問題，邏輯上或者事實上不符合，纔會運行報錯。

NullPointerException ：空指針異常。

4．數組的應用

1>獲取指定位置上的元素

數組名[下標]：arr[n];。

2>獲取數組的長度

數組名.length：arr.length;。

3>遍歷數組（ergodic array）

①普通for循環

for(int i = 0;i < arr.length; i ++){
System.out.println(arr[i]);
}

②加強for循環

1.加強for循環是基於迭代器。

2.沒法改變原來數組的元素。

// 表示把數組中的元素依次取出賦值給i
for(int i : arr){
	System.out.println(i);
}
for(String s : arr){
System.out.println(s);
}

③Arrays.toString();

將數組中的元素依次取出，拼接成一個字符串。

String str = Arrays.toString(arr);
System.out.println(Arrays.toString(arr));

4>獲取數組元素的最值。

獲取最大值用遍歷數組。

①加強for循環

int max = arr[0];
		for(int i : arr){
			if(max < i){
				max = i;
			}
		}
		System.out.println(max);

②普通for循環

int max = 0;
		for(int i = 0; i < arr.length; i++){
			if(arr[i] > arr[max]){
				max = i;
			}
		}
		System.out.println(arr[max]);

5>數組元素排序

數組元素排序有冒泡排序、選擇排序、快速排序、希爾排序、堆排序等多種排序方法。

①冒泡排序

方法以下：

for(int i = 1; i <= arr.length - 1; i++){
			for(int j = 1 ; j <= arr.length - i; j++){
				if(arr[j - 1] > arr[j]){
					int temp = arr[j - 1];
					arr[j - 1] = arr[j];
					arr[j] = temp;
				}
			}
		}

②選擇排序

這個方法我尚未整理出來，後期整理出來，會補上的。

③Arrays.sort()

須要導包語句，只能從小到大排序。

import java.util.Arrays;
Arrays.sort(arr);

6>查找元素的位置

①遍歷

針對無序數組。

class MyClass{
  public static void main(String[] args){
    int[] arr={5,6,2,4,8,1,3,7};
    int a = 4;
    int index = -1;
    for(int i=0;i < arr.length;i++){
      if(arr[i]==a){
        index = i;
        break;
      }
   }
   System.out.println(index);
  }
}

②折半查找（掌握）

針對有序數組。時間複雜度：O(log2n)

class MyClass{
	public static void main(String[] args) {
		int[] a={1,3,4,6,8,9,15,19,25,36,48};
		int num=25;		
		int min=0;
		int max=a.length-1;
		int mid=(min+max)/2;
		boolean b=true;
		while(min<=max){
			if(num==a[mid]){
				System.out.println(mid);
				b =false;
				break;
			}else if(num>a[mid]){
				min=mid+1;
			}else if(num<a[mid]){
				max=mid-1;
			}
			mid=(min+max)/2;
		}
		if(b)
		System.out.println("no");
	}
}

7>反轉數組

頭尾交換數組的元素。

方法一：利用第三方數組。

方法二：利用兩個變量同時操做數組的兩端。

int[] arr = {12,15,26,38,49,80,91};
		for(int start = 0, end = arr.length - 1; start < end ;start++,end--){
			int temp = arr[start];
			arr[start] = arr[end];
			arr[end] = temp;
		}
		System.out.println(Arrays.toString(arr));

注意：若是訪問的下標不存在，會出現ArrayIndexOutOfBoundsException---數組下標越界異常---編譯的時候沒有報錯---由於語法無錯。---因此編譯檢查的是語法問題。

8>數組的擴容/複製

其實是產生了一個新的數組。

①System.arraycopy()

System.arraycopy(要複製的數組, 要複製的起始下標, 要存放的數組, 存放的起始位置, 複製的元素的個數);

System.arraycopy(arr,3,arr1,2,4);
//從arr中3的位置開始複製，存放到arr1中，從arr1中2的位置開始存放，複製4個元素。

int arr ={1,2,3,4,5};
int arr1=new int[arr.length * 2];
System.arraycopy(arr,0,arr1,0,arr.length);
arr=arr1;

②Arrays.copyOf()

arr=Arrays.copyOf(要擴容的數組, 擴容以後的大小);

數組在擴容完成以後，堆內存的地址已經發生了改變，底層使用的就是System.arraycopy();。

Arrays.copyOf(arr,len);//底層代碼。

int[] arr={1,2,3,4}
int[] arr2 = new int[len];
if(len < arr.length){
System.arraycopy(arr,0,arr2,0,len);
} else {
System.arraycopy(arr,0,arr2,0,arr.length);
}
arr = arr2;

二、二維數組

1．定義

二維數組的每個元素就是一個一維數組，是一個存放數組的容器。實際上二維數組中存儲的是一維數組在堆內存中一維數組的內存地址。

2．格式

聲明二維數組的格式也有三種。

1.數據類型[][] 數組名 = new 數據類型[二維數組的大小][一維數組的大小];

int[][] arr = new int[3][5];

表示定義了一個包含了3個一維數組的二維數組，每一個一維數組包含5個整數元素。

arr[1][3] = 5;//賦值
int[]arr[] = new int[3][5];
int arr[][] = new int[3][5];
int[] arr2 = arr[0];//--獲取的是一個一維數組。
arr[0][2];// ---獲取具體的元素，須要兩個下標。

2.數據類型[][] 數組名 = new 數據類型[二維數組的大小][];

int[][] arr = new int[5][];//---表示二維數組中包含5個一維數組。
int[][] arr =new int[5][];
//給每一個一維數組規定長度。
arr[0] = new int[5];
arr[1] = new int[3];
arr[2] = new int[0];
arr[3][0] = 8;//---NullPointerException---空指針異常

注意：針對null的任何操做都會出現空指針異常

3.數據類型[][] 數組名 = {{元素1，元素12，……}，{元素21，元素22，……}，……{}};

int[][] arr = {{2,3}, {1}, {3,5,6}, {1,2,3,7}, {1}};

筆試題總結：

對於數組int[] x, y[]均已初始化，下面各項正確的是：--- BC --- y[][] x[]

A. y[0] = x[0];

B. y[0] = x;//一維數組賦值給二維數組。

C. y[0][0] = x[0];//一維數組的具體值，賦值給二維數組的具體元素。

D. y[0][0] = x;

E. y[0] = x[0][0];

注意：[]在變量名以前緊跟的是數據類型，之後定義的每個變量都會擁有這個[]；若是[]在變量名以後，那麼[]只屬於當前的變量。

3.應用：

2>二維數組的長度

數組名.lenght。 arr.length 每一個一維數組：數組名[下標].lengyh。 arr[0].length

3>遍歷

遍歷二維數組須要兩層循環。

①雙層for循環。

for(int i=0;i<arr.length;i++){
  for(int j=0;j<arr[i].length;j++){
   System.out.println(arr[i][j]);
  }
}

②Arrays.toString();

輸出的是二維數組中存儲的一維數組的地址。

4>二維數組的反轉

二維數組裏面的各個一維數組頭尾交換位置。

for(int statt = 0,end = arr.length - 1; start < end ; start++,end--){
  int temp[] = arr[start];
  arr[start] = arr[end];
  arr[end] = temp;
}

練習：

楊輝三角（二維數組）

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];

輸入一個數n，輸出前n行

//從控制檯獲取行數
Scanner s = new Scanner(System.in);
int row = s.nextInt();
//根據行數定義好二維數組，因爲每一行的元素個數不一樣，因此不定義每一行的個數
int[][] arr = new int[row][];
//遍歷二維數組
for(int i = 0; i < row; i++){
	//初始化每一行的這個一維數組
	arr[i] = new int[i + 1];
	//遍歷這個一維數組，添加元素	
	for(int j = 0; j <= i; j++){
		//每一列的開頭和結尾元素爲1，開頭的時候，j=0，結尾的時候，j=i
		if(j == 0 || j == i){
			arr[i][j] = 1;
		} else {//每個元素是它上一行的元素和斜對角元素之和
			arr[i][j] = arr[i -1][j] + arr[i - 1][j - 1];
		}
		System.out.print(arr[i][j] + "\t");
	}
	System.out.println();
}

7、方法（method）

一、定義

將一段邏輯或者功能提取出來，這種提取的形式就是方法，也叫函數。

爲了實現某段代碼的重複利用，將這段代碼進行封裝，這種封裝的形式就是方法，也叫函數。

二、格式

修飾符 返回值類型 方法名(參數列表){
方法體；
return 返回值;
}

聲明方法要注意兩點：

1.明確返回值類型。方法執行完成以後，返回值的數據類型是什麼方法的返回值類型就是對應的類型。

例如：求整型數組的元素之和，肯定返回值類型是int。

2.明確是否須要參數。若是方法執行過程當中須要一些未知量參與運算，而未知量在方法中不能自動產生，那麼這個時候須要以參數的形式體現。

聲明一個參數實際上就是聲明瞭變量，形式參數，也叫形參。

// 方法簽名---add(int[])
public static int add(int[] arr){
	int sum = 0;
	for(int i : arr){
		sum += i;
	}
	return sum;
}

在調用函數傳入的實際值叫實際參數，也叫實參。

add(arr);

1．注意：

1.若是方法執行完成以後沒有返回值，那麼返回值類型就是void。

2.return以後的代碼就執行不到了，一個函數一旦return，那麼後續代碼就再也不執行了。

3.任何一個實體方法內均可以寫return語句。

三、方法的重載

1．定義

當同一個類內出現了方法名一致而參數列表不一樣的方法的時候，構成了方法的重載。

方法名一致而參數列表不一樣，方法名+參數列表叫作方法簽名，和修飾符、返回值類型、異常等無關，是一種編譯時多態。

public static int add(int i,int j){ code }
public static double add(int i ,double d){ code }
public static double add(double d,int i){code}
public static int add(int i,int j,int k){ code }

方法在調用的時候會進行最優匹配。找參數類型最符合的進行匹配。

若是進行方法的重載，儘可能重載全部的狀況，以防出現調用混亂的狀況。

四、方法的重寫

1．定義

當父子類中產生了方法簽名徹底一致的非靜態方法的時候，構成了方法的重寫/覆蓋。

重寫的標誌註解：@Override。

2．規則

注意：方法的重寫須要遵循「兩等兩小一大」

1.父子類中方法簽名必須一致。

方法重寫的前提，父子類中能夠出現方法名稱同樣簽名不同的方法。

2.若是父類中方法的返回值類型是基本類型/void/最終類，那麼子類重寫的方法的返回值類型必須一致。

注意：八種基本類型之間沒有繼承關係。

class A {
  public void m(){}
}
class B extends A {
  public void m(){}
}

3.若是父類方法的返回值類型是引用數據類型，那麼子類重寫的方法的返回值類型是父類方法返回值類型的子類或者是自己。

Class A{
  Public void m(){}
}
Class B extends A{
  Public void m(){}
  Public void mb(){}
}
Class C{
  Public B mc(){return new B();}
}
Class D extends C{
  Public A mc(){return new A ();}
  //D類的mc方法沒有C類的大，若是使用向上造型建立C類對象，使用會有範圍的衝突。B類的東西比A類多有寫東西實現不了。
}

4.子類重寫的方法的編譯時異常必須是父類方法異常的子類或者自己。子類不能拋出比父類更多的異常，範圍不能更大，並且指的是編譯時異常。對於運行時異常不作限定。

5.子類重寫的方法的權限修飾符的範圍必須大於等於父類。

class A{
  public void m(){}
}
class B extends A {
  private void m(){}
}

 A a = new B(); 
// a對象使用A類來聲明的，A類告訴a對象身上有一個m方法，並且這個m方法是用public修飾的；
//等到具體使用的時候要看子類，子類是用B類來建立的，
//使用的時候發現B類中把這個方法聲明爲了private。產生了範圍衝突。

五、方法重寫和重載的異同

方法的重載和重寫都是一種行爲多態。

重載是指在同一個類中存在來方法名一致而參數列表不一樣的方法的現象。方法的重載只和參數列表中對應位置參數的參數類型是否一致有關，和其餘的元素無關；方法的重載是一種編譯時多態。

重寫是指在父子類中存在來方法簽名徹底一致的方法的現象。方法的重寫是基於繼承和實現存在的。方法的重寫要求方法簽名必須一致；在重寫的過程當中，若是父類方法的返回值類型是基本類型、void、最終列的時候，那麼子列對應方法的返回值類型要一致；若是父類方法的返回值類型是其餘引用類型，這個時候子類對應方法的返回值類型要是父類方法返回值類型的子類或者是自己。在重寫過程當中，若是父類方法拋出來異常而且該異常是編譯時異常的時候，子類重寫的方法能夠不拋出異常，或者是在父類編譯時異常的範圍下拋出，而對於運行時異常沒有限制。在重寫的過程當中，要求子類方法的權限修飾符要大於等於父類。重寫自己是一個運行時多態。因此對於靜態方法而言不存在重寫，可是父子類中容許存在方法簽名一致的靜態方法。

六、方法的遞歸

1．定義

函數調用本身自己就造成了遞歸。

//從1+到number的和。
public static int sum(int number){
	if(number <= 0){
		return 0;
	}
	return number + sum(--number );//函數調用本身自己。
}

練習

1>用遞歸求階乘

public static long factorial(int number){
  if(number == 0){
  return 1;
 }
  return number * factorial( -- number);
}

遞歸的效率會低一些。

控制好結束條件，若是遞歸層數太深，會出現棧溢出錯誤（StackOverFlowError）。

StackOverFlowError ：棧溢出錯誤，說明方法/函數在棧內存中執行。

注意：在傳遞參數的時候，對於基本類型而言，傳遞的實際值；對於引用類型而言，傳遞的是地址。只要地址不發生改變，函數中一切變化會做用於原數組。

七、做用

1.提升代碼的複用性。

2.代碼的結構更加清晰。

3.便於模塊化（團隊）開發

練習

判斷質數（prime）

import java.util.Scanner;
public class MethodExer1 {
	public static void main(String[] args){	
		Scanner s = new Scanner(System.in);
		int number = s.nextInt();		
		boolean b = isPrime(number);
		System.out.println(b);
	}
	public static boolean isPrime(int number){
		if(number <= 1){
			return false;
		}
		for(int i = 2; i <= number / 2; i++){
			if(number % i == 0){
				return false;
			}
		}		
		return true;
	}
}

2．親密數

A的全部因子（包含了1而不包含自己）之和等於B，而且B的全部因子（包含1而不包含自己）之和等於A，那麼A和B就是一對親密數。1000之內。

public class MethodExer2 {	
	public static void main(String[] args){		
		for(int i = 1; i <= 5000; i++){
			int b = sumAllFact(i);
			int c = sumAllFact(b);
			if(c == i && i < b){
				System.out.println(i + "," + b);
			}
		}		
	}
	public static int sumAllFact(int number){		
		int sum = 0;
		for(int i = 1; i <= number / 2; i++){
			if(number % i == 0){
				sum += i;
			}
		}
		return sum;
	}
}

3．任何一個大於等於6的偶數均可以分解爲兩個質數之和。

6= 3 + 3; 14 = 3 + 11 = 7 + 7 18 = 5 + 13 = 7 + 11

import java.util.Scanner;
public class MethodExer3 {
	public static void main(String[] args){	
		Scanner s = new Scanner(System.in);
		int number = s.nextInt();		
		while(number < 6 || number % 2 == 1){
			number = s.nextInt();
		}		
		for(int i = 3; i <= number / 2; i+=2){
			if(isPrime(i) && isPrime(number - i)){
				System.out.println(number + "=" + i + "+" + (number - i));
			}
		}	
	}
	public static boolean isPrime(int number){
		for(int i = 2; i <= number / 2; i++){
			if(number % i == 0){
				return false;
			}
		}
		return true;
	}
}

以上內容爲我的學習整理，若是錯誤，請你們批評斧正！