【JAVA】十、根本知识“类和对象”干货分享~（三）
目次1. 封装
1.1 封装的概念
1.2 访问限定符
public（公开访问）
private（私有访问）
1.3 包
1.3.1 包的概念
1.3.2 导入包中的类
1.3.3 自界说包
2. static成员
2.1 static变量（类变量）
2.1.1 static修饰成员变量
2.2 static方法（类方法）
2.2.1 static修饰成员方法
2.3 static成员变量初始化
3. 代码块
3.1 代码块概念以及分类
3.1.1 平凡代码块（少用）
3.1.2 构造代码块（实例代码块）
3.1.3 静态代码块
https://i-blog.csdnimg.cn/direct/8a810cdba8944fa9adee79daaf0f6d8c.png
1. 封装
1.1 封装的概念
在 Java 中，面向对象步伐三大特性：封装，继续，多态。而封装是面向对象编程（OOP）的核心概念之一，它的核心头脑是将数据（属性）和操纵数据的方法（举动）捆绑在一起，并潜伏对象的内部实现细节，仅对外公开可控的访问接口来和对象举行交互。简单来说就是套壳屏蔽细节啦~
而且封装通过限定对对象内部状态的直接访问，进步了代码的安全性、可维护性和机动性。
1.2 访问限定符
Java 中的访问限定符用于控制类、成员变量、方法和构造方法的可见性，是实现封装的紧张机制。共有四种访问修饰符：public、protected、默认、private。在这里博主先先容public修饰符，再先容private修饰符，剩下两个修饰符不做过多形貌~
[*] public（公开访问）
作用范围：全部类均可访问。
利用的场景：
对外袒露的接口或工具类（如 public class Main）。
常量（如 public static final）。
public class Animal {
public String name; // 任何类都可以访问
}
[*] private（私有访问）
封装性：优先利用 private，通过公共方法控制访问。
作用范围：仅限于声明它的类内部。
利用场景：
封装类的内部状态（如私有字段）。
单例模式的私有构造方法。
public class Student {
private String id; // 仅本类可以访问
public String getId() { // 通过公共方法暴露出来
return id;
}
} 1.3 包
1.3.1 包的概念
在 Java 中，包是一种用于构造类和接口的定名空间机制。它雷同于文件体系中的文件夹，内里存有许多文件，紧张目的是克订定名辩论、控制访问权限。
为了更好的管理，把多个类网络在一起成为一组，称为软件包。
包有一个很紧张的作用：差异包中可以存在雷同名称的类，克制类名的辩论。
1.3.2 导入包中的类
下面这一段代码是输出数组的内容，我们通过这段代码来举行导入包中的类的解说：
// 导入Arrays类（位于java.util包中）
import java.util.Arrays;
public class Test3 {// 类名建议首字母大写
public static void main(String[] args) {
// 创建并初始化一个int数组
int[] array = {1, 2, 3};
// 使用Arrays类的静态方法toString()转换数组为字符串
// 注意：Arrays是类名，Array是Java中的数组关键字，不要混淆
System.out.println(Arrays.toString(array));// 输出
}
}
[*] 导入包
利用 Arrays 类前需导入包：可以利用import语句导入包：
import java.util.Arrays; // 必须添加在代码开头
[*]Arrays.toString(array)
[*]Arrays 是 Java 提供的工具类（位于 java.util 包），用于操纵数组。
[*]toString() 是它的静态方法，功能是将数组元素转换为可读的字符串格式。
System.out.println(Arrays.toString(array)) 这行Java代码的作用是将数组 array 的内容转换为字符串并输出到控制台。
假如直接打印数组对象 System.out.println(array)，输出的是数组的哈希值（如 [I@1b6d3586），这时间没办法看到实际内容。
利用 Arrays.toString() 后，输出的是直观的数组元素。
我们也可以利用import static导入包中的静态的方法和字段，后续代码中可以直接利用静态成员，无需通过类名调用。
// 使用静态导入：导入Arrays类中的toString方法
// 使得可以直接调用toString()而无需写类名Arrays
import static java.util.Arrays.toString;
public class test3 {
public static void main(String[] args) {
// 定义一个int数组
int[] array = {1, 2, 3};
// 直接调用静态导入的toString方法，等价于Arrays.toString(array)
System.out.println(toString(array));//输出
}
} 1.3.3 自界说包
选中src，右键点击 src 目次，点击New（新建），再点击Package（软件包），创名字（名字全小写），末了就创建好了包。https://i-blog.csdnimg.cn/direct/3023ebe48acf44b29504c58be6c93b9e.png
https://i-blog.csdnimg.cn/direct/ba4ba5e3b9c642128e0e641fe09d6c4f.png
2. static成员
在之前的博客中我们举了门生类来举行干系知识点解说，如今同样我们再用门生类举例：
https://i-blog.csdnimg.cn/direct/cf49a654865741eeaad6b27980a8cf9c.png
上述三者都是成员变量。成员变量界说在方法的外部，类的内部。此中schoolName用static修饰之后，就不存在于对象当中了，而存在于方法区当中。
全部门生共享学校名称：每个门生对象都有自己的 name 和 age，但 schoolName 是全部门生共享的。修改一次，全部对象看到的都会厘革。
直接通过类名访问：比方 Student.schoolName
2.1 static变量（类变量）
2.1.1 static修饰成员变量
[*] 用static修饰的成员属于类自己（schoolName被static修饰）
[*] 全部对象共享同一个static变量
[*] 示例中的schoolName被全部Student对象共享
[*] 静态成员变量访问方式：类名.变量名（而非静态成员变量属于对象，访问方式是：引用.变量名）
[*] 静态成员变量不依赖于对象，不消实例化都可以
2.2 static方法（类方法）
2.2.1 static修饰成员方法
https://i-blog.csdnimg.cn/direct/8b685565682540fe97a3221817b84558.png
[*]②静态成员方法中，利用时也是不依赖于对象的
[*] ②静态成员方法无需实例化：可通过类名.方法名()直接调用
[*] changeSchool() 通过类名调用（如 Student.changeSchool("盼望中学")），修改全部门生共享的 schoolName
[*]在②静态成员方法内里，不能 直接 调用①非静态成员方法或成员变量，在 changeSchool() 中实验访问 name 或 age 会报错，由于static 方法中没有 this 引用
假如肯定要在静态成员方法里调用的话，肯定要通过对象的引用来调用！即：
https://i-blog.csdnimg.cn/direct/becfe976eec342d78f27e9d4a243528b.png
完备代码如下：
public class Student {
// 实例变量 - 每个学生对象独有的属性
String name; // 学生姓名
int age; // 学生年龄
// static成员 - 属于类本身的属性（所有对象共享）
static String schoolName = "阳光中学"; // 学校名称（所有学生相同）
// 构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
// 实例方法 - 需要创建对象后才能调用
void showInfo() {
System.out.println(name + "，" + age + "岁，就读于" + schoolName);
}
// static方法 - 通过类名直接调用
static void changeSchool(String newName) {
schoolName = newName; // 修改所有学生共享的学校名称
}
}
// 测试类
public class Main {
public static void main(String[] args) {
// 访问static变量（不需要创建对象）
System.out.println("当前学校：" + Student.schoolName);
// 创建两个学生对象
Student s1 = new Student("张三", 15);
Student s2 = new Student("李四", 16);
// 调用实例方法
s1.showInfo(); // 张三，15岁，就读于阳光中学
s2.showInfo(); // 李四，16岁，就读于阳光中学
// 通过类名调用static方法修改学校名称
Student.changeSchool("希望中学");
System.out.println("\n修改后的学校信息：");
s1.showInfo(); // 张三，15岁，就读于希望中学
s2.showInfo(); // 李四，16岁，就读于希望中学
// 再次直接访问static变量
System.out.println("当前学校：" + Student.schoolName);
}
} 2.3 static成员变量初始化
静态成员变量一样寻常不会放在构造方法中初始化，构造方法内里初始化的是与对象干系的实例属性。
初始化方式分为两种：就地初始化和静态代码块初始化
就地初始化在界说时直接给出初始值：
static String schoolName = "阳光中学"; // 最常用的初始化方式 静态初始化我们在背面举行先容
3. 代码块
3.1 代码块概念以及分类
https://i-blog.csdnimg.cn/direct/568cd096e2524d7f912ceb0ae083add2.png
如图，利用{ }界说的一段代码称为代码块。 可以分为四类：
[*]平凡代码块 构造块 静态块 同步代码块
3.1.1 平凡代码块（少用）
[*]在方法内部用{ }包裹的代码块
void showInfo() {
{ // 普通代码块开始
int temp = 10;
System.out.println("变量是：" + temp);
} // temp变量在这里被销毁
// System.out.println(temp); // 这里会报错，temp已经不可用啦
} 3.1.2 构造代码块（实例代码块）
[*]类中直接利用{ }包裹的代码块（不加修饰符）。也叫做实例代码块，构造代码块一样寻常用于初始化实例成员变量，这个代码块在方法的表面，类的内里。
[*]每次创建对象时自动实验，且在构造方法之前
public class Student {
// 实例变量
String name;
int age;
// ---------- 构造代码块 ----------
{
// 这个代码块会在每次创建对象的时候执行
System.out.println("执行构造代码块");
age = 10; // 为所有学生设置默认年龄10
}
// -----------------------------
// 构造方法
public Student(String name, int age) {
System.out.println("执行构造方法");
this.name = name;
this.age = age; // 会覆盖构造代码块中的默认值
}
} 3.1.3 静态代码块
[*]利用static { }包裹的代码块称为静态代码块。一样寻常用于初始化静态成员变量。
[*]类初次加载时实验，且仅仅实验一次
public class Student {
static String schoolName;
// 静态代码块
static {
System.out.println("静态代码块啦~");
schoolName = "希望中学";
}
} 静态代码块只会实验一次，只要类被加载，就会被实验，而实例代码块肯定是实例化对象的时间被实验。
假如三者都存在时，实验序次：①静态代码块 ②实例代码块 ③不带参数的构造方法。
盼望能帮到友友们的学习~
制作不易，更多内容加载中~感谢友友们的点赞收藏关注~~
如有标题欢迎品评指正，祝友友们生存舒畅，学习工作顺顺遂利！
https://i-blog.csdnimg.cn/direct/de2e0ad3491844888dd2bd1bf179b990.gif
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]