🔥博客主页🔥：【 坊钰_CSDN博客 】
欢迎各位点赞👍评论✍收藏⭐
目录
1. 封装的概念
1.1 一个例子
2. 访问权限控制符
3. 包的概念
3.1 import 导入
3.2 常见的包
4. static 静态成员
4.1 static 使用情况
4.2 static 修饰成员变量
4.3 static 修饰成员方法
4.4 static 初始化
4.4.1 就地初始化
4.4.2 静态代码块初始化
5. 代码块
5.1 普通代码块
5.2 构造代码块
5.3 静态代码块
6. 小结
1. 封装的概念
Java 对于面向对象来说，有三大特点 封装、继承、多态，而本次讲解 封装 的特性
1.1 一个例子
比如汽车， 提供给驾驶员的只有：油门、刹车、离合等... 驾驶员用这些来操作汽车，但汽车是由很多零件组成的，如：发动机、轮胎、引擎等... 但对于使用者来说，不用担心，这些零件是如何运作的，这就大大提高了效率，所以，汽车在出厂时，只用把一些零件封装在内部即可，只需要驾驶员操作油门、刹车、离合等... 就可以操作汽车了
封装：将数据和方法进行有机结合，隐藏对象的属性和细节，仅对外公开接口与对象进行交互
2. 访问权限控制符
Java 用访问权限控制符来进行封装，Java 提供四种访问权限控制符（访问限定符）
分别是：
- private 同一个包的同一个类本类中使用
- default 同一个包的不同类使用 + private 的范围
- protected 不同包的子类 + default 的范围
- public 不同包的非子类 + protect 的范围
- protected 主要用于继承，后续讲解
- default 成员属性什么都不写时，自动添加
- 访问限制符不但可以控制变量，还可以控制类
3. 包的概念
在面向对象编程中，提出了一个包的概念
为更好管理类，把多个类管理成一组，进而形成了包
比如：电脑用文件夹来分类电影的种类
在 Java 也引入了包，包时对类和接口封装机制的体现，相同名字的类只要放在不同的包中就不会报错
3.1 import 导入
Java JDK 中为我们提供了很多现成的类，如：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);
}
}这时就可以用 import 关键字来导入包了
import java.util.Date;
public class Test {
public static void main(String[] args) {
//得到一个毫秒级的时间戳
Date date = new java.util.Date(); //这边可以直接定义
System.out.println(date);
}
}写成这样也可以
import java.util.*;
public class Test {
public static void main(String[] args) {
//得到一个毫秒级的时间戳
Date date = new java.util.Date(); //这边可以直接定义
System.out.println(date);
}
}
区别：
import java.util.*; // ‘*’ 表示导入 java.util 中的所有类
import java.util.Date; // 这个是导入 java.util 的指定类有一些情况要用完整的类名
import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
//得到一个毫秒级的时间戳
java.util.Date date1 = new java.util.Date();
}
}因为，两个包中都有 Date 类，要使用时，用哪个就写那个的完整类名
3.2 常见的包
JDK 自带的有很多包，下面举几个常见的包
- java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入
- java.lang.reflect:java 反射编程包
- java.net:进行网络编程开发包
- java.sql:进行数据库开发的支持包
- java.util:是java提供的工具程序包。(集合类等) 非常重要
- java.io:I/O编程开发包
4. static 静态成员
4.1 static 使用情况
在 Java 中，关于 static 关键字，被 static 修饰的成员，都从属于类，属于类变量，对于所有的对象来说是共享的
一个班级有三个学生，学生 A ，学生 B ，学生 C ，现建立 3 个对象来表示他们
public class Student {
String name;
int age;
String classroom;
public Student(String name, int age, String classroom) {
this.name = name;
this.age = age;
this.classroom = classroom;
}
public static void main(String[] args) {
Student student1 = new Student("小明",18,"115班");
Student student2 = new Student("李华",16,"115班");
Student student3 = new Student("小红",19,"115班");
}
}
大家发现，只要是这个班的的同学，都有一个固定的属性，没错是 115 班，这时就可以用 static 关键字了
4.2 static 修饰成员变量
上面说过，被 static 修饰的变量，称为静态变量（类变量）
静态变量的特性
- 是从属于类的，不属于任何对象，但是被所有对象共享
- 可以通过类访问，也能通过对象访问，更推荐类访问
- 静态变量存储在方法区中
- 生命周期和类一致，随类创建而创建，销毁而销毁
上面代码可优化
public class Student {
String name;
int age;
static String classroom = "115班";
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "[ " + name +
" " + age +
" " + classroom +
" ]";
}
public static void main(String[] args) {
Student student1 = new Student("小明",18);
Student student2 = new Student("李华",16);
Student student3 = new Student("小红",19);
}
}
- 被 static 修饰后，为类变量，被所有对象共享
4.3 static 修饰成员方法
与成员变量一样，成员方法被 static 修饰之后，为静态成员方法，是属于类的方法，当然也被对象共享，对象也可以调用
静态成员方法特性
- 从属于类，被对象共享
- 通过类和对象都可以调用，更推荐类调用
- 在静态方法中，不能使用任何非静态成员变量
- 但是，非静态方法，可以用静态成员变量
- 静态成员变量中，不能出现 this 关键字，无法传递 this 引用
public class Student {
private String name;
private int age;
static String classroom = "115班";
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public static void write() { //静态成员方法
System.out.println("写作业......");
}
public String toString() {
return "[ " + name +
" " + age +
" " + classroom +
" ]";
}
public static void main(String[] args) {
Student student = new Student("小明",18);
student.write(); //通过对象调用
Student.write(); //直接类调用
}
}
4.4 static 初始化
静态成员变量的初始化一般不会放在构造方法中初始化，它的初始化有两种
4.4.1 就地初始化
在创建变量时直接初始化
static String classroom = "115班";4.4.2 静态代码块初始化
什么是代码块呢？
5. 代码块
把使用 { } 定义的代码称为代码块，代码块分为以下 3 种（目前）：
- 普通代码块
- 构造代码块
- 静态代码块
5.1 普通代码块
直接用 { } 定义代码
public class Main {
public static void main(String[] args) {
{
int a = 10;
System.out.println(a);
}
}
}5.2 构造代码块
在类中定义的代码块，一般用来初始化成员变量
public class Main {
String name;
int age;
String classroom;
int scroce;
{
//构造代码块，也叫实例代码块
name = "张三";
age = 18;
classroom = "115班";
scroce = 90;
}
public static void main(String[] args) {
}
}
5.3 静态代码块
就像名字说的那样，一般用于初始化静态变量
public class Main {
String name;
int age;
int scroce;
static String classroom;
{
//构造代码块，也叫实例代码块
name = "张三";
age = 18;
scroce = 90;
}
static {
//静态代码块
classroom = "115班";
}
public static void main(String[] args) {
}
}
- 静态代码最先执行，且只执行一次
- 静态代码块，{ } 前有 static 修饰
6. 小结
以上就是对封装和 static 的了解，具体还需宝子们去实践，如果觉得该博客对你有用的话，希望一键三连，点个关注不迷路，谢谢支持 ！
