Java Basics Part 4/20 - Object & Classes

Java Basics Part 4/20 - Object & Classes

目錄

---

Java 作爲一門面向對象的語言，具有面向對象的基本特徵：

• 多態
• 繼承
• 封裝
• 抽象
• 類
• 對象
• 實例
• 方法
• 消息解析

這一章，看看類和對象的概念。

• 對象：對象有狀態有行爲。
• 類：對象的模板/藍圖，描述了對象的狀態和行爲。

---

Java 中的對象

什麼是對象？現實世界中，身邊到處都是對象——車，狗，人等。這些對象都要狀態和行爲。

考慮一條狗，那麼它的狀態——名字，品種，顏色；它的行爲：吠，搖尾巴，跑
現實世界與軟件世界，異曲同工。

軟件中的對象也有狀態和行爲。它的狀態存儲在 域(fields) 中，行爲由 方法(methods) 來表徵。

所以，在軟件開發中，一個對象的方法操作內部的狀態(也就是 field 啦)，對象與對象之間的通信通過方法調用來完成。

---

Java 中的類

類是藍圖，基於這個藍圖創建出一個個對象。

如下就是一個類：

public class Dog{
   String breed;
   int ageC
   String color;

   void barking(){
   }

   void hungry(){
   }

   void sleeping(){
   }
}

一個類可以包含以下變量：

• 局部變量：定義在方法中，構造器中或者塊中的變量叫做局部變量，方法完成即銷燬。
• 實例變量：定義在類中對象之外的變量。類實例化的時候，這些變量會初始化。方法、構造器或者塊中的代碼能夠訪問實例變量。
• 類變量：定義在類中對象之外的變量，由 static 修飾。

---

構造器

當創建一個新的對象時，至少會調用一個構造器。構造器的名字必須和類名相同，一個類可以有多個構造器。
舉例：

public class Puppy{
   public Puppy(){
   }

   public Puppy(String name){
      // This constructor has one parameter, name.
   }
}

Java 同樣支持單例類——一個類只能創建一個對象。

---

創建對象

類是對象的模板。Java 中，new 關鍵字用來創建一個新對象。
創建對象三步走：

• 聲明：聲明一個變量，類型是類名。
• 實例化：new 關鍵字用來創建對象。
• 初始化：緊跟在 new 關鍵字後面的是對構造器的調用。這個調用完成了對象的初始化。

舉例：

public class Puppy{

   public Puppy(String name){
      // This constructor has one parameter, name.
      System.out.println("Passed Name is :" + name ); 
   }

   public static void main(String []args){
      // Following statement would create an object myPuppy
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

// output
Passed Name is :tommy

---

訪問實例變量和方法

通過創建好的對象可以訪問實例變量和方法。
爲了訪問一個實例變量，需要如下：

/* First create an object */
ObjectReference = new Constructor();

/* Now call a variable as follows */
ObjectReference.variableName;

/* Now you can call a class method as follows */
ObjectReference.MethodName();

如下例子說明了如何訪問實例變量和方法：

public class Puppy{

   int puppyAge;

   public Puppy(String name){
      // This constructor has one parameter, name.
      System.out.println("Name chosen is :" + name ); 
   }

   public void setAge( int age ){
       puppyAge = age;
   }

   public int getAge( ){
       System.out.println("Puppy's age is :" + puppyAge ); 
       return puppyAge;
   }

   public static void main(String []args){
      /* Object creation */
      Puppy myPuppy = new Puppy( "tommy" );

      /* Call class method to set puppy's age */
      myPuppy.setAge( 2 );

      /* Call another class method to get puppy's age */
      myPuppy.getAge( );

      /* You can access instance variable as follows as well */
      System.out.println("Variable Value :" + myPuppy.puppyAge ); 
   }
}

// output
Name chosen is :tommy
Puppy's age is :2
Variable Value :2

---

源文件聲明規則

當聲明類，使用 import 和 package 語句時，需要注意一下規則：

• 一個源文件中只能有一個 public 類
• 一個源文件中可以有多個非 public 類
• public 類的名字必須和源文件的類名一樣
• 如果類定義在一個 包 中，那麼 package 語句必須是第一行語句
• 如果存在 import，那麼 import 語句必須在 package 語句和類聲明之間，如果沒有 package 語句，那麼 import 語句必須是第一行語句
• import 和 package 語句對源文件中的所有類都有效

類有不同的訪問級別，同時也有不同的類的類型：抽象類，final 類等。除了以上提到的類的類型，Java 還有一些特殊的類：內部類和匿名類。

---

Java 包

Java 中的包，就是一種類和接口的分類方式，便於管理。

---

Import 語句

Java 中，如果告訴編譯器一個類的完全名，那麼編譯器會很快就定位到源文件或者是類文件。import 語句就是幫助編譯器定位到特定的類的。

import java.io.*;

---

案例學習

這裏會創建兩個類：Employee 和 EmployeeTest。
Employee 類有四個實例變量：name， age，designation 和 salary。類有一個顯示定義的構造器，有一個形參。

// Employee.java
import java.io.*;

public class Employee{

   String name;
   int age;
   String designation;
   double salary;

   // This is the constructor of the class Employee
   public Employee(String name){
      this.name = name;
   }
   // Assign the age of the Employee  to the variable age.
   public void empAge(int empAge){
      age =  empAge;
   }
   /* Assign the designation to the variable designation.*/
   public void empDesignation(String empDesig){
      designation = empDesig;
   }
   /* Assign the salary to the variable salary.*/
   public void empSalary(double empSalary){
      salary = empSalary;
   }
   /* Print the Employee details */
   public void printEmployee(){
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

EmployeeTest 會創建兩個 Employee 類的實例，並且調用每個對象的方法給每個變量賦值。

import java.io.*;

public class EmployeeTest{

   public static void main(String args[]){
      /* Create two objects using constructor */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // Invoking methods for each object created
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

// output
C:\> javac Employee.java
C:\> javac EmployeeTest.java
C:\> java EmployeeTest
Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0