橘子味的心

    • 二十五岁时我们都一样愚蠢、多愁善感，喜欢故弄玄虚，可如果不那样的话，五十岁时也就不会如此明智。

    标题：Java对象和类

    在本节教程中，我们将学习Java对象和类。在面向对象编程技术中，需要设计和使用对象和类的程序。对象是物理和逻辑实体，而类是逻辑实体。

    提醒：对于Java初学者来说，对象和类是一个十分重要的概念，能否理解和掌握对之后其他Java知识有直接影响。所以，虽然本节的内容比较多，但建议认真阅读并理解，最好能结合手动实现本节中的所有示例代码。

    1. Java中的对象

    具有状态和行为的实体可称为对象(女朋友也可以叫对象)。 椅子，自行车，标记，笔，桌子，汽车等。它可以是物理或逻辑(有形和无形)。 无形对象的例子是银行系统。

    一个对象有三个特点：

    • 状态： 表示一个对象的数据(值)。
    • 行为： 表示对象的行为(功能)，例如：存款，取款等。
    • 标识： 对象标识通常通过唯一ID实现。该ID的值对外部用户不可见。 但是，它由JVM内部使用来唯一地标识每个对象。

    例如： 汽车是一个对象。它的名字是：捷达，颜色是白色等这些就是它的状态(数据值)。它用于跑路，所以跑路就是它的行为。

    对象是类的一个实例。 类是创建对象的模板或蓝图。 所以对象是一个类的实例。

    对象定义：

    • 对象是一个现实世界的实体。
    • 对象是一个运行时实体。
    • 对象是具有状态和行为的实体。
    • 对象是类的一个实例。

    2. Java中的类

    类是具有共同属性的一组对象。它是创建对象的模板或蓝图。它是一个逻辑实体。 它不能是物理存在的实体。

    Java中的类可以包含：

    • 字段
    • 方法
    • 构造函数
    • 代码块
    • 嵌套类和接口

    声明一个类的语法：

    1. class <class_name>{  
    2.     field;  
    3.     method;  
    4. }
    5. Java

    2.1. Java中的实例变量

    实例变量在类内部，但在方法外部定义的变量称为实例变量。 实例变量在编译时不获取内存。 它在运行时获取对象(实例)创建时的内存。 这是为什么，它被称为实例变量。

    2.2. Java中的方法

    在java中的方法类似函数，用于暴露对象的行为。

    方法的优点

    • 代码可重用性
    • 代码优化

    2.3. Java中的new关键字

    new关键字用于在运行时分配内存。所有对象在堆内存区域中获取内存。

    2.4. 对象和类示例： main方法和类

    在这个例子中，我们创建了一个有两个数据成员:id和name的Student类。并通过使用new关键字创建Student类的对象，并打印对象的值。

    这里，在类中创建main()方法。Student.java 类文件的代码如下 -

    1. class Student {
    2.     int id;// field or data member or instance variable
    3.     String name;
    4.  
    5.     public static void main(String args[]) {
    6.         Student s1 = new Student();// creating an object of Student
    7.         System.out.println(s1.id);// accessing member through reference variable
    8.         System.out.println(s1.name);
    9.     }
    10. }
    11. Java

    上面代码执行结果如下 -

    1. 0 
    2. null
    3. Java

    2.5. 对象和类示例：main方法在类外部

    在真实的开发中，我们一般创建类并从另一个类中使用它。这是比上面的在同一个类中更好的方法。 让我们来看一个简单的例子，在另一个类中有main()方法创建其它类。
    在不同的java文件或单个java文件中有多个类。 如果在单个java源文件中定义多个类，则最好使用带有main()方法的类名作为保存的文件名。下面来看一个名称为 TestStudent1.java 的文件中的代码：

    1. class Student {
    2.     int id;
    3.     String name;
    4. }
    5.  
    6. class TestStudent1 {
    7.     public static void main(String args[]) {
    8.         Student s1 = new Student();
    9.         System.out.println(s1.id);
    10.         System.out.println(s1.name);
    11.     }
    12. }
    13. Java

    执行上面代码，得到以下结果 - 

    1. 0 
    2. null
    3. Java

    3. 初始化对象

    在java中初始化对象有3种方式，它们分别如下 -

    1. 通过引用变量初始化对象
    2. 通过方法初始化对象
    3. 通过构造函数初始化对象

    3.1. 通过引用变量初始化对象

    初始化对象仅仅是将数据初步地存储到对象中。下面来看看一个简单的例子，通过引用变量初始化对象。这里创建一个 TestStudent2.java 类文件，代码如下：

    1. class Student {
    2.     int id;
    3.     String name;
    4. }
    5.  
    6. class TestStudent2 {
    7.     public static void main(String args[]) {
    8.         Student s1 = new Student();
    9.         s1.id = 101;
    10.         s1.name = "Sonoo";
    11.         System.out.println(s1.id + " " + s1.name);// printing members with a
    12.                                                     // white space
    13.     }
    14. }
    15. Java

    上面代码输出结果如下 - 

    1. 101 Sonoo
    2. Java

    还可以通过引用变量创建多个对象并存储信息在这些对象。这里创建一个 TestStudent3.java 类文件，代码如下：

    1. class Student {
    2.     int id;
    3.     String name;
    4. }
    5.  
    6. class TestStudent3 {
    7.     public static void main(String args[]) {
    8.         // Creating objects
    9.         Student s1 = new Student();
    10.         Student s2 = new Student();
    11.         // Initializing objects
    12.         s1.id = 101;
    13.         s1.name = "Sonoo";
    14.         s2.id = 102;
    15.         s2.name = "Amit";
    16.         // Printing data
    17.         System.out.println(s1.id + " " + s1.name);
    18.         System.out.println(s2.id + " " + s2.name);
    19.     }
    20. }
    21. Java

    上面代码输出结果如下 - 

    1. 101 Sonoo
    2. 102 Amit
    3. Java

    3.2. 通过方法初始化对象

    在本示例中，将创建Student类的两个对象，并通过调用insertRecord方法来初始化这些对象的值。并通过调用displayInformation()方法显示对象的状态(数据)。这里创建一个 TestStudent4.java 类文件，代码如下：

    1. class Student {
    2.     int rollno;
    3.     String name;
    4.  
    5.     void insertRecord(int r, String n) {
    6.         rollno = r;
    7.         name = n;
    8.     }
    9.  
    10.     void displayInformation() {
    11.         System.out.println(rollno + " " + name);
    12.     }
    13. }
    14.  
    15. class TestStudent4 {
    16.     public static void main(String args[]) {
    17.         Student s1 = new Student();
    18.         Student s2 = new Student();
    19.         s1.insertRecord(111, "Karan");
    20.         s2.insertRecord(222, "Aryan");
    21.         s1.displayInformation();
    22.         s2.displayInformation();
    23.     }
    24. }
    25. Java

    执行上面代码，得到如下结果 - 

    1. 111 Karan
    2. 222 Aryan
    3. Java

    创建对象的示意如下 -

    从上图可以看出，对象在堆内存区域获取内存。 引用变量指的是在堆内存区域中分配的对象。 这里，s1和s2都是引用存储器中分配的对象的引用变量。

    3.3. 通过构造函数初始化对象

    有关于通过构造函数初始化对象，我们将在后面的Java构造函数中学习。

    3.3.1. 对象和类示例：Employee

    下面我们来看看一个例子，实现维护员工信息的记录。这里创建一个 TestEmployee.java 类文件，代码如下所示 -

    1. class Employee {
    2.     int id;
    3.     String name;
    4.     float salary;
    5.  
    6.     void insert(int i, String n, float s) {
    7.         id = i;
    8.         name = n;
    9.         salary = s;
    10.     }
    11.  
    12.     void display() {
    13.         System.out.println(id + " " + name + " " + salary);
    14.     }
    15. }
    16.  
    17. public class TestEmployee {
    18.     public static void main(String[] args) {
    19.         Employee e1 = new Employee();
    20.         Employee e2 = new Employee();
    21.         Employee e3 = new Employee();
    22.         e1.insert(101, "ajeet", 45000);
    23.         e2.insert(102, "irfan", 25000);
    24.         e3.insert(103, "nakul", 55000);
    25.         e1.display();
    26.         e2.display();
    27.         e3.display();
    28.     }
    29. }
    30. Java

    上面代码执行得到结果如下 - 

    1. 101 ajeet 45000.0
    2. 102 irfan 25000.0
    3. 103 nakul 55000.0
    4. Java

    3.3.2. 对象和类示例：Rectangle

    还有另一个维护Rectangle类记录的例子。这里创建一个 TestRectangle1.java 类文件，代码如下所示 -

    1. class Rectangle {
    2.     int length;
    3.     int width;
    4.  
    5.     void insert(int l, int w) {
    6.         length = l;
    7.         width = w;
    8.     }
    9.  
    10.     void calculateArea() {
    11.         System.out.println(length * width);
    12.     }
    13. }
    14.  
    15. class TestRectangle1 {
    16.     public static void main(String args[]) {
    17.         Rectangle r1 = new Rectangle();
    18.         Rectangle r2 = new Rectangle();
    19.         r1.insert(11, 5);
    20.         r2.insert(3, 15);
    21.         r1.calculateArea();
    22.         r2.calculateArea();
    23.     }
    24. }
    25. Java

    上面代码执行得到结果如下 - 

    1. 55 
    2. 45
    3. Java

    在Java中创建对象的不同方法有哪些？

    在java中有很多方法可以用来创建对象。它们分别是：

    • 通过new关键字
    • 通过newInstance()方法
    • 通过clone()方法
    • 通过反序列化
    • 通过工厂方法等

    在接下来的章节中，将学习这些方法用来创建对象。

    匿名对象

    匿名只是表示没有名。没有引用的对象(也就是不使用实例变量)称为匿名对象。它只能在创建对象时使用。如果只需要使用一个对象，匿名对象是一个很好的方法。 例如：

    1. new Calculation();//匿名对象
    2. Calculation c = new Calculation();// 使用实例变量，所以不是匿名对象
    3. Java

    调用方法通过引用：

    1. Calculation c = new Calculation();  
    2. c.fact(5);
    3. Java

    通过匿名对象调用方法：

    1. new Calculation().fact(5);
    2. Java

    下面来看看java中的匿名对象的完整示例。

    1. class Calculation {
    2.     void fact(int n) {
    3.         int fact = 1;
    4.         for (int i = 1; i <= n; i++) {
    5.             fact = fact * i;
    6.         }
    7.         System.out.println("factorial is " + fact);
    8.     }
    9.  
    10.     public static void main(String args[]) {
    11.         new Calculation().fact(5);// calling method with anonymous object
    12.     }
    13. }
    14. Java

    上面代码执行得到结果如下 - 

    1. Factorial is 120
    2. Java

    仅创建同个类型的多个对象

    可以按照一种类型创建多个对象，就像在原始数据类型中的情况中一样。
    原始变量的初始化：

    1. int a=10, b=20;
    2. Java

    引用变量的初始化：

    1. Rectangle r1=new Rectangle(), r2=new Rectangle();//creating two objects
    2. Java

    下面再看看一个例子：

    1. class Rectangle {
    2.     int length;
    3.     int width;
    4.  
    5.     void insert(int l, int w) {
    6.         length = l;
    7.         width = w;
    8.     }
    9.  
    10.     void calculateArea() {
    11.         System.out.println(length * width);
    12.     }
    13. }
    14.  
    15. class TestRectangle2 {
    16.     public static void main(String args[]) {
    17.         Rectangle r1 = new Rectangle(), r2 = new Rectangle();// creating two
    18.                                                                 // objects
    19.         r1.insert(11, 5);
    20.         r2.insert(3, 15);
    21.         r1.calculateArea();
    22.         r2.calculateArea();
    23.     }
    24. }
    25. Java

    上面代码执行得到结果如下 - 

    1. 55 
    2. 45
    3. Java

    真实的应用示例: Account

    在本节的最后部分，我们来看看一个真实应用中的示例，模拟银行账户转帐的实现。这里创建一个 TestAccount.java 类文件，代码如下所示 -

    1. class Account {
    2.     int acc_no;
    3.     String name;
    4.     float amount;
    5.  
    6.     void insert(int a, String n, float amt) {
    7.         acc_no = a;
    8.         name = n;
    9.         amount = amt;
    10.     }
    11.  
    12.     void deposit(float amt) {
    13.         amount = amount + amt;
    14.         System.out.println(amt + " deposited");
    15.     }
    16.  
    17.     void withdraw(float amt) {
    18.         if (amount < amt) {
    19.             System.out.println("Insufficient Balance");
    20.         } else {
    21.             amount = amount - amt;
    22.             System.out.println(amt + " withdrawn");
    23.         }
    24.     }
    25.  
    26.     void checkBalance() {
    27.         System.out.println("Balance is: " + amount);
    28.     }
    29.  
    30.     void display() {
    31.         System.out.println(acc_no + " " + name + " " + amount);
    32.     }
    33. }
    34.  
    35. class TestAccount {
    36.     public static void main(String[] args) {
    37.         Account a1 = new Account();
    38.         a1.insert(832345, "Ankit", 1000);
    39.         a1.display();
    40.         a1.checkBalance();
    41.         a1.deposit(40000);
    42.         a1.checkBalance();
    43.         a1.withdraw(15000);
    44.         a1.checkBalance();
    45.     }
    46. }
    47. Java

    上面代码执行得到结果如下 - 

    1. 832345 Ankit 1000.0
    2. Balance is: 1000.0
    3. 40000.0 deposited
    4. Balance is: 41000.0
    5. 15000.0 withdrawn
    6. Balance is: 26000.0
    7. Java

    目录

    分类

    © 2020-2025 橘子味的心

  • 黔ICP备17008247号-2
  • 贵公网安备52022102000140