運行第一個JAVA程序：

這里使用的開發環境是eclipse，新建一個java工程，然后可以看到src這個是存放java代碼的地方，然后在src文件右擊新建一個class（類），然后可以看到下圖，同樣和C語言一樣java語言也有main函數，只是寫法不一樣，java語言的main函數寫法如下，同時java里面的打印函數和C語言也不一樣，java語言用的是System.out.println，如下圖進行打印，然后運行輸出hello world

JAVA SE、EE、ME的區別：

• Java SE（Java Platform，Standard Edition）。Java SE 以前稱為 J2SE。它允許開發和部署在桌面、服務器、嵌入式環境和實時環境中使用的 Java 應用程序。Java SE 包含了支持 Java Web 服務開發的類，并為 Java Platform，Enterprise Edition（Java EE）提供基礎。總的來說： JAVA SE就是最標準的java語言，就和最基本的C語言一樣，包含這個語言最基本的一些東西，在java里面包含一些最基本的繼承、多態等等

• Java EE（Java Platform，Enterprise Edition）。這個版本以前稱為 J2EE。企業版本幫助開發和部署可移植、健壯、可伸縮且安全的服務器端 Java 應用程序。Java EE 是在 Java SE 的基礎上構建的，它提供 Web 服務、組件模型、管理和通信 API，可以用來實現企業級的面向服務體系結構（service-oriented architecture，SOA）和 Web 2.0 應用程序。總的來說： JAVA EE相較于JAVA SE對了一些API（這些API是用來搞服務器用的，就相當于C語言面向linux的開發，也是多了一些API）

• Java ME（Java Platform，Micro Edition）。這個版本以前稱為 J2ME。Java ME 為在移動設備和嵌入式設備（比如手機、PDA、電視機頂盒和打印機）上運行的應用程序提供一個健壯且靈活的環境。Java ME 包括靈活的用戶界面、健壯的安全模型、許多內置的網絡協議以及對可以動態下載的連網和離線應用程序的豐富支持。基于 Java ME 規范的應用程序只需編寫一次，就可以用于許多設備，而且可以利用每個設備的本機功能。總的來說： 相對于JAVA EE也是多了一些API面向于嵌入式設備。主要針對消費者電子設備，為嵌入式應用提供開發和運行環境，例如手機程序和PDA程序等等，可以理解為單片機的C語言。

• 相比較于SE，EE和ME提供針對指向不同的API。

JRE、JDK：

• JRE: 百度百科：Java運行環境（Java Runtime Environment，簡稱JRE）是一個軟件，由太陽微系統所研發，JRE可以讓計算機系統運行Java應用程序（Java Application）。JAVA程序之所以可以跨平臺，就是有JRE，有了JRE，JAVA可以在windows、linux、手機環境下運行。只要在操作系統上裝了JRE那么就可以運行java程序，所以java的移植性比較好。JRE的內部有一個Java虛擬機 （Java Virtual Machine，JVM）以及一些標準的類別函數庫（Class Library）。
• JDK全稱Java Development ToolKit，是Java語言開發工具包。JDK是整個JAVA的核心，包括了Java運行環境（Java Runtime E nvirnment），一堆Java工具（javac/java/jdb等）和Java基礎的類庫（即Java API 包括rt.jar）。對于C語言來說，JDK有點像linux操作系統帶的C語言的運行環境同時帶了C庫。沒有JDK的話 無法編譯 JAVA程序（指java源碼的.java文件），如果想 只運行 jAVA程序（指class或jar或其他歸檔文件），要確已安裝相應的JRE。
• JDK包含的基本組件有：javac（編譯器，將源程序轉成字節碼，相當于C語言里面的gcc）、jar（打包工具，將相關的類文件打包成一個文件）、javadoc（文檔生成器，從源碼注釋中提取文檔，相當于man手冊）、jdb（查錯工具用來debug的）、java（運行編譯后的java程序 .class 后綴的，.java 文件編譯后生成 .class 文件）、appletviewer （小程序瀏覽器，一種執行HTML文件上的Java小程序的Java瀏覽器）、Javah（產生可以調用Java過程的C過程，或建立能被Java程序調用的C過程的頭文件）、Javap （Java反匯編器，顯示編譯類文件中的可訪問功能和數據，同時顯示字節代碼含義）、Jconsole （ Java進行系統調試和監控的工具）
  

java的基本數據類型：

• 總的來說和C語言沒啥區別，只是輸出時不用占位符，只需要用+拼接輸出。

/* 以下代碼相當于C語言的main函數，是程序的入口點int main(int argc,char** argv)//參數是參數的個數，和字符串數組（二級指針）{return 0;}*/ public class Test {public static void main(String[] args) {//String[] args是字符串數組，就是一個參數System.out.println("hello1");System.out.println("hello2");//java里面的整形數int a=10;int b;b=10;int c=a+b;System.out.println("a="+a); System.out.println("a+b="+c);System.out.println("a="+a+" b="+b);//這里的+不帶引號表示連接輸出的內容System.out.println(a+"+"+b+"="+c);//這里帶引號的加號是指直接將+輸出，不帶引號的還是起連接作用//java里面的浮點數/*float f=0.1; //環境寫小數默認是double類型，所以不能賦值,要將f強制轉換為double類型 */float f=(float)0.1;double d=0.02;System.out.println("f="+f);//因為該方法不存在占位符，所以直接將要輸出的內容連進來就行了System.out.println("d="+d);} }

java里面的選擇語句：

• 基本上和C語言的沒啥區別

public class Test {public static void main(String[] args) {int a=2;if(a>0){ //if語句和C語言基本一樣System.out.println("a是正數");if(a==1){System.out.println("a是正數,并且等于1");}else{System.out.println("a是正數，并且不等于1");}}else{System.out.println("a是負數");}switch (a){//switch選擇語句case 1:System.out.println("輸出1");break;case 2:System.out.println("輸出2");break;case 3:System.out.println("輸出3");break;}} }

java的循環控制語句：

• 和C語言一模一樣，只是程序的入口函數不一樣

public class Test {public static void main(String[] args) {int a=10;int b;for(b=1;b<10;b++){System.out.println("b="+b);}while(b>0){System.out.println("b="+b);b--;}} }

java的數組：

• java里面的數組和C里面的數組在定義的時候稍微有點區別，但是在使用的時候都是通過數組下標來使用的，

public class Test {public static void main(String[] args) {/*int a[3];C語言數組定義但是在java里面不能這樣定義*///int a[];//在java里面定義數組時不能體現數組的個數[]里面不能有數字int b[]={1,2,3};//這種定義方式在java和C里面都可以System.out.println(b[0]);//訪問數組元素也是通過數組下標來訪問的，也是從0開始的System.out.println(b[1]);System.out.println(b[2]);//在java里面定義一個空數組//int array[]=new int[3];//表示定義了一個有三個元素空間的空數組,array是數組名，int是數組的類型int[] array=new int[3];[]在數組名前面或者后面都可以int i;for(i=0;i<array.length;i++){//循環遍歷數組,array.length就是求數組的長度System.out.println(array[i]);System.out.println(b[i]);}for(i=0;i<3;i++){array[i]=i;System.out.println(array[i]);}//數組的定義還可以這樣寫int[] array2=null;//arrary2[]/[]array2表示這是一個數組，數組的起始地址指向nullarray2=new int[3];//在句話再給數組做一個初始化給數組分配空間//數組的定義還可以這樣寫，即在數組初始化時給元素賦值int[] array3=new int[]{1,2,3};//等同于int[] array3={1,2,3}; } }

java的函數：

• java里面的函數如果在定義時沒有說明是static類型的函數那么，在函數調用的時候必須先創建對象然后通過對象訪問類里面的方法，如果函數定義為static類型的，那么就可以像c語言那樣調用函數。

public class Test {static void myprintf(){int b;//作用域也只是這個函數，和C語言一樣System.out.println("第一個測試函數");}static void putAint(int a){System.out.println("函數傳入的數字為"+a);}public static void main(String[] args) {int a=10;/*myprintf();//在main函數里面這樣調用函數，前提是函數必須是static靜態的putAint(a);*///如果不用以上調用方式，則可以用以下方式進行調用Test t=new Test();//創建類的對象，并為其開辟空間t.myprintf();t.putAint(a);//這種方式調用函數不用使函數定義為static類型的} }

java實現計算器（+ - * /）：

• 其實和C語言沒啥區別，主要還是定義和使用的時候有些區別

public class Test {int add(int data1,int data2){return data1+data2;}int min(int data1,int data2){return data1-data2;}float div(int data1,int data2){return (float)data1/data2;}int mul(int data1,int data2){return data1*data2;}public static void main(String[] args) {//int[] score;//score=new int[10];//int[] score=new int[10];//查找最低分和最高分int score[]={67,60,31,40,50,88,99};int min;int max;int i;min=max=score[0];for(i=0;i<score.length;i++){if(max<=score[i]){max=score[i];}else if(min>score[i]){min=score[i];} }System.out.println("最高分為："+max);System.out.println("最低分為："+min);//實現計算器int data1=10;int data2=3;Test t=new Test();System.out.println("兩數之和為："+t.add(data1,data2));System.out.println("兩數之積為："+t.mul(data1, data2));System.out.println("兩數之差為："+t.min(data1, data2));System.out.println("兩數相除為："+t.div(data1, data2));} }

java的輸入類：

• java的輸入類Scanner，然后創建對象，然后進行實例化（在實例化的時候要傳入參數System.in可以理解為從鍵盤獲取吧），就可以使用實例化對象里面的方法，根據輸入的類型不同進而選擇不同的方法。

import java.util.Scanner; public class Test {public static void main(String[] args) {Scanner sc=new Scanner(System.in);//Scanner是類，sc是創建的對象(ctrl+shift+o)自動導包//new Scanner(System.in)是對sc進行實例化,這里還涉及到構造方法，后面將會學到int a;float f;double d;String str;System.out.println("請輸入一個整數");a=sc.nextInt();//獲取一個整數str=sc.nextLine();//吸收輸入整數后的鍵盤的回車System.out.println("請輸入一個字符串");str=sc.nextLine();//獲取一個字符串System.out.println("請輸入一個float小數");f=sc.nextFloat();//獲取一個字符串System.out.println("請輸入一個double小數");d=sc.nextDouble();//獲取一個字符串System.out.println("得到整數："+a);System.out.println("得到字符串："+str);System.out.println("得到flaot小數："+f);System.out.println("得到double小數："+d);} }

封裝的概念：

將東西包在一起，然后以新的完整形式呈現出來，將方法和字段一起包裝到一個單元中，單元以類的形式實現（類比C語言就是結構體，字段就是各種數據類型，方法就是函數指針），但是與C語言結構體不同的是，java的類有信息隱藏，隱藏對象的實現細節，不讓外部直接訪問到，就是外部看不到函數體。將數據和方法包裝進類中，加上具體實現的隱藏（訪問修飾符），共同被稱作封裝，其結果是一個同時帶有特征和行為的數據類型。封裝類： 定義類、定義其屬性、方法的過程稱為封裝類。

• 下面是封裝類的示例代碼（可以類比于C語言的結構體）：

/*struct Student{int age;char* name;double score;void (*introduce)(int age,int name,int score);void (*testFunc)();} */ class Student //封裝類 {int age;String name;//java中沒有char類型的變量，只有String類型的字符串double score;void introduce(){ //這個函數在用參數的時候如果使用類中的變量，則不用在函數定義的時候聲明變量System.out.println("name="+name+"age="+age+"score="+score);}void testFunc(){System.out.println("testFunc"); } } public class Demo1 {public static void main(String[] args) {Student stu1=new Student(); //Student()括號內是用來傳參數的,通過類實例化對象//類等于模板//類不能直接使用，不能直接訪問變量，需要先實例化，申請一個訪問空間/*上面那一行等同于C語言里面的struct Student *pp=malloc(sizeof(struct Student));先定義struct Student這個類型的變量再為其開辟空間，在java里面是一條語句完成的*/stu1.age=20;stu1.name="FHN";stu1.score=99;stu1.introduce();//這個函數沒有參數，因為類內部有給字段賦值stu1.testFunc();} }

java封裝之訪問修飾符：

信息隱藏是OOP最重要的功能之一，也是使用訪問修飾符的原因。信息隱藏的原因包括：①對模塊的任何實現細節所作的更改不會影響使用該模塊的代碼。②防止用戶以外修改數據。③使模塊易于維護和使用（就是電腦配件）。訪問修飾符有： private、protected、public、默認。上面的代碼沒有修飾符，所以屬性是默認屬性。這些訪問修飾符就是設置看能不能通過stu1.age=20這樣的形式訪問變量。訪問修飾符不僅可以修飾變量和方法還可以修飾類。

• 訪問修飾符的訪問權限：
• public:該類或非該類均可以訪問
• private：只有該類可以訪問（但是可以通過方法去間接地訪問private修飾的變量）
• protected：該類及其子類的成員可以訪問，同一個包中的類也可訪問
• 默認：同一個包中的類可以訪問

位置private默認protectedpublic

同一個類	是	是	是	是
同一個包內的類	否	是	是	是
不同包內的子類	否	否	是	是
不同包并且不是子類	否	否	否	是

• 屬性封裝的實現：修改屬性的可見性來限制對屬性的訪問、為每個屬性創建一對賦值的方法（setter）和取值的方法（getter）方法，用于公開對這些屬性的訪問接口，在setter和getter方法中，根據需要加入對屬性操作限制。這樣外部就可以通過這些方法來獲取或者修改私有屬性。
• 方法封裝的目的：隱藏方法實現細節（方法體），向外部提供公開接口（方法頭），以供安全調用，簡化調用，方便維護。根據需要，可以私有化方法，以供內部使用（僅在類內部使用）。

UML類圖：

Unified Modeling Language（UML）又稱統一建模語言或標準建模語言，類的命名盡量應用領域中的術語，應明確、無歧義、以利于相互交流和理解。類的屬性、操作中的可見性使用+、#、-分別表示public、protected、private

構造方法：

• 類的構造方法的概念和作用：①構造方法負責對象的初始化工作，為對象的屬性賦合適的初值。②創建對象時，其類的構造方法確保在用戶操作對象之前，系統保證初始化的進行。
• 構造方法的語法規則：①構造方法與類名一致②沒有返回類型③方式實現主要為字段賦初值。
• 構造方法的調用：構造方法的調用很特別，new操作符（實例化對象的時候，自動被調用），java系統保證每個類都有構造方法。 如果在類里面不寫構造方法，它會自動的添加一個構造函數（無參構造方法）只是我們看不見而已，在一個類中可以有多個構造方法（函數的重載，參數列表一定要改），構造方法不能被重寫

class Student //封裝類 {int age;String name;//java中沒有char類型的變量，只有String類型的字符串double score; // Student(int newage,String newnme,double newscore) { //沒有返回值是什么都不寫而不是設置void的返回值 // System.out.println("構造方法被調用"); // age=newage; // name=newnme; // score=newscore; // }Student() {//無參構造方法System.out.println("無參構造方法被調用");}Student(int newage,String newnme) { //在java中，方法是可重載的，在C中是不允許的System.out.println("構造方法一被調用");age=newage;name=newnme;}Student(int newage,double newscore) { System.out.println("構造方法二被調用");age=newage;score=newscore;}void introduce(){ //這個函數在用參數的時候如果使用類中的變量，則不用在函數定義的時候聲明變量System.out.println("name="+name+"age="+age+"score="+score);}void testFunc(){System.out.println("testFunc"); } } public class Test {public static void main(String[] args) {Student stu1=new Student();Student stu3=new Student(18, "FHN");//在實例化的時候被調用，根據參數個數自動選擇不同的構造方法Student stu2=new Student(18, 99);//在實例化的時候被調用，根據參數個數自動選擇不同的構造方法stu3.introduce();} }

• java中的重寫和重載：
• 方法重載的概念： 同一個類中，同名不同參的方法稱為重載方法，注意： 僅有返回值不同的方法不能稱為重載。
• 多數程序設計語言要求為每個方法（函數）提供一個獨一無二的方法名，不存在方法重載的概念，在java中，規定方法簽名是解析方法的規則而不是方法名，為方法重載開創了條件，方法重載使得在一個類中，方法名相同而參數列表不同的方法可同時存在，代表相似的行為或功能。
• 例如：System.out.print這個函數就支持方法重載：
  
  

方法重寫：

• 什么是方法重寫？ 方法重寫是指子類可以根據需要對從父類繼承來的方法進行改寫，是多態機制的前奏。
• 方法重寫的注意點： ① 重寫方法必須和被重寫的具有相同的方法名稱、參數列表和返回值。 ② 重寫方法不能比被重寫方法有更嚴格的訪問權限。③ 父類的私有方法，不能被重寫。 ④ 在子類重寫方法中繼續調用父類的被重寫方法可以通過super.函數名獲取。

class Person{String name;String address;private void printInfo(){System.out.println("父類adress："+address);}void printName(){System.out.println("父類name："+name);} } class Student extends Person{int score;void printName()//對父類方法進行重寫，重寫方法不能比被重寫方法有更嚴格的訪問權限{super.printName();System.out.println("子類name："+name);}void printInfo(){//父類的私有方法，不能被重寫，在這里雖然和父類里面的方法名一樣//但是這不是方法重寫，可以理解為在子類里面定義的一個和父類方法名一樣的方法吧，既不是重寫也不是重載super.printName();System.out.println("子類adress："+address);} } public class Main {public static void main(String[] args) {Person p=new Person();Student s=new Student();//當構造一個子類對象的時候一定會先調用父類的構造方法來初始化父類的字段s.name="子類" ;s.address="河北";s.printName();//優先調用子類的方法s.printInfo();} }

• 函數重載發生在同一個類里面，函數重寫發生在繼承關系里面

This關鍵字的特點：

• 在類的方法中，使用This關鍵字代表的是調用此方法的對象的引用
• This可以看做是一個變量，他的值是當前對象的引用
• 使用This可以處理方法中的成員變量和形參同名的問題（使用比較多）
• 在方法內需要用到調用到該方法的對象時，就可以用This
• 在類的構造方法中可以調用This（[參列表]）來調用該類的指定構造方法（使用比較多）

class Student //封裝類 {int age;String name;//java中沒有char類型的變量，只有String類型的字符串double score;Student() {//無參構造方法System.out.println("無參構造方法被調用");}Student(int age,String name) { //在java中，方法是可重載的，在C中是不允許的System.out.println("構造方法一被調用");this.age=age;this.name=name;}Student(int age,String nme,double score) { //沒有返回值是什么都不寫而不是設置void的返回值//this();//在類的構造方法中可以調用This（[參列表]）來調用該類的指定構造方法//在這個構造方法中調用無參構造方法this(22,"NHF");//但是使用this構造方法只能調用一個，只能放在這個構造方法的第一條語句System.out.println("構造方法二被調用");this.age=age;this.name=nme;//this表示是可以處理方法中的成員變量和形參同名的問題this.score=score;//在變量前加一個this就表示是當前類中的變量}void testThis(){/*Student stutmp=null;System.out.println(stutmp.age);并沒有為stutmp開辟空間這樣訪問這里面的值會出現錯誤*/Student stutmp=null;stutmp=this;//This可以看做是一個變量，他的值是當前對象的引用,就是當前對象的一個別名System.out.println(stutmp.age);System.out.println(this.name);//This關鍵字代表的是調用此方法的對象的引用} } public class Test {public static void main(String[] args) {Student stu1=new Student(18,"FHN",20);stu1.testThis();//This關鍵字在這里代表是調用此方法的對象的引用，也就是stu1的引用} }

static關鍵字的特點：

• 用來修飾類的成員—修飾成員變量的稱為類變量（靜態變量）
• 修飾成員方法稱之為類方法（靜態方法）
• 當類被加載的時候就會被加載，優先于對象的存在
• 用來修飾語句—稱之為靜態代碼，先于構造方法之前執行，只會執行一次，用來對靜態成員做初始化
• 調用的時候可以直接通過類名.成員進行訪問。
• static關鍵字的注意事項： ①靜態方法只能訪問外部靜態成員。②靜態方法中不能出現this關鍵字。因為this是指的是對象的引用，而靜態方法是先于對象之前的，可以直接通過類來訪問靜態方法，不通過實例化對象來訪問靜態方法。

class Student //封裝類 {int age;String name;//java中沒有char類型的變量，只有String類型的字符串double score;static int data;//修飾類里面的變量（靜態變量）Student(int age,String nme,double score) { //沒有返回值是什么都不寫而不是設置void的返回值System.out.println("構造方被調用");this.age=age;this.name=nme;//this表示是可以處理方法中的成員變量和形參同名的問題this.score=score;//在變量前加一個this就表示是當前類中的變量}void introduce(){ //這個函數在用參數的時候如果使用類中的變量，則不用在函數定義的時候聲明變量System.out.println("name="+name);System.out.println("age="+age);System.out.println("score="+score);System.out.println("data="+data);}void testFunc(){System.out.println("testFunc"); }static{//這個是靜態代碼快，先于構造方法執行，不管實例化多少對象他只會執行一次，而構造方法會執行多次System.out.println("先于構造方法之前執行，只會執行一次，用來對靜態成員做初始化");data=10000;//age=19;靜態方法只能訪問外部靜態成員} } public class Test {public static void main(String[] args) {Student stu1=new Student(18,"FHN",20);Student.data=10;//靜態變量可以直接通過類名來訪問(也可以通過實例化后的對象來訪問)，其他成員變量必須先實例化然后再訪問。//當類被加載的時候data就會被加載，優先于對象的存在，可以不依賴于對象來訪問stu1.introduce();System.out.println("和為："+Test.add(1, 2));Test tes1=new Test();System.out.println("差為："+tes1.min(3,2));}static int add(int data1,int data2)//加上static就可以通過類名來直接訪問類方法{return data1+data2;}int min(int data1,int data2)//不加static必須通過實例化對象來訪問方法{return data1-data2;} }

包（package）：

打包的意義：

• 標準的java庫是由一系列包組成的，包括java.lang、java.util、java.net等等
• 標準的java包就是層次型包結構，就如同硬盤上嵌套的子目錄一樣，我們可以使用嵌套層次來組織包
• java的包是為了更好的規劃代碼，防止命名沖突和混亂。所以java出現了打包機制
• 當把類組織起來放進一個包之內時，也就給包中的成員賦予了相互訪問的權限，就可以擁有了該包內的程序代碼
• 包訪問權限把類聚集在一個包中這一做法提供了意義和理由。
• java開發人員可以編寫屬于自己的java包，為了保證包名唯一性，要求開發人員在定義自己的包時在名字前加上唯一的前綴。由于互聯網的域名名稱不會重復，所以推薦采用公司在互聯網上的域名的倒置作為包的唯一前綴。
• 一個類可以使用同一個包中的所有類，一個類可以使用其他包中的所有公開類。怎么使用其他包中的公開類？ ① 在每個類簽名加上完整包名，例如：java.until.Data today=new java.util.Date() ②更簡潔更通用的方式：使用import語句來導包（eclipse ctrl+shift+o） import java.util.Date(導入特定類) Date today=new Date() ③可以import特定類，也可以導入整個包。通過在源代碼文件的頂部（打包語句后）使用import語句實現import java.util.*
  
• 注意：包名后面的每一個點都代表一級文件，比如上圖的包名com.first.fhn相應的會在工程文件下面的src和bin下面新建文件夾，然后再將包放在對應的位置。如下圖所示：
  

總結： 這篇博客講了封裝的概念、UML類圖、構造方法、this關鍵字、static關鍵字、方法重載、方法重寫、包（packahe）

總結

以上是生活随笔為你收集整理的JAVA SE、EE、ME，JRE、JDK，基本数据类型，访问修饰符、函数、封装的概念、UML类图、构造方法、this关键字、static关键字、方法重载、方法重写、包（packahe）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。