老师的知识点1

在JAVA中，必须先设计类，才能获得对象。

我的理解：

疑问：为什么是这样的呢？

答案：

在 JAVA 或其他面向对象的编程语言中，类是对象的蓝图或模板。这意味着在你创建对象之前，你需要定义一个类来指明你的对象应该拥有哪些属性和方法。这个设计模式有几个原因和优点：

1. **规范性与一致性**：
   通过首先定义类，你可以确保每个对象都具有一致的结构和行为。这提供了一个明确的规范，指明了对象的属性和能够执行的操作。

2. **代码重用与模块化**：
   类允许你创建具有相同属性和方法的多个对象，而无需重复编写代码。这有助于减少代码重复，同时也使得代码更加模块化和可维护。

3. **抽象化**：
   类提供了一种抽象化的方式，使你能够将现实世界中的复杂实体模拟为简化但仍然代表其基本特性和行为的对象。

4. **封装与信息隐藏**：
   通过定义类，你可以实现封装，即将对象的内部状态和实现细节隐藏起来，仅通过公共接口暴露出必要的信息和交互方式。这有助于保护对象的内部状态，并提高代码的安全性和稳定性。

5. **易于维护和扩展**：
   通过使用类和对象，程序更易于维护和扩展。如果需要更改对象的结构或行为，你只需要在类级别进行更改，而不是在多个地方更改相同的代码。

因此，必须先设计类以便能够定义对象的结构和行为，然后才能创建和使用具有这些结构和行为的对象。这是面向对象编程的基本原则和工作方式。

2.如何定义类？

 老师的答案：

如上图。我觉得很直观了

我的答案：

在 Java 中定义一个类基本上包括以下几个步骤和元素：

### 1. 定义类的基本结构：

public class ClassName {
    // 类体
}

- `public` 是一个访问修饰符，它定义了这个类的可见性。除了 `public`，还有其他的访问修饰符，比如 `protected`, `private` 和默认的包级访问。
- `class` 是一个关键字，用来声明这是一个类。
- `ClassName` 是你给这个类起的名字，应遵循大驼峰命名规则。

### 2. 声明类的属性（字段）：

public class ClassName {
    private String attribute1;
    private int attribute2;
}

- `private` 是访问修饰符，表示这些属性只能在这个类内部访问。
- 属性的类型和名称：这里定义了两个属性，一个是字符串类型，一个是整数类型。

### 3. 定义类的方法：

public class ClassName {
    private String attribute1;
    private int attribute2;

    public void method1() {
        // 方法体
    }

    public int method2(int parameter) {
        // 方法体
        return 0;  // 根据实际情况返回合适的值
    }
}

- 方法可以有返回类型（如 `method2`），也可以没有（如 `method1`，其返回类型是 `void`）。
- 方法可以有参数，也可以没有参数。

### 4. 定义构造方法：

public class ClassName {
    private String attribute1;
    private int attribute2;

    public ClassName() {
        // 无参数构造方法
    }

    public ClassName(String attribute1, int attribute2) {
        this.attribute1 = attribute1;
        this.attribute2 = attribute2;
        // 带参数构造方法
    }

    // ... 其他方法
}

- 构造方法用于创建类的对象，它的名称必须与类名相同。
- 可以定义多个构造方法，实现构造方法重载。

以上是定义一个基本类的方法。可以根据实际需要添加更多的属性和方法，以及进行更复杂的操作和逻辑实现。

 3.如何得到类的对象

老师举了个例子就是构建手机类

package Phone;

public class Phone {
    //属性
    String brand;
    double price;
    //行为
    public void call(){
        System.out.println("手机在打电话");
    }
    public void playgame(){
        System.out.println("手机在打电话");
    }
}

package Phone;

public class Phonetest {
    public static void main(String[] args){
        //创建手机的对象
        Phone p=new Phone();
        p.brand="小米";
        p.price=199.9;
        System.out.println(p.brand);
        System.out.println(p.price);
    }
}

 

运行结果：

 

我的答案：

在Java中，你可以通过多种方式来获取一个类的对象：

### 1. 使用 `new` 关键字

最常见的方法是使用 `new` 关键字来创建一个类的新实例：

MyClass myObject = new MyClass();

### 2. 通过反射

你也可以通过反射来动态创建对象：

try {
    Class<MyClass> myClass = (Class<MyClass>) Class.forName("MyClass");
    MyClass myObject = myClass.getDeclaredConstructor().newInstance();
} catch (Exception e) {
    e.printStackTrace();
}

### 3. 克隆一个已存在的对象

如果一个类实现了 `Cloneable` 接口，你可以通过调用 `clone` 方法来创建一个新的对象：

MyClass originalObject = new MyClass();
try {
    MyClass clonedObject = (MyClass) originalObject.clone();
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}

### 4. 使用工厂方法

你可以通过一个工厂方法来创建对象。工厂方法是一个返回类的实例的静态方法：

public class MyClass {
    public static MyClass createInstance() {
        return new MyClass();
    }
}

// 使用工厂方法创建对象
MyClass myObject = MyClass.createInstance();
```

### 5. 反序列化

如果一个类实现了 `Serializable` 接口，你可以通过反序列化来创建对象：

```java
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.dat"))) {
    MyClass myObject = (MyClass) ois.readObject();
} catch (IOException | ClassNotFoundException e) {
    e.printStackTrace();
}

注意：对于上述每个例子，`MyClass` 应该替换为你想创建对象的实际类名。

4.如何使用对象

老师的答案:

访问属性：对象名，成员变量

访问行为：对象名，方法名

总结：

补充扩展：

JAVAbean类：

`JavaBean` 是Java编程中的一种标准，主要用于封装多个属性为一个单一对象，方便数据的存储和传输。JavaBean通常满足以下几个标准或条件：

1. 有一个公共的无参数的构造函数。
2. 属性私有化，并通过公共方法（getter和setter方法）来访问这些属性。
3. 实现`Serializable`接口，使得JavaBean可以被序列化和反序列化。
4. 可以包含业务逻辑方法，但这些方法通常是对该JavaBean属性的操作或与属性相关的逻辑。

下面是一个简单的JavaBean类的例子：

import java.io.Serializable;

public class Person implements Serializable {
    
    private static final long serialVersionUID = 1L;
    
    private String name;
    private int age;
    
    public Person() {
        // 无参数的构造函数
    }

    // getter 方法
    public String getName() {
        return name;
    }

    // setter 方法
    public void setName(String name) {
        this.name = name;
    }

    // getter 方法
    public int getAge() {
        return age;
    }

    // setter 方法
    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}

在这个例子中，`Person`类就是一个简单的JavaBean，它有两个私有属性（`name`和`age`），通过公共的getter和setter方法来访问和修改这些属性，并实现了`Serializable`接口以支持序列化。

测试类：

创建一个测试类是一个很好的方法来检验你的 `JavaBean` 类是否正常工作。下面是一个简单的测试类，使用了上面定义的 `Person` 类：

public class PersonTest {
    public static void main(String[] args) {
        // 创建一个 Person 对象
        Person person = new Person();
        
        // 使用 setter 方法设置属性值
        person.setName("John");
        person.setAge(30);
        
        // 使用 getter 方法获取属性值，并打印到控制台
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
        
        // 使用 toString 方法打印对象的状态
        System.out.println("Person Details: " + person.toString());
    }
}

当你运行这个测试类时，它应该输出：
Name: John
Age: 30
Person Details: Person [name=John, age=30]

这个测试类首先创建了一个新的 `Person` 对象，然后使用 `setter` 方法设置了 `name` 和 `age` 属性。然后它使用 `getter` 方法获取这些属性的值并打印它们，最后它使用 `toString` 方法打印出对象的整体状态。

定义类的补充注意事项：

老师的答案：

老师举了个手机类的例子。

package Phone;

public class Phone {
    //属性
    String brand;
    double price;
    //行为
    public void call(){
        System.out.println("手机在打电话");
    }
    public void playgame(){
        System.out.println("手机在打电话");
    }
}

 

package Phone;

public class Phonetest {
    public static void main(String[] args){
        //创建手机的对象
        Phone p=new Phone();
        p.brand="小米";
        p.price=199.9;
        System.out.println(p.brand);
        System.out.println(p.price);
    }
}

 运行结果：

我的答案：

在Java中定义类时，除了遵循基本的语法规则和编码标准之外，还应考虑以下几点，以确保代码的可维护性、可读性和可重用性：

1. **封装性**：
   - 限制类的字段和方法的访问级别（使用`private`, `protected`, `public`修饰符）。
   - 提供公共的getter和setter方法来访问和修改私有属性。

2. **命名规范**：
   - 类名应该是名词，以大写字母开头，遵循驼峰命名法。
   - 方法名应该是动词，以小写字母开头，遵循驼峰命名法。

3. **文档和注释**：
   - 使用JavaDoc来为类及其成员变量和方法提供适当的文档。
   - 使用注释来解释代码中复杂或不明显的部分。

4. **代码结构**：
   - 保持类的职责单一，避免一个类做太多事情。
   - 尽量减少类中的代码重复，考虑使用继承或者组合来复用代码。

5. **初始化和清理**：
   - 提供合适的构造方法来初始化对象。
   - 如果需要，可以覆盖`finalize`方法来清理对象。

6. **异常处理**：
   - 使用适当的异常处理来处理可能出现的错误情况。
   - 为方法提供适当的`throws`声明，或者使用`try-catch`块来处理异常。

7. **依赖管理**：
   - 尽量减少类之间的紧密耦合，使用接口和抽象类来实现松耦合。

8. **合理使用静态成员**：
   - 考虑将一些不依赖于实例状态的方法或常量定义为静态成员。

9. **遵循设计原则和模式**：
   - 尽量遵循软件设计的一些基本原则，如开闭原则、依赖倒置原则等。
   - 如果可能，尝试使用设计模式来解决复杂的设计问题。

10. **单元测试**：
    - 为类编写单元测试，以验证其正确性和功能。
    - 试图覆盖各种边界条件和异常情况。

遵循这些注意事项可以帮助你创建更健壮、更可维护和更易于理解的代码。

 老师的练习：

package GirlFriend;

public class Girlfriendtext {
    //创建女朋友的对象
    Girlfriend gf1=new Girlfriend();
    gf1.name="琳琳";
    gf1.age=18;
    gf1.gender='少女';
    System.out.Printlen(gf1.name);
    gf1.eat();
}

实际例子：

讲的非常好。