java三大特性-封装

一、封装概述

1.1 什么是封装

Java中的封装是一种将数据和对数据的操作隐藏在一起的机制，它能够提高代码的可维护性、可读性和安全性，实现代码的重用性和解耦。

1.2 为什么需要封装

在编程中，我们追求"高内聚，低耦合"的原则，其中，高内聚指的是类的内部数据操作细节由自己完成，不允许外部干涉；低耦合则是仅暴露必要的方法给外部使用。

封装通过隐藏对象的属性和实现细节，控制其访问权限来实现。一般来说，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。例如，我们可以使用private访问修饰符来限制直接访问类的属性，然后通过公共的getter和setter方法来访问和修改这些属性的值。

总的来说，封装的主要作用是保护对象的内部状态不受外部干扰和损害，同时也简化了代码和接口的设计，使得代码更具有可读性和可维护性。

二、包

2.1 什么是包

在Java编程语言中，包（package）是一种组织类的方式，其作用是提供唯一性，避免类名冲突。具体来说，包是一个类库单元，包含有一组类，这些类在单一的名称空间下被组织在一起，这个名称空间就是包名。

2.2 为什么需要包

包的主要目的是把功能相似或相关的类或接口组织在同一个包中，这样方便类的查找和使用。此外，通过使用包机制，我们可以更好地管理程序，例如按照功能划分不同的软件包。

2.3 如何导入包

在实际编程中，可以使用import关键字来导入一个包。例如，使用import java.util.*就可以导入名称空间java.util包里面的所有类。值得一提的是，Java为我们提供了很多现成的类供我们使用，这些被称为API。熟练掌握了Java一些核心的API，才能更好的使用Java进行编程。

2.4 如何声明包

在Java编程语言中，声明包的方式是在源文件的第一行使用package关键字指定包名。例如：

package com.example.myapp;

在这个例子中，我们声明了一个名为com.example.myapp的包。需要注意的是，包名应该全部小写，多个单词之间用点号分隔。此外，Java中的顶级包（即没有父包的包）通常都以java或javax开头，这些包由Java语言本身提供。

一旦声明了包，就可以在该包下创建类、接口和其他类型的文件。如果一个源文件中没有声明包，则该源文件将被视为默认包（即没有名称空间的包）。但是，为了避免命名冲突和代码管理混乱，建议在每个源文件中显式声明包。

2.5 包和目录的关系

在Java编程语言中，包和目录之间存在一种映射关系。这种映射是自然的，因此编译后的class文件仍然维护着这种包与文件路径的映射关系。当您创建一个包时，其实就是在定义一个命名空间，用于组织相互关联的类、接口等类型。

具体来说，如果您有一个位于“mypackage1.mypackage2”中的类，这意味着java命令将期望在名为“mypackage1\mypackage2”的目录结构中找到它。在实际开发中，您可以自由地根据自己的需要创建包，并为这些包选择合适的名称。例如，可以创建名为com.example.myapp的包，然后在该包下创建对应的源文件。

需要注意的是，虽然包名必须出现在物理路径中，但实际上，在不同的物理路径（如src, testsrc）下可以使用相同的包名。此外，使用包的主要优点之一是可以避免命名冲突，并且使得定位相关类更加简单。

2.6 Java常用包

在Java编程语言中，有许多预定义的包和第三方包被广泛使用。以下是一些常用的包：

• 1、Java.lang包：这个包下包含了Java语言的核心类，如String、Math、Sytem和Thread类等，使用这个包无需使用import语句导入，系统会自动导入这个包中的所有类。

• 2、Java.util包：这个包下包含java的大量工具类/接口和集合框架类/接口。 如Arrays和List、Set等。

• 3、Java.net包：这个包下包含了一些Java网络编程相关的类/接口。

• 4、java.io包： 这个包含了一些Java输入/输出编程相关的类/接口。

• 5、java.text: 这个包下包含一些Java格式化相关的类。

• 6、java.sql包： 这个包下包含了java进行JDBC数据库编程的相关类/接口。

• 7、java.awt包：这个包下包含了图形界面（GUI）相关的类和接口。

三、访问修饰符

3.1 什么是访问修饰符

在Java编程语言中，访问修饰符是一种关键的机制，它用于限制对类、变量、方法和构造方法的访问权限。具体来说，访问修饰符可以确定这些成员的可见性和访问范围。

3.2 访问修饰符的分类

Java语言提供了四种不同的访问权限：public、protected、default（即默认或不加任何修饰符）、private。

• 1、public：公共权限，可以被任意类访问，无论是否在同一包或不同包中。它可以修饰类、成员变量、方法和内部类。

• 2、protected：受保护的权限，可以被同包类访问，如果不是同包的类，必须是该类的子类才可以访问。它主要修饰成员变量、方法和内部类。

• 3、default（或不加任何修饰符）：在同一包内可见，不使用任何修饰符。它可以修饰类、接口、变量、方法和内部类。

• 4、private：私有权限，只能在本类中访问，即使是同包的其他类也不能访问。它主要修饰成员变量和方法是最常用的。

通过使用这些访问修饰符，我们可以有效地控制代码的封装性和安全性，防止不必要的修改和冲突。例如，我们可以使用private修饰符来隐藏实现细节，只暴露必要的接口；或者使用protected修饰符来控制子类对父类的继承和访问等。总的来说，访问修饰符是Java面向对象编程的重要特性之一，对于编写安全、可维护的代码至关重要

四、构造方法

4.1 什么是构造方法

在Java编程语言中，构造方法是一种特殊类型的方法，它的主要作用是在创建对象时执行一些必要的初始化操作。构造方法的名称必须与类名完全相同，并且没有返回值类型。

构造方法的语法结构是：[修饰符列表] 构造方法名(形式参数列表){ 构造方法体； }。这里的形式参数列表是可选的，可以没有参数。当通过new关键字创建一个新的对象时，就会自动调用与该对象对应的类的构造方法。

例如，一个简单的构造方法可能会看起来像这样：public class Person { public Person() { System.out.println(“A new person is created!”); } }。在这个例子中，Person就是类名，和构造方法名相同，并且没有形式参数列表。当创建Person类的新对象时，就会打印出"A new person is created!"。

此外，构造方法还具有以下特点：它们不能被程序手动调用，并且不能有返回值（也就是说，不需要使用return语句）。构造方法经常用于给一个类的实例变量赋初值，或者执行其他必要的步骤来创建一个完整的对象。

4.2 构造方法和静态代码块

Java中的构造方法和静态代码块是两种特殊的方法，它们在类中有不同的用途。

构造方法：构造方法是一种特殊的方法，用于初始化对象。它的名称与类名相同，没有返回类型。当创建类的对象时，构造方法会自动被调用。如果没有显式地定义构造方法，编译器会自动为类生成一个默认的无参构造方法。
示例：

public class MyClass {
    int x;

    // 构造方法
    public MyClass() {
        x = 10;
    }

    public static void main(String[] args) {
        MyClass obj = new MyClass(); // 自动调用构造方法
        System.out.println("x = " + obj.x);
    }
}

静态代码块：静态代码块是在类加载时执行的一段代码，它只执行一次。静态代码块通常用于初始化静态变量或执行一些只需要执行一次的操作。静态代码块使用关键字static和大括号{}包围。

public class MyClass {
    static int y;

    // 静态代码块
    static {
        y = 20;
        System.out.println("静态代码块执行");
    }

    public static void main(String[] args) {
        System.out.println("y = " + y);
    }
}

在这个示例中，静态代码块在类加载时执行，并将变量y的值设置为20。

五、重载

5.1 为什么使用重载

Java使用重载的主要原因是提高代码的可读性和可维护性。方法的重载是一个类中定义了多个方法名相同，而他们的参数的数量不同或数量相同而类型和次序不同，则称为方法重载。

这种特性使得程序员可以根据不同的参数情况，调用相应的方法，无需为每个参数情况编写不同的方法名称，从而减少代码量，使代码更加简洁。此外，当方法的参数类型、参数个数或参数顺序发生变化时，只需要增加新的方法即可，无需修改原有的方法，这也有利于提高代码的可维护性。

需要注意的是，对于重载的方法，它们的返回类型可以不相同，也可以有不同的修饰符。然而，如果两个方法具有相同的名称、参数和返回类型，那么这不是有效的方法重载示例，这将引发编译错误。

5.2 构造方法的重载

Java中的构造方法也可以进行重载，即在同一个类中定义多个构造方法，这些构造方法的名称相同但参数列表不同。

通过构造方法的重载，我们可以实现不同的初始化逻辑，根据传入的参数来创建对象并初始化其属性。例如：

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

    // 无参构造方法
    public Person() {
        this.name = "";
        this.age = 0;
        this.height = 0.0;
    }

    // 带一个参数的构造方法
    public Person(String name) {
        this.name = name;
        this.age = 0;
        this.height = 0.0;
    }

    // 带两个参数的构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        this.height = 0.0;
    }

    // 带三个参数的构造方法
    public Person(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }
}

在这个例子中，我们定义了四个构造方法，它们的名称都是Person，但是参数列表不同。当我们使用不同的参数调用这些构造方法时，就会创建出不同类型的Person对象。

5.3 成员方法的重载

Java中的成员方法也可以进行重载，即在同一个类中定义多个同名但参数列表不同的方法。

通过成员方法的重载，我们可以实现不同的功能，根据传入的参数来执行相应的操作。例如：

public class Calculator {
    // 加法运算
    public int add(int a, int b) {
        return a + b;
    }

    // 减法运算
    public int subtract(int a, int b) {
        return a - b;
    }

    // 乘法运算
    public int multiply(int a, int b) {
        return a * b;
    }

    // 除法运算
    public double divide(double a, double b) {
        if (b == 0) {
            throw new IllegalArgumentException("除数不能为0");
        }
        return a / b;
    }
}

在这个例子中，我们定义了四个成员方法，它们的名称都是add，但是参数列表不同。当我们使用不同的参数调用这些方法时，就会执行不同的操作。其中，divide方法还进行了除数是否为0的判断，如果为0则抛出异常。

六、this

this关键字在Java中用于引用当前对象。它可以在类的成员方法中使用，以区分成员变量和方法参数。以下是一些使用this关键字的示例：

访问成员变量：

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

    public void setName(String name) {
        this.name = name; // 使用this关键字访问成员变量name
    }

    public void setAge(int age) {
        this.age = age; // 使用this关键字访问成员变量age
    }
}

调用其他成员方法：

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

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

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

    public void display() {
        System.out.println("姓名：" + this.name + "，年龄：" + this.age);
    }
}

构造函数中的this关键字：

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

    public Student(String name, int age) {
        this.name = name; // 使用this关键字将参数值赋给成员变量name
        this.age = age; // 使用this关键字将参数值赋给成员变量age
    }
}