Java对象和类，部分2

2024-11-21

学习目录：

Java创建对象
访问实例变量与方法
实例
源文件声明规则
了解Java包
了解import语句

一. Java创建对象

对象是根据类创建的

在Java中，使用关键字 new 来创建一个新的对象。
构造器是用来创建类的实例（对象）并初始化其状态的特殊方法。
在这个构造器中，name 参数将被传递给 Puppy 类的实例，用来输出小狗的名字。

创建对象需要以下三步：

声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字 new 来创建一个对象。
初始化：使用 new 创建对象时，会调用构造方法初始化对象。

例子：

public class Puppy{
      // class：关键字，用来定义一个类。
      // Puppy：类的名称，这里表示该类描述的是一个“小狗”（Puppy）对象。
// 构造器(构造方法)：
   public Puppy(String name){
      // 这是一个构造器方法，名字和类名相同（Puppy），并且具有一个参数 String name，用于初始化 Puppy 类的对象。
      System.out.println("小狗的名字是 : " + name ); 
       // 这一行代码将 name 的值（即传入的狗的名字）打印到控制台上，格式为 "小狗的名字是 : " 后跟 name 的值。
       // 例如，如果传入的名字是 "tommy"，那么输出会是 小狗的名字是 : tommy。
   }
   public static void main(String[] args){ 
     // String[] args：表示命令行传入的参数，可以通过它接收外部输入的值
      Puppy myPuppy = new Puppy( "tommy" );
     // 这一行代码创建了一个 Puppy 类的对象 myPuppy，并将字符串 "tommy" 作为参数传递给构造器。
     // 构造器会被调用，输出 小狗的名字是 : tommy。
   }
}

输出结果：

1	小狗的名字是 : tommy

详细解释：

Puppy 类有一个构造器，这个构造器接收一个字符串类型的参数 name，并打印出“小狗的名字是 : +name"。
在 main 方法中，创建了一个 Puppy 对象，并传入 "tommy" 作为参数，最终输出 "小狗的名字是 : tommy"。

总结：

这段代码演示了如何定义一个带有构造器的类。构造器接受一个参数（小狗的名字），并将其打印出来。
通过在 main 方法中创建对象并传递参数，程序会打印出该小狗的名字。

二. 访问实例变量与方法

/* 实例化对象 */
Object referenceVariable = new Constructor();
/* 访问类中的变量 */
referenceVariable.variableName;
/* 访问类中的方法 */
referenceVariable.methodName();

详细解释：

第一行：实例化对象

1	Object referenceVariable = new Constructor();

Object referenceVariable: 创建一个 Object 类型的变量 referenceVariable。
Object： 是 Java 中所有类的基类（根类），因此它可以指向任何对象类型的实例。
new Constructor(): 通过 new 关键字调用类的构造函数，创建类的一个新实例。
Constructor： 应该是某个类的名称，表示使用该类的构造方法来实例化对象。

这行代码的意思是：

创建一个新的对象 referenceVariable，它是通过 Constructor 类的构造函数生成的。

注意，这里使用 Object 类型来声明变量，因此 referenceVariable 被视为 Object 类型的引用。

第二行：访问类中的变量

1	referenceVariable.variableName;

referenceVariable: 指向通过构造方法创建的对象的引用。
variableName: 类中的成员变量（字段）。可以通过该对象引用来访问该变量。

这行代码的意思是：

通过对象 referenceVariable 访问该对象的成员变量 variableName。

然而，由于 referenceVariable 是 Object 类型的引用，而 Object 类并没有直接定义 variableName，

因此这段代码通常会导致编译错误，除非 referenceVariable 被强制转换为实际类类型。

第三行：访问类中的方法：

1	referenceVariable.methodName();

methodName(): 类中的方法（函数），可以通过对象引用来调用。methodName 是该类中定义的某个方法的名称。

这行代码的意思是：通过对象 referenceVariable 调用该对象的 methodName 方法。

如果 referenceVariable 被声明为 Object 类型，则也需要确保 methodName 是 Object 类的方法

或者通过类型转换将其转换为实际类类型以调用相应的方法。

三. 实例

Puppy.java文件代码:

public class Puppy {
    private int age; // 声明了一个 int 类型的成员变量 age
    private String name; // 声明了一个 String 类型的成员变量 name
 
    // 构造器
    public Puppy(String name) {
        this.name = name;
        System.out.println("小狗的名字是 : " + name);
    }
 
    // 设置 age 的值
    public void setAge(int age) {
        this.age = age;
    }
 
    // 获取 age 的值
    public int getAge() {// 这是一个返回 int 类型的方法，用于获取 Puppy 对象的年龄。
        return age; // 方法返回 age 成员变量的值。
    }
 
    // 获取 name 的值
    public String getName() {
        return name;
    }
 
    // 主方法
    public static void main(String[] args) {
        // 创建对象
        Puppy myPuppy = new Puppy("Tommy");
 
        // 通过方法来设定 age
        myPuppy.setAge(2); // 通过调用 setAge 方法设置 myPuppy 对象的年龄为 2。
 
        // 调用另一个方法获取 age
        int age = myPuppy.getAge(); // 调用 getAge 方法获取 myPuppy 对象的年龄，并将返回值赋给 age 变量。
        System.out.println("小狗的年龄为 : " + age); // 输出
 
        // 也可以直接访问成员变量（通过 getter 方法）
        System.out.println("变量值 : " + myPuppy.getAge()); // 输出
    }
}

四. 源文件声明规则

当在一个源文件中定义多个类，并且还有import语句和package语句时

要特别注意这些规则：

一个源文件中只能有一个 public 类
一个源文件可以有多个非 public 类
文件名与类名一致
如果一个类定义在某个包中，那么 package 语句应该在源文件的首行
如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。

如果没有 package 语句，那么 import 语句应该在源文件中最前面。
import 语句和 package 语句对源文件中定义的所有类都有效。

在同一源文件中，不能给不同的类不同的包声明。

五.什么是 Java包？

包：主要用来对类和接口进行分类。当开发 Java 程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。

包的作用：是组织类，避免类名冲突，并且提供访问控制

包通常分为两种类型：默认包（没有声明包时使用）和命名包（通过 package 关键字指定）。

可以通过 import 语句导入其他包中的类。

package com.example.myapp;  // 声明该类所属的包 com.example.myapp
// 这意味着该类会被存储在与 com/example/myapp/ 路径对应的目录结构下。
public class MyClass {      // 定义一个公共类 MyClass
    // 类的定义部分，其中 public 关键字表示这个类可以在其他包中被访问和使用。
}

小结：这段代码定义了一个名为 MyClass 的类，并将其放入 com.example.myapp 包中。有助于项目中类的组织和结构化管理。

六. import语句

在 Java 中，如果给出一个完整的限定名，包括包名、类名，那么 Java 编译器就可以很容易地定位到源代码或者类。

import 语句就是用来提供一个合理的路径，使得编译器可以找到某个类。

例如，下面的命令行将会命令编译器载入 java_installation/java/io 路径下的所有类:

1	import java.io.*;

import java.io.*; 是用于引入 java.io 包中的所有类，使得我们可以在当前 Java 类中方便地使用这些类。
通过 * 通配符，我们不需要逐个列出 java.io 包中的所有类，只需使用一次 import 语句，就能访问该包中的任何类。
java.io 包包含了许多用于输入输出操作的类和接口，常见的如 FileReader、BufferedReader、FileWriter、PrintWriter 等，用于处理文件的读写、字符流和字节流等。