java中的類與物件

Employee.java

import java.io.*;
//唯一public類（可以沒有）必須和java檔案同名 ，每個類中至少一個構造方法，必須與類同名
public class Employee{	//1.類中可以定義類變數，類的所有物件共有，必須static宣告
   String name;	//2.成員變數
   int age;
   String designation;
   double salary;
   // 類的構造器，沒有返回值，括號裡可以變化，可以有多個建構函式，java編譯器預設有一個空的
   public Employee(String name){
      this.name = name;		//3.區域性變數，方法結束後銷燬。
   }
   // 設定age的值
   public void empAge(int empAge){
      age =  empAge;
   }
   /* 設定designation的值*/
   public void empDesignation(String empDesig){
      designation = empDesig;
   }

   public void empSalary(double empSalary){
      salary = empSalary;
   }

   public void printEmployee(){
      System.out.println("名字:"+ name );
      System.out.println("年齡:" + age );
      System.out.println("職位:" + designation );
      System.out.println("薪水:" + salary);
   }
} 

EmployeeTest.java

import java.io.*;
public class EmployeeTest{
 
   public static void main(String []args){
      /* 使用構造器建立兩個物件 */
      Employee empOne = new Employee("RUNOOB1");
      Employee empTwo = new Employee("RUNOOB2");
 
      // 呼叫者兩個物件的成員方法
      empOne.empAge(26);
      empOne.empDesignation("高階程式設計師");
      empOne.empSalary(1000);
      empOne.printEmployee();
 
      empTwo.empAge(21);
      empTwo.empDesignation("菜鳥程式設計師");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

執行：

總結：

●文字編譯時編碼用ANSI,不然會出錯編碼GKB無法對映字元。

●成員變數和靜態變數的區別：

由static修飾的變數稱為靜態變數，其實質上就是一個全域性變數。如果某個內容是被所有物件所共享，那麼該內容就應該用靜態修飾；沒有被靜態修飾的內容，其實是屬於物件的特殊描述。

不同的物件的例項變數將被分配不同的記憶體空間， 如果類中的成員變數有類變數，那麼所有物件的這個類變數都分配給相同的一處記憶體，改變其中一個物件的這個類變數會影響其他物件的這個類變數，也就是說物件共享類變數。

成員變數和類變數的區別：

   1、兩個變數的生命週期不同

      成員變數隨著物件的建立而存在，隨著物件的回收而釋放。

      靜態變數隨著類的載入而存在，隨著類的消失而消失。

   2、呼叫方式不同

      成員變數只能被物件呼叫。

      靜態變數可以被物件呼叫，還可以被類名呼叫。

   3、別名不同

      成員變數也稱為例項變數。

      靜態變數也稱為類變數。

   4、資料儲存位置不同

      成員變數儲存在堆記憶體的物件中，所以也叫物件的特有資料。

      靜態變數資料儲存在方法區（共享資料區）的靜態區，所以也叫物件的共享資料。

static 關鍵字，是一個修飾符，用於修飾成員(成員變數和成員函式)。

   特點：

   1、想要實現物件中的共性資料的物件共享。可以將這個資料進行靜態修飾。

   2、被靜態修飾的成員，可以直接被類名所呼叫。也就是說，靜態的成員多了一種呼叫方式。類名.靜態方式。

    3、靜態隨著類的載入而載入。而且優先於物件存在。

弊端：

   1、有些資料是物件特有的資料，是不可以被靜態修飾的。因為那樣的話，特有資料會變成物件的共享資料。這樣對事物的描述就出了問題。所以，在定義靜態時，必須要明確，這個資料是否是被物件所共享的。

   2、靜態方法只能訪問靜態成員，不可以訪問非靜態成員。

      因為靜態方法載入時，優先於物件存在，所以沒有辦法訪問物件中的成員。

   3、靜態方法中不能使用this，super關鍵字。

      因為this代表物件，而靜態在時，有可能沒有物件，所以this無法使用。

什麼時候定義靜態成員呢？或者說：定義成員時，到底需不需要被靜態修飾呢？

成員分兩種：

   1、成員變數。（資料共享時靜態化）

      該成員變數的資料是否是所有物件都一樣：

      如果是，那麼該變數需要被靜態修飾，因為是共享的資料。 

      如果不是，那麼就說這是物件的特有資料，要儲存到物件中。 

   2、成員函式。（方法中沒有呼叫特有資料時就定義成靜態）

      如果判斷成員函式是否需要被靜態修飾呢？

      只要參考，該函式內是否訪問了物件中的特有資料：

      如果有訪問特有資料，那方法不能被靜態修飾。

      如果沒有訪問過特有資料，那麼這個方法需要被靜態修飾。

成員變數和靜態變數的區別：

   1、成員變數所屬於物件。所以也稱為例項變數。

      靜態變數所屬於類。所以也稱為類變數。

   2、成員變數存在於堆記憶體中。

      靜態變數存在於方法區中。

   3、成員變數隨著物件建立而存在。隨著物件被回收而消失。

      靜態變數隨著類的載入而存在。隨著類的消失而消失。

   4、成員變數只能被物件所呼叫 。

      靜態變數可以被物件呼叫，也可以被類名呼叫。

   所以，成員變數可以稱為物件的特有資料，靜態變數稱為物件的共享資料。

●靜態內部類：

public class Test {
    public static void main(String[] args)  {
        Outter.Inner inner = new Outter.Inner();
    }
}
 
class Outter {
    public Outter() {
         
    }
     
    static class Inner {
        public Inner() {
             
        }
    }
}

靜態內部類也是定義在另一個類裡面的類，只不過在類的前面多了一個關鍵字static。靜態內部類是不需要依賴於外部類的，這點和類的靜態成員屬性有點類似，並且它不能使用外部類的非static成員變數或者方法，這點很好理解，因為在沒有外部類的物件的情況下，可以建立靜態內部類的物件，如果允許訪問外部類的非static成員就會產生矛盾，因為外部類的非static成員必須依附於具體的物件。

●私有內部類：

class Out {
    private int age = 12;
     
    private class In {
        public void print() {
            System.out.println(age);
        }
    }
    public void outPrint() {
        new In().print();
    }
}
 
public class Demo {
    public static void main(String[] args) {
        //此方法無效
        /*
        Out.In in = new Out().new In();
        in.print();
        */
        Out out = new Out();
        out.outPrint();
    }
}

如果一個內部類只希望被外部類中的方法操作，那麼可以使用 private 宣告內部類。

上面的程式碼中，我們必須在 Out 類裡面生成 In 類的物件進行操作，而無法再使用 Out.In in = new Out().new In() 生成內部類的物件。

也就是說，此時的內部類只有外部類可控制。

如同是，我的心臟只能由我的身體控制，其他人無法直接訪問它。

轉載於  http://www.runoob.com/java/java-object-classes.html