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