Java:类和对象（2）

一对象的构建和初始化

1.对象构建 (Object Construction)

Student student1=new Student("zhangsan",12,"123456");
Student student2=new Student("lisi",10,"15236");

2. 构造函数（Constructor）

构造函数的特性：

名字与类名相同。
没有返回类型。
可以重载（多个构造函数可以具有不同的参数列表）。

2.1有参数构造方法

 public Student(String name,int age,String stuNum){
        this.name=name;
        this.age=age;
        this.stuNum=stuNum;
        System.out.println("带有三个参数的构造方法");
    }

2.2无参数构造方法

 public Student(){
        this.name="lisi";
        this.age=18;
        this.stuNum="123456";
        System.out.println("无参数的构造方法");
    }

3. 对象初始化 (Object Initialization)

3.1在声明字段时赋值

public class Student {
    String name = "lisi";
    int age = 20;
    String num="123456"
}

3.2构造代码块处赋值 (Initialization Block)

静态代码块

 static {
        //定义在类当中，方法的外面，一般用于初始化静态成员的初始值
        classNum="114";
        System.out.println("静态代码块一般用来初始化静态成员变量");
    }

实例代码块

{
        this.name="pig";
        System.out.println("实例代码块");
    }

注：

Java 对象的构建和初始化主要通过 new 操作符、构造函数、字段初始化、构造代码块以及静态代码块来完成。每个对象的生命周期从构造开始，直到被垃圾回收器销毁。

二封装

在 Java SE 中，封装（Encapsulation） 是面向对象编程（OOP）中的一种核心概念。封装的目的是将对象的状态（字段/属性）隐藏起来，并通过公开的方法（访问器、修改器）来访问和修改这些属性。这种机制能够保护对象的内部状态不被随意修改，增强代码的安全性和可维护性。

1.封装的基本原则

将字段声明为 private，防止外部直接访问。
提供 public 的 getter 和 setter 方法，用于控制对私有字段的访问和修改。
通过 setter 方法可以添加业务逻辑来限制对属性的修改，而不是直接操作属性。

2.封装的优点

数据隐藏：外部类无法直接访问对象的内部数据。
控制访问：可以在 getter 和 setter 中增加逻辑，控制数据的访问权限。
灵活性：可以根据需要修改内部实现，而不影响使用该类的其他代码。
提高可维护性：减少错误发生的机会，并使代码更易维护。

public class Student {
    private String name="wangda";
    private int age;
    private double score;
    private static String classNum="1班";

利用getter 和 setter 方法，用于控制对私有字段的访问和修改

public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public static String getClassNum() {
        return classNum;
    }

    public static void setClassNum(String classNum) {
        Student.classNum = classNum;
    }

3.对封装的使用

 public static void main1(String[] args) {
        Student student1=new Student("zhangsan",12,"123456");
        Student student2=new Student("lisi",10,"15236");
        student1.setName("zhangsan");
        System.out.println(student1.getName());
        student1.setAge(12);
        System.out.println(student1.getAge());
        student1.setStuNum("123456");
        System.out.println(student1.getStuNum());
        student2.setName("lisi");
        System.out.println(student2.getName());
        student2.setAge(10);
        System.out.println(student2.getAge());
        student2.setStuNum("15236");
        System.out.println(student2.getStuNum());

    }

4.访问修饰符及他们的权限

5. 封装的好处

增强代码的安全性：通过限制直接访问对象的属性，可以防止外部代码对对象进行不合法的操作。
维护性和可扩展性：封装让我们可以轻松修改类的内部实现，而不影响使用该类的其他代码。
保护不变性：在 setter 方法中可以添加数据验证，确保对象始终处于有效状态。

注：封装是 Java 面向对象编程中的重要原则之一，通过将类的字段设为 private 并提供 public 的 getter 和 setter 方法，可以确保对象的状态只能通过受控的方式进行访问和修改。封装使代码更加安全、易于维护，并且更容易扩展。

default属性：只能被本包中类访问。

public属性：可以任何其他类访问。

private属性：只能在类中访问，不能被其他类访问

三包（Package）

在 Java SE 中，包（Package） 是一种用于组织类和接口的机制。包提供了一种层次化的结构，以便更好地管理代码，并避免类名冲突。Java 中的每个类都属于某个包，未显式声明包的类属于默认包。

1.包的概念

包在 Java 中的作用类似于文件夹，提供了一种分类和管理类、接口的方式。通过包，开发者可以对项目中的类进行分组，使代码更加结构化。

2.包的作用

避免类名冲突：不同开发者可以创建相同名称的类，但通过包来区分它们，避免名称冲突。
访问控制：包提供了额外的访问权限控制，不同包中的类之间的访问权限可以通过访问修饰符进行控制。
提高代码的可维护性：将类按功能分组可以使代码更加易读和易于维护。
方便类的查找和使用：通过包的层次结构，可以快速定位和使用类。

3.包的创建

package com.b.www;

public class TEST2 {

}

在上面的例子中，TEST2类属于 com.b.www包。package 声明必须是源文件中的第一条语句，除非有 package 之前的注释或许可声明。

4.包的命名规则

Java 包的命名通常使用公司或组织的互联网域名的反向写法作为包名的一部分，例如：

com.companyname.projectname：公司名和项目名作为包的前缀。
org.organizationname.product：使用组织名和产品名。

这有助于确保包名的全局唯一性。包名中的每个部分都必须是有效的 Java 标识符，通常采用小写字母。

5.包的导入

5.1导入单个类

import java.util.Arrays;
import java.util.Date;

5.2导入整个包

import java.util.*;
import java.util.*;

四 static（静态的）

在 Java SE 中，static 关键字用于声明类的成员（属性和方法）为静态的，即这些成员属于类本身，而不是类的实例（对象）。这意味着静态成员在类的所有实例之间共享，不依赖于具体对象进行调用。

1. 静态变量 (Static Variables)

  private static String classNum="1班";

特点：

静态变量在所有对象间共享。
无需通过对象，静态变量可以通过类名直接访问
静态变量在类加载时初始化，并在类的整个生命周期内保持。

   public static void main2(String[] args) {
        //都可以表示静态成员的打印
        System.out.println(Student.classNum);
        System.out.println(Student.getClassNum());

2.静态变量的 getter 和 setter 方法

public static String getClassNum() {
        return classNum;
    }

    public static void setClassNum(String classNum) {
        Student.classNum = classNum;
    }

3.静态方法(Static Methods)

public static int add(int a,int b){
        return a+b;
    }

4.静态代码块

static {
        //定义在类当中，方法的外面，一般用于初始化静态成员的初始值
        classNum="114";
        System.out.println("静态代码块一般用来初始化静态成员变量");
    }

五对象的打印

public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

public static void main(String[] args) {
        Student student=new Student("lis",12,13);
        System.out.println(student);
        System.out.println(student.toString());
    }

打印结果：