橘子味的心

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

    标题：Java对象和类

    Java是面向对象的语言。 作为具有面向对象功能的语言，Java支持以下基本概念 -

    • 多态性
    • 继承
    • 封装
    • 抽象化
    • 类
    • 对象
    • 实例
    • 方法
    • 消息传递

    在本节中，我们将学习两个概念 - 类和对象。

    • 对象 - 对象具有状态和行为。 例如：一只狗的状态有：颜色，名称，品种，它的行为有：摇尾巴，吠叫，吃东西。 对象是类的实例。
    • 类 - 可以将类定义为描述其类型对象支持的行为/状态的模板/蓝图。

    1. Java对象

    下面将深入了解什么是对象。 如果考虑现实世界，可以在我们周围找到许多对象，如：汽车，狗，人等等。所有这些对象都有状态和行为。

    如果考虑一只狗，那么它的状态是 - 名称，品种，颜色，并且它的行为是 - 吠叫，摇尾巴，跑步。

    如果将软件对象与实际对象进行比较，则它们具有非常相似的特征。
    软件对象也具有状态和行为。 软件对象的状态存储在字段中，行为通过方法显示。
    因此，在软件开发中，方法对对象的内部状态进行操作，并且对象到对象的通信是通过方法完成的。

    2. Java类

    类是创建单个对象的蓝图(模板)。以下是一个类的示例代码。

    1. public class Dog {
    2.    String breed;
    3.    int age;
    4.    String color;
    5.  
    6.    void barking() {
    7.    }
    8.  
    9.    void hungry() {
    10.    }
    11.  
    12.    void sleeping() {
    13.    }
    14. }
    15. Java

    类可以包含以下任何变量类型。

    • 局部变量 - 在方法，构造函数或块中定义的变量称为局部变量。 变量将在方法中声明和初始化，并且在方法完成时将销毁变量。
    • 实例变量 - 实例变量是类中的变量，但在方法之外。 在实例化类时初始化这些变量。 可以从类的任何方法，构造函数或块内部访问实例变量。
    • 类变量 - 类变量是使用static关键字修饰，它是在类中的方法之外声明的变量。

    一个类可以有任意数量的方法。 在上面的例子中，barking()，hungry()和sleeping()都是类的方法。

    以下是在学习Java语言类和对象时，需要了解的一些重要主题内容。

    构造函数

    在讨论类时，最重要的子主题之一是构造函数。 每个类都有一个构造函数。 如果没有为类显式编写构造函数，Java编译器会自动为该类构建一个默认构造函数。

    每次创建新对象时，都将至少调用一个构造函数。构造函数的主要规则是它与类具有相同的名称。 一个类可以有多个构造函数。

    以下是构造函数的示例 - 

    1. public class Dog {
    2.    // 无参数构造函数
    3.    public Dog() {
    4.    }
    5.    // 有参数构造函数
    6.    public Dog(String name) {
    7.       // 此构造函数有一个参数：name。
    8.    }
    9. }
    10. Java

    Java还支持单实例类，它是一种创建一个类只有一个实例设计模式。

    注意 - 有两种不同类型的构造函数。 我们将在后续章节中详细讨论构造函数。

    创建对象

    如前所述，类提供了对象的蓝图。一个对象是从一个类创建的。 在Java中，new关键字用于创建新对象。

    从类创建对象时有三个步骤 -

    • 声明 - 具有变量名称和对象类型的变量声明。
    • 实例化 - new关键字用于创建对象。
    • 初始化 - new关键字后跟对构造函数的调用，此调用初始化新对象。

    以下是创建对象的示例代码 - 

    1. public class Dog {
    2.    public Dog(String name) {
    3.       // 这个构造函数有一个参数：anem
    4.       System.out.println("传入的参数值是: " + name );
    5.    }
    6.  
    7.    public static void main(String []args) {
    8.       // 以下语句将创建一个对象: myDog
    9.       Dog myDog = new Dog( "小屁狗" );
    10.    }
    11. }
    12. Java

    编译并执行上面示例代码，得到以下结果：

    1. 传入的参数值是: 小屁狗
    2. Shell

    访问实例变量和方法

    通过创建的对象访问实例变量和方法。 要访问实例变量，以下是完全限定的路径 - 

    1. /* 首先创建一个对象 */
    2. ObjectReference = new Constructor();
    3.  
    4. /* 调用变量如下 */
    5. ObjectReference.variableName;
    6.  
    7. /* 现在，可以按如下方式调用类方法 */
    8. ObjectReference.MethodName();
    9. Java

    下面示例说明如何访问类的实例变量和方法。

    1. public class Dog {
    2.     int dogAge;
    3.  
    4.     public Dog(String name) {
    5.         // 此构造函数有一个参数：name
    6.         System.out.println("设置的小狗名字是: " + name);
    7.     }
    8.  
    9.     public void setAge(int age) {
    10.         dogAge = age;
    11.     }
    12.  
    13.     public int getAge() {
    14.         System.out.println("小狗的年龄是: " + dogAge);
    15.         return dogAge;
    16.     }
    17.  
    18.     public static void main(String[] args) {
    19.         /* 创建对象 */
    20.         Dog myDog = new Dog("小屁狗");
    21.  
    22.         /* 调用方法来设置狗的年龄 */
    23.         myDog.setAge(2);
    24.  
    25.         /* 调用另一个方法来获取狗的年龄 */
    26.         myDog.getAge();
    27.  
    28.         /* 也可以按如下方式访问实例变量：dogAge */
    29.         System.out.println("变量的值是:" + myDog.dogAge);
    30.     }
    31. }
    32. Java

    编译并执行上面示例代码，得到以下结果：

    1. 设置的小狗名字是: 小屁狗
    2. 小狗的年龄是: 2
    3. 变量的值是:2
    4. Shell

    源文件声明规则

    在源文件中声明类，import语句和package语句时，这些规则是必不可少的。

    • 每个源文件只能有一个public类。
    • 源文件可以有多个非public类。
    • public类名称也应该是源文件的名称，最后以.java作为扩展名。 例如：类名是public class Employee{}，那么源文件应该是：Employee.java。
    • 如果在包内定义了类，则package语句应该是源文件中的第一个语句。
    • 如果存在import语句，则必须在package语句和类声明之间写入它们。如果没有package语句，则import语句应该是源文件中的第一行。

    类具有多个访问级别，并且有不同类型的类; 抽象类，final类等。我们将在访问修饰符章节中解释所有这些。

    除了上面提到的类类型之外，Java还有一些特殊类：内部类和匿名类。

    Java包

    简而言之，它是一种对类和接口进行分类的方法。 在Java中开发应用程序时，将编写数百个类和接口，因此必须对这些类进行分类，以使生活变得更加容易。Java包也是用于解决命名冲突的问题。

    import语句

    在Java中，如果给出了包含包和类名的完全限定名称，则编译器可以快速地找到源代码或类。 import语句是一种为编译器提供正确位置以查找特定类的方法。

    例如，以下行将要求编译器加载目录java_installation/java /io中可用的所有类 - 

    1. import java.io.*;
    2. Java

    3. 一个简单学习案例

    在这个学习案例中，将创建两个类。 它们是：Employee和EmployeeTest。

    首先打开记事本并添加以下代码。Employee类是公共(public)类。因此使用文件名称为：Employee.java 保存此源文件。

    Employee类有四个实例变量 - name, age, designation 和 salary。 该类有一个显式定义的构造函数，它接受一个参数。

    1. import java.io.*;
    2.  
    3. public class Employee {
    4.  
    5.     String name;
    6.     int age;
    7.     String jobPosition;
    8.     double salary;
    9.  
    10.     // 这是Employee类的构造函数
    11.     public Employee(String name) {
    12.         this.name = name;
    13.     }
    14.  
    15.     // 设置员工的年龄，将empAge的分配给变量：age。
    16.     public void empAge(int empAge) {
    17.         age = empAge;
    18.     }
    19.  
    20.     /* 设置员工的工作岗位. */
    21.     public void setJobPosition(String jobPosit) {
    22.         jobPosition = jobPosit;
    23.     }
    24.  
    25.     /* 设置员工的薪水，将empSalary的分配给变量：salary。 */
    26.     public void empSalary(double empSalary) {
    27.         salary = empSalary;
    28.     }
    29.  
    30.     /* 打印员工详细信息 */
    31.     public void printEmployee() {
    32.         System.out.println("------------------------------------");
    33.         System.out.println("姓名:" + name);
    34.         System.out.println("年龄:" + age);
    35.         System.out.println("工作岗位:" + jobPosition);
    36.         System.out.println("薪水:" + salary);
    37.     }
    38. }
    39. Java

    如本教程前面所述，程序从main方法开始执行。 因此，要运行这个Employee类，应该有一个main方法，并且应该创建对象。接下来将为这些任务创建一个单独的类：EmployeeTest。

    在EmployeeTest类中，它创建Employee类的两个实例，并为每个对象调用方法以为每个变量赋值。将以下代码保存在EmployeeTest.java 文件中。

    1. import java.io.*;
    2. public class EmployeeTest {
    3.  
    4.    public static void main(String args[]) {
    5.       /* 使用构造函数创建两个对象 */
    6.       Employee empOne = new Employee("Maxsu");
    7.       Employee empTwo = new Employee("张小龙");
    8.  
    9.       // 为每个创建的对象调用方法
    10.       empOne.empAge(26);
    11.       empOne.setJobPosition("高级软件工程师");
    12.       empOne.empSalary(15999);
    13.       empOne.printEmployee();
    14.  
    15.       empTwo.empAge(42);
    16.       empTwo.setJobPosition("产品经理");
    17.       empTwo.empSalary(999999);
    18.       empTwo.printEmployee();
    19.    }
    20. }
    21. Java

    现在，编译这两个类，然后运行得到结果如下 - 

    1. D:/worksp/java> javac Employee.java
    2. D:/worksp/java> javac EmployeeTest.java
    3. D:/worksp/java> java EmployeeTest
    4. ------------------------------------
    5. 姓名:Maxsu
    6. 年龄:26
    7. 工作岗位:高级软件工程师
    8. 薪水:15999.0
    9. ------------------------------------
    10. 姓名:张小龙
    11. 年龄:42
    12. 工作岗位:产品经理
    13. 薪水:999999.0
    14. Shell

    目录

    分类

    © 2020-2025 橘子味的心

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