1.类

javaBean类：

用来描述一类事物的类

测试类：

检查其他的类是否书写正确，带main方法，是程序入口

工具类：

帮助我们做一些事情的类

1. 类名见名知意

2. 私有化构造方法（不让外界创建它的对象）

在 Java 中，工具类（Utility Class）通常是包含一组静态方法和变量的类，用于提供一些通用的、无需对象实例就可以执行的功能

1. 避免实例化

工具类通常不需要被实例化，因为它们包含的是静态方法和变量。通过将构造方法设为私有（private），可以防止外部代码创建工具类的实例。例如：

public class UtilityClass {
    private UtilityClass() {
        // 防止实例化
    }

    public static void utilityMethod() {
        // 一些实用功能
    }
}

2. 明确类的使用意图

将工具类的成员（方法和变量）设置为静态的，并且使构造方法私有，能够明确表达这个类的使用意图：即该类仅用于提供一组静态方法和/或变量，不应该被实例化。这有助于其他开发者理解如何正确使用该类。

3. 约束类的职责

私有化构造方法和成员方法强制工具类专注于提供静态方法，确保它不会被误用来保存状态或以其他方式被当作常规类使用。这有助于保持代码的整洁和一致性。

4. 代码风格和最佳实践

在很多编程风格和最佳实践中，工具类通常被建议设计为不可实例化的，因为它们的作用主要是提供功能，而不是表示数据。私有化构造方法是实现这一目的的有效方式。

总结

私有化成员方法和构造方法在工具类中的应用是为了避免工具类被错误地实例化，并确保其按照预期的方式（即作为一组静态方法和变量的容器）被使用。这种设计模式有助于维护代码的清晰性和逻辑性。

3.方法定义为静态

在 Java 中，工具类通常使用 static 关键字修饰成员方法，原因主要包括：

1. 无需实例化

• 工具类通常包含一组功能性的方法，这些方法与特定对象的状态无关，而是提供一些通用的操作或服务。
• 通过使用 static 修饰这些方法，可以直接通过类名来调用它们，无需创建类的实例。这样做更方便，也更符合这些方法的使用场景。

2. 状态无关

• static 方法不依赖于对象的状态，因为它们不需要访问实例变量。所有的 static 方法都可以在没有类的任何对象的情况下执行。
• 这使得 static 方法成为实现工具类（例如数学计算、字符串操作等）的理想选择，因为这些操作通常不需要访问或修改对象的状态。

3. 资源共享和效率

• static 方法和变量属于类级别，而不是实例级别。这意味着它们在所有实例之间共享，不需要为每个实例单独分配空间。
• 对于频繁使用的工具方法，使用 static 可以减少内存的使用，并提高程序的效率。

4. 组织相关功能

• 将相关的功能性方法组织在一个工具类中，并用 static 修饰，可以提供一种清晰的组织结构。
• 这种方式易于理解和维护，同时也方便在不同的地方重复使用这些方法。

5.例子

public class ArrUtil{
    private ArrUtil(){
    public static int getMax(...){...}
    public static int getMax(...){...}
    }
}

1.1 如何定义类

类的定义格式如下:

修饰符 class 类名 {
    // 1.成员变量（属性）
    // 2.成员方法 (行为) 
    // 3.构造方法 （初始化类的对象数据的）
    //4.代码块
    //5.内部类
}

例如:

public class Student {
    // 1.成员变量
    public String name ;
    public char sex ; // '男'  '女'
    public int age;
}

1.2 如何通过类创建对象

类名 对象名称 = new 类名();

例如:

Student stu = new Student();

1.3 封装

1.3.1 封装的步骤

1.使用 private 关键字来修饰成员变量。

2.使用public修饰getter和setter方法。

1.3.2 封装的步骤实现

1. private修饰成员变量

public class Student {
    private String name;
    private int age;
}

2. public修饰getter和setter方法

public class Student {
    private String name;
    private int age;

    public void setName(String n) {
      	name = n;
    }

    public String getName() {
      	return name;
    }

    public void setAge(int a) {
        if (a > 0 && a <200) {
            age = a;
        } else {
            System.out.println("年龄非法！");
        }
    }

    public int getAge() {
      	return age;
    }
}

1.4 构造方法

1.4.1 构造方法的作用

在创建对象的时候，给成员变量进行初始化。 初始化即赋值的意思。

1.4.2 构造方法的格式

修饰符 类名(形参列表) {
    // 构造体代码，执行代码
}

1.4.3 构造方法的应用

首先定义一个学生类，代码如下：

public class Student {
    // 1.成员变量
    public String name;
    public int age;

    // 2.构造方法
    public Student() {
		System.out.println("无参数构造方法被调用")；
    }
}

接下来通过调用构造方法得到两个学生对象。

public class CreateStu02 {
    public static void main(String[] args) {
        // 创建一个学生对象
        // 类名 变量名称 = new 类名();
        Student s1 = new Student();
        // 使用对象访问成员变量，赋值
        s1.name = "张三";
        s1.age = 20 ;

        // 使用对象访问成员变量 输出值
        System.out.println(s1.name);
        System.out.println(s1.age); 

        Student s2 = new Student();
        // 使用对象访问成员变量 赋值
        s2.name = "李四";
        s2.age = 18 ;
        System.out.println(s2.name);
        System.out.println(s2.age);
    }
}

1.5 this关键字的作用

1.5.1 this关键字的作用

this代表所在类的当前对象的引用（地址值），即代表当前对象。

1.5.2 this关键字的应用

1.5.2.1 用于普通的gettter与setter方法

this出现在实例方法中，谁调用这个方法（哪个对象调用这个方法），this就代表谁（this就代表哪个对象）。

public class Student {
    private String name;
    private int age;

    public void setName(String name) {
      	this.name = name;
    }

    public String getName() {
      	return name;
    }

    public void setAge(int age) {
        if (age > 0 && age < 200) {
            this.age = age;
        } else {
            System.out.println("年龄非法！");
        }
    }

    public int getAge() {
      	return age;
    }
}

1.5.2.2 用于构造方法中

this出现在构造方法中，代表构造方法正在初始化的那个对象。

public class Student {
    private String name;
    private int age;
    
    // 无参数构造方法
    public Student() {} 
    
    // 有参数构造方法
    public Student(String name,int age) {
    	this.name = name;
    	this.age = age; 
    }
}

2.封装

一.封装简介

==封装==：告诉我们，<span style="color: red;">如何正确设计对象的属性和方法</span> 对象代表什么，就得封装相应的数据，并提供数据对应的行为 ==封装的好处==:降低学习成本，或者说不用学，只要找就行

二.权限修饰符

1.<span style="color: red;">pravite</span>（私有的）

• 是一个权限修饰符
• 可以修饰成员（成员变量和成员方法）
• 被pravite修饰的成员只能在==本类==当中才能被访问

2.<span style="color: red;">public</span>（公共的）

• 用于指定成员可以被该类之外的任何类访问。

3.<span style="color: red;">protected</span>(受保护的)

• 用于指定成员可以被其子类访问，以及在同一包中的其他类访问。

4.默认（无修饰符）

• 用于指定成员可以在同一包中的其他类访问，但不能被其他包中的类访问。

三.代码示例

1.

• 针对每一个私有化成员变量,都要提供get和set方法
• set(参数) : 给成员变量赋值
• get() : 对外提供成员变量的值

public class GirlFriend {

    //此时在测试代码中就不能通过.age方法直接调用了
    private int age;  
  
    //set赋值  
    //相当于一个过滤通道，来检测输入的数据是否符合要求  
    public void getAge(int a){  
        if(a>=18 && a<=50){  
            age = a;  
        }  
        else{  
            System.out.println("非法数据");  
        }  
    }  
  
    //get获取  
    public int getAge(){  
        return age;  
    }  
}