JavaSE--类和对象·下

1.封装 

1.1封装概念
面向对象程序三大特性：封装、继承、多态 。而类和对象阶段，主要研究的就是封装特性。

Java中的封装是指将类的数据和操作封装在一个单元内，对外部隐藏内部实现细节，并通过访问修饰符控制对类的成员的访问权限。

封装的关键在于使用访问修饰符来控制对类的成员的访问权限。Java提供了几种访问修饰符：

通过封装，我们可以隐藏类的内部实现细节，只暴露必要的方法给外部使用。这样可以提高代码的安全性和可维护性，同时还可以提供一些额外的功能，如数据验证、数据转换等。

下面是一个简单的示例代码，演示了如何使用封装：

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("Age can't be negative");
        }
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("John");
        person.setAge(30);

        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

在上面的示例中，Person类的name和age字段被声明为私有的(private)，外部类无法直接访问它们。为了访问这些字段，我们提供了getName和setName方法来获取和设置name字段的值，以及getAge和setAge方法来获取和设置age字段的值。在setAge方法中，我们还添加了一个数据验证的逻辑，确保年龄不会为负数。这样，我们就可以在外部类中安全地使用Person对象的属性。

注意：一般情况下成员变量设置为private ，成员方法设置为 public。
1.2封装扩展之包
在面向对象体系中，提出了一个软件包的概念，即： 为了更好的管理类，把多个类收集在一起成为一组，称为软件 包 。有点类似于目录。比如：为了更好的管理电脑中的歌曲，一种好的方式就是将相同属性的歌曲放在相同文件下，也可以对某个文件夹下的音乐进行更详细的分类。
在 Java 中也引入了包 ，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一 个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可 。
1.2.1导入类中的包

Java 中已经提供了很多现成的类供我们使用。

例如 Date 类：可以使用 java.util.Date 导入 java.util 这个包中的 Date类。 
public class Test {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}
但是这种写法比较麻烦一些 , 可以 使用 import 语句导入包。 
import java.util.Date;
public class Test {
    public static void main(String[] args) {
    Date date = new Date();
    // 得到一个毫秒级别的时间戳
    System.out.println(date.getTime());
    }
}
如果需要使用 java.util 中的其他类 , 可以使用 import java.util.* 
import java.util.*;
public class Test {
    public static void main(String[] args) {
    Date date = new Date();
    // 得到一个毫秒级别的时间戳
    System.out.println(date.getTime());
    }
}
但是我们 更建议显式的指定要导入的类名， 否则还是容易出现冲突 的情况。
还可以使用 import static 导入包中静态的方法和字段（一般不用）。

    常见的包

  • 1. java.lang:系统常用基础类(String、Object)。
  • 2. java.lang.reflect:java 反射编程包;
  • 3. java.net:进行网络编程开发包。
  • 4. java.sql:进行数据库开发的支持包。
  • 5. java.util:是java提供的工具程序包。
  • 6. java.io:I/O编程开发包。
1.2.2自定义包
基本规则
  • 在文件的最上方加上一个 package 语句指定该代码在哪个包中。
  • 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 )。
  • 包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路com/bit/demo1 来存储代码。
  • 如果一个类没有 package 语句, 则该类被放到一个默认包中。

2.static成员

在 Java 中，被 static 修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对
象，是所有对象所共享的 。
2.1static修饰成员变量
静态成员变量特性
  • 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
  • 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
  • 类变量存储在方法区当中
  • 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)
例如： 
//三位同学共享一间教室
public class Student{
    public String name;
    public String gender;
    public int age;
    public double score;
    public static String classRoom = "Bit306";

    public static void main(String[] args) {
        // 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);
        
        // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);
    }
}
2.2static修饰成员方法
Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不依赖于对象。静态成员一般是通过静态方法来访问的。 
public class Student{
    private static String classRoom = "Bit306";

    public static String getClassRoom(){
        return classRoom;
    }
}

public class TestStudent {
    public static void main(String[] args) {
        System.out.println(Student.getClassRoom());
    }
}//输出Bit306
静态成员方法特性
  • 不属于某个具体的对象，是类方法
  • 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者
  • 不能在静态方法中访问任何非静态成员变量
  • 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用
  • 静态方法无法重写，不能用来实现多态
 2.3成员方法或成员变量的调用
  1. 通过对象的引用调用
  2. 通过类名调用

在静态的方法当中不能直接使用任何非静态的成员变量和成员方法。要想使用，要通过new对象，然后通过对象的引用访问。但是在非静态方法当中，可以直接使用静态的成员方法或者静态的成员变量 。

2.4static成员变量初始化

  1. 就地初始化
  2. get set初始化
  3. 构造方法初始化
  4. 静态代码块初始化

3.代码块

Java代码块（Code Block）是一组用大括号 {} 包围的语句，它们可以被视为一个独立的单元。

代码块可以用来定义局部变量，这些变量只在代码块内部有效。这样可以控制变量的作用域，避免变量冲突和命名冲突。

代码块还可以用来组织代码，将相关的语句放在一起。例如，可以在代码块中定义一个局部变量，并在代码块内部使用这个变量，这样可以限制变量的作用范围，提高代码的可读性和可维护性。

代码块可分为以下几种：

  • 静态代码块：用 static 关键字修饰，用来初始化类的静态变量。
  • 实例代码块：不带任何修饰符，用来初始化实例变量。
  • 构造代码块：也称为构造方法内部的代码块，在创建对象时执行。

例如： 

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        
        // Java代码块开始
        {
            int sum = a + b;
            System.out.println("Sum: " + sum);
        }
        // Java代码块结束
        
        int c = 7;
        int d = 3;
        
        // Java代码块开始
        {
            int product = c * d;
            System.out.println("Product: " + product);
        }
        // Java代码块结束
    }
}
3.1静态代码块

静态代码块（Static Initialization Block）是一个特殊的代码块，在类加载时执行，并且只执行一次。它用 static 关键字修饰，用来初始化类的静态变量或执行一些静态方法。

静态代码块的语法如下：

static {
    // 静态代码块中的代码
}

在静态代码块中，可以编写任意合法的 Java 代码。静态代码块中的代码会在类第一次加载的时候执行，并且只执行一次。

静态代码块的主要作用是在类加载时进行一些初始化操作，例如读取配置文件、加载驱动程序等。由于静态代码块在类加载时执行，因此它的执行顺序是在静态变量初始化之前。

下面是一个静态代码块的示例：

public class MyClass {
    static {
        // 初始化静态变量
        // 执行其他静态代码
    }
}

需要注意的是，静态代码块不能访问非静态成员（比如实例变量和实例方法），因为它是在类加载过程中执行的，而不是在对象创建过程中执行的。

3.2 实例代码块

实例代码块（Instance Initialization Block）是在创建对象时执行的一段代码，它在每次创建对象时都会执行一次。实例代码块不需要使用关键字修饰，直接在类中定义即可。

实例代码块的语法如下：

{
    // 实例代码块中的代码
}

实例代码块与构造方法的执行顺序是在构造方法之前执行的。每当创建对象时，实例代码块都会被执行一次。

实例代码块的主要作用是在对象创建时进行一些初始化操作，例如初始化实例变量。也可以在实例代码块中执行其他任意合法的 Java 代码。

下面是一个实例代码块的示例：

public class MyClass {
    {
        // 初始化实例变量
        // 执行其他代码
    }
}

需要注意的是，实例代码块不能访问静态成员（比如静态变量和静态方法），因为它是在对象创建过程中执行的，而不是在类加载过程中执行的。

 
----------------------------------制作不易，麻烦给个三连支持一下吧------------------------------------