目录
👩🏻💻封装
面向对象程序三大特性:封装、继承、多态
。而
类和对象阶段,主要研究的就是封装特性
。何为封装呢?简单来说就是套壳屏蔽细节
。
对于我们买电脑,我们买电脑的时候我们只看到外壳开关屏幕外观的美丽,但是内部的硬件是被封装起来的,我们通过开关键盘网卡等等来进行用户和计算机交互。但实际上:电脑真正工作的却是CPU、显卡、内存等一些硬件元件。
封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互
🚩访问限定符
Java
中主要通过类和访问权限来实现封装:
类可以将数据以及封装数据的方法结合在一起
,更符合人类对事物的认知,而访问权限用来控制方法或者字段能否直接在类外使用
。
Java
中提供了四种访问限定符:
比如:
- public:可以理解为一个人的外貌特征,谁都可以看得到
- default: 对于自己家族中(同一个包中)不是什么秘密,对于其他人来说就是隐私了(什么都不写,默认是default)
- private:只有自己知道,其他人都不知道
public class Computer {
private String cpu; // cpu
private String memory; // 内存
public String screen; // 屏幕
String brand; // 品牌---->default属性
public Computer(String brand, String cpu, String memory, String screen) {
this.brand = brand;
this.cpu = cpu;
this.memory = memory;
this.screen = screen;
}
public void Boot(){
System.out.println("开机~~~");
}
public void PowerOff(){
System.out.println("关机~~~");
}
public void SurfInternet(){
System.out.println("上网~~~");
}
}
class TestComputer {
public static void main(String[] args) {
Computer p = new Computer("HW", "i7", "8G", "13*14");
System.out.println(p.brand); // default属性:只能被本包中类访问
System.out.println(p.screen); // public属性: 可以任何其他类访问
//System.out.println(p.cpu); // private属性:只能在Computer类中访问,不能被其他类访问
}
}
解析:brand没有指明什么属性,所以默认是default属性,只能被本包中类访问,因为这个俩个类在一个文件中。public可以任何其他类访问,所以没有错误,而private只能在类中访问,不能被其他类访问,cpu是Computer类,当TestComputer类访问Computer类的时候是不被允许的。
注意:一般情况下成员变量设置为private,成员方法设置为public
上面我们看到default是只能在本包中类访问,包的概念是什么?包其实就是一个文件夹。
🚩封装扩展之包
在面向对象体系中,提出了一个软件包的概念,即:
为了更好的管理类,把多个类收集在一起成为一组,称为软件
包
。有点类似于目录。比如:为了更好的管理电脑中的歌曲,一种好的方式就是将相同属性的歌曲放在相同文件下,也可以对某个文件夹下的音乐进行更详细的分类。
在Java中也引入了包,包是对类、接口等的封装机制的体现,是一种对类或者接口等的很好的组织方式,比如:一 个包中的类不想被其他包中的类使用。包还有一个重要的作用:在同一个工程中允许存在相同名称的类,只要处在不同的包中即可。
src里面的Package是一个封装包 里面包含了名为Test的类,而src里面直接有一个Test类,如果我们没有设定什么封装包默认在src中。
👉导入包中的类
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
导入包中静态的方法和字段
import static java.lang.Math.*;
public class Test {
public static void main(String[] args) {
double x = 30;
double y = 40;
// 静态导入的方式写起来更方便一些.
// double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
double result = sqrt(pow(x, 2) + pow(y, 2));
System.out.println(result);
}
}
注意事项
:
import
和
C++
的
#include
差别很大
. C++
必须
#include
来引入其他文件内容
,
但是
Java
不需要
. import 只是为了写代码的时候更方便
.
import
更类似于
C++
的
namespace
和
using
👉自定义包
- 在文件的最上方加上一个 package 语句指定该代码在哪个包中.
- 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.cl.demo1 ).
- 包名要和代码路径相匹配. 例如创建 com.cl.demo1 的包, 那么会存在一个对应的路com/cl/demo1 来存储代码.(基本上包名java.util....)
- 如果一个类没有 package 语句, 则该类被放到一个默认包中.
🕶️操作步骤
1.
在
IDEA
中先新建一个包
:
右键
src ->
新建
->
包
2.
在弹出的对话框中输入包名
,
例如
com.cl.demo1
3.
在包中创建类
,
右键包名
->
新建
->
类
,
然后输入类名即可
.
![](https://i-blog.csdnimg.cn/blog_migrate/57e4cf0ff377861246fea7150cce2fb8.png)
4.
此时可以看到我们的磁盘上的目录结构已经被
IDEA
自动创建出来了
5.
同时我们也看到了
,
在新创建的
Test.java
文件的最上方
,
就出现了一个
package
语句
👉包的访问权限控制举例
Computer
类位于
com.cl.demo1
包中,
TestComputer
位置
com.cl.demo2
包中:
🕶️常见的包
- 1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
- 2. java.lang.reflect:java 反射编程包;
- 3. java.net:进行网络编程开发包。
- 4. java.sql:进行数据库开发的支持包。
- 5. java.util:是java提供的工具程序包。(集合类等) 非常重要
- 6. java.io:I/O编程开发包。
👩🏻💻static成员
使用前文中介绍的学生类实例化三个对象
s1
、
s2
、
s3
,每个对象都有自己特有的名字、性别,年龄,学分绩点等成 员信息,这些信息就是对不同学生来进行描述的,如下所示:
public class Student{
// ...
public static void main(String[] args) {
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);
}
}
假设三个同学是同一个班的,那么他们上课肯定是在同一个教室,那既然在同一个教室,那能否给类中再加一个成 员变量,来保存同学上课时的教室呢?答案是不行的。
之前在
Student
类中定义的成员变量,每个对象中都会包含一份
(
称之为实例变量
)
,因为需要使用这些信息来描述 具体的学生。而现在要表示学生上课的教室,这个教室的属性并不需要每个学生对象中都存储一份,而是需要让所 有的学生来共享。
在Java中,被static修饰的成员,称之为静态成员,也可以称为类成员,其不属于某个具体的对象,是所有对象所共享的。
🚩static修饰成员变量
static
修饰的成员变量,称为静态成员变量
,静态成员变量最大的特性:
不属于某个具体的对象,是所有对象所共
享的
。 直接用类名.访问。
【静态成员变量特性】
- 1. 不属于某个具体的对象,是类的属性,所有对象共享的,不存储在某个对象的空间中
- 2. 既可以通过对象访问,也可以通过类名访问,但一般更推荐使用类名访问
- 3. 类变量存储在方法区当中,对象存在堆区
- 4. 生命周期伴随类的一生(即:随类的加载而创建,随类的卸载而销毁)
监视窗口中可以看到,静态成员变量并没有存储到某个具体的对象中。
🚩static修饰成员方法
一般类中的数据成员都设置为
private
,而成员方法设置为
public
,那设置之后,
Student
类中
classRoom
属性如何 在类外访问呢?
![](https://i-blog.csdnimg.cn/blog_migrate/7222ab202138f9fdd154d0ae487efe9c.png)
![](https://i-blog.csdnimg.cn/blog_migrate/617e0790ab12b95f765f68889481f24a.png)
Java
中,
被static修饰的成员方法称为静态成员方法,是类的方法,不是某个对象所特有的。
静态成员一般是通过 静态方法来访问的。(一个类里声明一个静态成员方法,然后再另一个类接收这个静态成员方法的返回值)
【 静态方法特性 】
- 1. 不属于某个具体的对象,是类方法
- 2. 可以通过对象调用,也可以通过类名.静态方法名(...)方式调用,更推荐使用后者
- 3. 不能在静态方法中访问任何非静态成员变量
但是可以再非静态成员方法中访问静态成员变量
- .4 静态方法中不能调用任何非静态方法,因为非静态方法有this参数,在静态方法中调用时候无法传递this引用
public static String getClassRoom (){doClass ();return classRoom ;}
🚩static成员变量初始化
注意:静态成员变量一般不会放在构造方法中来初始化,构造方法中初始化的是与对象相关的实例属性
静态成员变量的初始化分为两种:就地初始化 和 静态代码块初始化
。
1. 就地初始化
就地初始化指的是:在定义时直接给出初始值
2. 静态代码块初始化
那什么是代码块呢?继续往后看
:) ~~~
👩🏻💻代码块
🎈代码块概念以及分类
使用 {} 定义的一段代码称为代码块 。根据代码块定义的位置以及关键字,又可分为以下四种:
- 普通代码块
- 构造块
- 静态块
- 同步代码块(后续讲解多线程部分再谈)
🚩普通代码块
普通代码块:定义在方法中的代码块
❗构造代码块
构造块:定义在类中的代码块
(
不加修饰符
)
。也叫:
实例代码块
。
构造代码块一般用于
初始化实例成员变量。
实例代码块只有在创建对象时才会执行。(所以我们再创建对象的时候,实例化代码块执行)
❗静态代码块
使用
static
定义的代码块称为静态代码块。
一般用于初始化静态成员变量。
注意事项
- 静态代码块不管生成多少个对象,其只会执行一次
- 静态成员变量是类的属性,因此是在JVM加载类时开辟空间并初始化的
- 如果一个类中包含多个静态代码块,在编译代码时,编译器会按照定义的先后次序依次执行(合并)
- 实例代码块只有在创建对象时才会执行,静态代码块在加载内存的时候执行。所以惊天比实例先打印,但是静态代码块只打印一次。
我们会有怎样的未来?