一：自定義類：

之前我們寫的類大多數是只有一個main方法并且沒有返回值。一個完整的程序包括各種主力類，這些自定義類有自己的實例域和返回值。一個程序中只有一個類有一個main方法,多個主力類組成。main方法主要寫各個類之間的調用。

自定義類的語法：

class classname{
fields。。。 constructor.. statement ....... } 1 public class mod_cls { 2 public static void main(String[] args){ 3 Mod_Cl get_name=new Mod_Cl(); 4 String check_name=get_name.checkName("tom"); 5 System.out.println(check_name); 6 } 7 } 8 9 class Mod_Cl{ 10 String checkName(String x){ 11 String name=x; 12 return name; 13 } 14 }

?

類Mod_Cl就是自定義類，通過mod_cls調用自定義類中的checkNmame方法。

注意：在一個程序中只有一個公共類和多個非公共類組成。

構造器：

之前我們的簡單了解下構造器，構造器的名字和類的名字一致。構造器當初始化的時候通過new方法進行調用，將對象的初始化的值（對象null，布爾false，int0）進行改變，講對象的引用賦值對象的變量。

特點：只能用public private protected 三個修飾符。

????????? 沒有返回值，因為構造器不是函數，所以他沒有返回值，也不允許有返回值，但是允許return語句，如果有返回值，編譯器不會報錯，但是jvm認為該類的構造器和該函數重名，會報找不到構造器。

?練習：

需求：在一個公司里，有多個員工，員工有漲工資的屬性，模擬員工漲工資，并且將員工的漲完的工資信息輸出出來。

分析：有需求中，可以看出有employee類和一個公共類employee_test，其中類employee類為非共有類其中包含員工的字段信息，這些信息屬于私有（private）只能該類的方法的才能進行修改，不能被其他類的方法進行修改，這些字段信息初始化值是放在構造器中。

即：employee類由以下組成：

1：非公有類

2：私有字段信息。

3：構造器：初始化該類的私有信息字段。

4：方法：漲工資

完整代碼：

1 public class Employee_Test { 2 public static void main(String[] args){ 3 Employee[] em_arr= new Employee[3]; 4 em_arr[0]=new Employee("tom",22,1200); 5 em_arr[1]=new Employee("evil",22,22200); 6 em_arr[2]=new Employee("jack",22,2200); 7 System.out.printf("add salary information below:\n"); 8 for (Employee a:em_arr){ 9 System.out.printf("name is %s age: %d salary:%f\n",a.getName(),a.getAge(),a.addSalary(0.5)); 10 } 11 } 12 } 13 14 class Employee{ 15 private String name; 16 private int age; 17 private double salary; 18 public Employee(String aname,int age,double asalary){ 19 this.name=aname; 20 this.age=age; 21 this.salary=asalary; 22 } 23 public double addSalary(double addpercent){ 24 double addsalary=addpercent*this.salary; 25 salary+=addsalary; 26 return salary; 27 } 28 public String getName(){ 29 return this.name; 30 } 31 public int getAge(){ 32 return this.age; 33 } 34 35 }

?

?解析：

多個源文件編譯規則：

一個java程序是由多個類組成，只有一個公共類其他非公共類，類的名字和源文件名字一樣的。靜態方法main方法只在公共類中。靜態方法是通過類的來調用，在初始化的程序的時候，是沒有創建對象，所以通過類的靜態方法的來調用。

如上程序是由2個類組成，我們把這2個類放在一起，形成Employee_Test.java文件，但是在IDE編譯的時候形成2個class文件。

對于大多數人來說，會把一個類放在一個文件中。形成2個java結尾的文件：Employee.java?Employee_Test.java.

我們在編譯的時候，該怎么操作呢？

一種使用通配符*

javac? Employee*.java

一種是直接編譯

javac? Employee_Test.java

在java中，如果一個類的中代碼調用其他的類的時候，他會在當前的目錄找到該類，并編譯該類，如果被調用的類代碼更新，在調用的時候會重新編譯。

字段：

如上程序，Employee類包含多個私有字段、一個構造器、三個方法。

三個方法修飾符都是public，表示任意的類的方法都可以對Employee類的方法進行調用。

?

private String name;
private int age;
private double salary

?

如上字段，修飾符都是private ，表示這三字段只有 Employee類的對象的方法才能進行對象狀態（實例域）的修改。其他類的無法訪問和操作。這符合類的封裝的特性。想一想如果別的類能夠操作這些字段，那數據會出現混論！

類的方法可以訪問類的所有對象的私有數據！

也就是說類的字段一般設置為private修飾符

構造器：

1 public Employee(String aname,int age,double asalary){ 2 this.name=aname; 3 this.age=age; 4 this.salary=asalary; 5 }

?構造器是給對象初始化狀態，通過構造器修改對象初始值。

調用方式：通過new初始化對象的時候將對象的引用值傳給對象變量的時候執行了構造器。

特點：

修飾符只有public、private、protected。

沒有返回值。

構造器可以多個，不止一個。構造器可以進行重載多個構造器。

構造器的名字和類的名字的一致的。

不能對已經有對象的對象變量進行再次執行構造器修改狀態而達到重新設置值的目的。

構造器的參數可以為0、1、。。。。多個。

參數：

參數分隱式參數和顯式參數。比如上面的構造器中：

1 private String name; 2 private int age; 3 private double salary; 4 public Employee(String aname,int age,double asalary){ 5 this.name=aname; 6 this.age=age; 7 this.salary=asalary; 8 }

?

在構造器中，參數aname、aage、asalary，屬于構造器Employee的參數這叫做顯式參數。

而構造器中的name、age、salary屬于類中定義的字段，并不屬于構造器的參數，這叫做隱式參數。

隱式參數用this.來表示，在構造器塊中 this.name表示參數name。這樣用this更好區別的與構造器的自己的局部變量參數。

構造器的參數命令最好是能讓人易于理解，比如上面的aname、aage等。

訪問器和更改器：

如上程序中，其中方法：getName()? getAge()? addSalary()。其中：getName()? getAge() 通過聲明public 2個訪問器來訪問實例域。通過聲明public的更改器，這樣只有通過Employee類的通過訪問器和更改器來訪問對象的實例域和修改實例域更為安全。避免出現數據混亂。

也就是說需要獲得或者更改實例域的時候，需要提供以下：

1：私有的實例域。

2：公共的域訪問器方法

3：公共的域更改器方法。

1 public double addSalary(double addpercent){ 2 double addsalary=addpercent*this.salary; 3 salary+=addsalary; 4 return salary; 5 } 6 public String getName(){ 7 return this.name; 8 } 9 public int getAge(){ 10 return this.age; 11 }

?這種好處是：通過內部的實現，通過類的方法之外不會影響其他的代碼。
final 修飾符：

一 final數據
1.在修飾基本類型時，表示它是一個常量，在定義時必須給予賦值.
?? 特別的一個既是static又是final 的字段只占據一段不能改變的存儲空間。
2.在修飾對象或者數組時，它表示對對象或數組的引用恒定不變，然而對象本身卻是可以修改的.
? 空白final:聲明為final但末給定初值的字段，但必須確保空白final在使用前被初始化，一般在構造方法完成。
? final參數：在方法的參數列表以聲明的方式將參數指明為final，這意味著在方法里無法修改參數的引用所指向的對象。

如上面的字段name 可以用final來進行修飾表示該變量自始至終未發生任何的改變。

靜態域合靜態方法：

類似于python 的靜態字段和類方法，無論創建多少個對象，他只創建一次靜態域，他不伴隨對象的創建而創建。靜態域和靜態方法通過類來進行調用，在python中需要裝飾器@classmethod進行修飾，并必需參數為cls。

靜態域他屬于類，即使沒創建類他也自己存在。100個對象，但只有一份拷貝的靜態域。

靜態變量用的比較少，但是靜態常量用的比較多。比如Math對象中的PI

1 import java.lang.Math; 2 public class Math_test { 3 public static void main(String[] args){ 4 System.out.println(Math.PI); 5 } 6 }

他本身就是一個靜態常量。

靜態方法無法對對象實施操作的方法。

為什么呢？

因為靜態方法、靜態變量和靜態常量，無需通過對象進行調用，在啟動程序的時候，還沒有創建對象時候，是通過類的進行調用。而不管對象創建多少，靜態常量和變量只有一份拷貝。所以靜態方法無法對對象實施任何操作。

在調用的時候直接通過類進行調用，比如我們每個程序都有main方法，Math中pow方法都屬于靜態方法。

什么時候使用靜態方法呢？

1：不需要訪問類對象的實例域。

2：方法的參數都是顯式參數。

靜態方法另一個應用：工廠方法。

?方法參數：

1 public class args { 2 public static void main(String[] args){ 3 int a=2; 4 Base_Ar check_args =new Base_Ar("tom",20000); 5 check_args.set_Args(a); 6 check_args.prin_Info(); 7 System.out.printf("a is %d",a); 8 9 } 10 } 11 12 class Base_Ar{ 13 14 15 private double salary; 16 private String name; 17 public Base_Ar(String anme,double asalary){ 18 name=anme; 19 salary=asalary; 20 21 } 22 public void set_Args(int x){ 23 x+=3; 24 salary+=20; 25 } 26 public void prin_Info(){ 27 System.out.printf("name:%s salary:%f\n",name,salary); 28 29 } 30 31 }

在java中變量參數的傳遞是值。

如上變量a，在調用set_Args中，將a的值傳遞給該方法，雖然在方法中進行x+=3的操作，但是a的值并沒有發生變化。

而在對象中，傳遞的值是對象的引用值。在上面的salary中傳遞是對象的引用，他們都指同一個對象，所以修改了對象的狀態。

總結如下：

1：一個方法不能修改一個基本數據類型的參數（即數值型和布爾型）

2：一個方法可以改變一個對象的參數的狀態。

3：一個方法不能讓對象參數引用一個新的對象。

?

轉載于:https://www.cnblogs.com/evilliu/p/7624895.html

總結

以上是生活随笔為你收集整理的java oop的全部內容，希望文章能夠幫你解決所遇到的問題。

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