Java——类与对象(封装)

简介: 封装是面向对象编程中的概念,指将数据(属性)和相关操作(方法)组合成独立单元(类),使外部无法直接访问对象的内部状态,只能通过提供的方法进行交互,从而保护数据安全。例如,手机将各种组件封装起来,只暴露必要的接口供外部使用。实现封装时,使用`private`关键字修饰成员变量,并提供`get`和`set`方法进行访问和修改。此外,介绍了包的概念、导入包的方式及其注意事项,以及`static`关键字的使用,包括静态变量和方法的初始化与代码块的加载顺序。

封装的概念

封装是指将数据(属性)和相关的操作(方法)绑定在一起,形成一个独立的单元(即类)。封装后,对象的内部状态(属性)对外界是不可见的,只能通过对象提供的方法来访问和修改内部状态。这样可以保护对象的状态不被随意修改,提高数据的安全性。
也就类似于手机,产家把手机的各种零件都封装起来,只留下接口被外界使用,这样就很好的保护了手机的零件。

封装的实现

我们所要实现的效果就是,让外界拿不到类的内部属性,那么就需要使用private关键字来修饰成员变量,private是一个权限修饰符,可以修饰成员变量和成员方法,被private修饰的成员只能在本类中才能访问

可以明显的看到,当私有化成员变量的时候,在Text类中再访问这些变量就会报错,那么怎么访问呢
针对每一个私有化成员变量都需要写对应的get和set方法

public class Student {
    //private修饰成员变量,外界不可访问
    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) {
        this.age = age;
    }
}


因为get和set方法是public修饰的,就相当与留给外界访问的接口,通过以上的代码就实现了对student类的一个封装

包的概念

其实包就是一个文件夹,类就是具体的文件,为了更好的管理类,把多个类收集在一起成为一组,就称为软件包

上面的包名中,每一个包就代表一个文件夹,com.sun也就是sun公司域名的反写

import 导包

import java.util.Arrays;
import java.util.Date;
public class Demo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(arr));
        Date date = new Date();
        System.out.println(date);
    }
}

例如上面的Date 类和 Array类,java默认会加载一个java.long包,我们要创建Date对象或者Array对象,或是要用到这些类有关的方法就需要导入相关的包名

如果不导包也有一种写法

//import java.util.Arrays;
public class Demo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(java.util.Arrays.toString(arr));
    }
}

但是这样写的话,每写一次就需要写一长串,导包之后就方便了很多,是不是感觉和C++中的using namespace 有些类似

#include <iostream>
  
int main() { 
    std::cout << "Hello, World!" << std::endl;
    return 0; 
}

如果不写using namespace std;的话,每次使用std(标准)命名空间中的名称,都加上std::前缀,所以为了方便就会这样写

#include <iostream>
using namespace std;
int main() { 
    cout << "Hello, World!" << endl;
    return 0;

java中的import也是类似的道理

导包中*的介绍

import java.util.*;
/*import java.util.Arrays;
import java.util.Date;*/
public class Demo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(arr));
        Date date = new Date();
    }
}

这样写也是可以的 * 表示通配符,表示导入了java.util包下的所有类和接口
但是这样写虽然更简洁了,但是并不推荐这样写

例如上面的例子,util 和 sql 包底下都有Date类,这样就不知道写的是哪个包中的Date,所以编译器直接报错了,还是推荐导包的时候要导全

import static 导入包中的静态方法和字段

public class Demo {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;
        double res = Math.sqrt(Math.pow(x, 2)+ Math.pow(y, 2));
        System.out.println("两点之间的距离是:"+res);
    }
}

当导入静态方法之后
import static java.lang.Math.*;
就可以省略掉之前的Math.


其实System.out也是静态方法
那么也可以类似的进行静态导入

不过以上方法并不常用

static关键字的使用

static修饰符用于声明类的静态成员,包括静态变量(也称为类变量)和静态方法(也称为类方法)。当static修饰一个成员变量时,这个变量就变成了类级别的一个属性,而不是实例级别的。

static 修饰成员变量

先看一个例子

创建对象后开始调试:

换成public修饰成员变量className后:


可以看出,通过static修饰的成员变量被单独提出来,已经不属于对象了,并且存放在方法区当中,而对象是存在于堆内存中的
那么既然不属于对象了,怎么去访问呢

仍然可以通过对象名访问,但是并不推荐这种写法,因为static修饰的成员变量已经和对象没有关系了,推荐使用类名进行访问
通过static就可以把对象的公共属性设置成静态变量,通过类名访问。

static修饰方法

类似的,static修饰的成员方法称为静态方法,也是不依赖与对象的,通过类名调用

public class Text {
    public static void main(String[] args) {
        System.out.println(add(1, 1));
    }
    public static int add(int x, int y) {
        return x + y;
    }
}

我们在写方法的时候前面都是加上了static修饰,如果去掉就会报错,因为已经不是静态方法了,就要依赖与对象的创建,需要创建类的对象,再通过对象去调用方法

public class Text {
    public static void main(String[] args) {
        Text text = new Text();
        System.out.println(text.add(1, 1));
    }
    public int add(int x, int y) {
        return x + y;
    }
}

注意:
1.静态方法中不能用this关键字
2.静态方法中不能调用非静态的变量和方法
3.非静态方法可以使用静态方法或变量

静态成员变量的初始化

就地初始化

static int a = 1;

通过get set 方法初始化

public static void setClassName(String className) {
        Student.className = className;
    }
    public static String getClassName() {
        return className;
    }

构造方法初始化

public Student(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        className = "1";
    }

代码块初始化

static String className;
    static {
        className = "101";
    }

代码块

静态代码块

静态代码块定义在类中但在任何方法之外,并使用static关键字修饰。它们仅在类首次被加载到JVM时执行一次。静态代码块常用于初始化静态变量或执行只需执行一次的代码。

static {
        classNum = 1;
        System.out.println("静态代码块执行,一般用来初始化静态变量···");
    }

非静态代码块/实例化代码块/构造代码块

初始化代码块也称为实例初始化块或非静态初始化块。它们定义在类中但在任何方法之外。当创建类的实例时,这些代码块会被执行,且每次创建新实例时都会执行。它们通常用于初始化实例变量。

{
        this.age = 1;
        System.out.println("构造代码块执行,一般用来初始化实例变量···");
    }

加载顺序

我们来看输出结果:

如果再加上构造方法的话顺序就变成了,先加载静态代码块,再加载构造代码块,最后才是构造方法

所以我们创建一个类之后尽量按照
先写字段,再写静态代码块,构造代码块,构造方法
最后还有一个注意事项

public class Text {
    public static void main(String[] args) {
        Teacher teacher1 = new Teacher("张三", 30);
        System.out.println(Teacher.getClassNum());
        System.out.println("========");
        Teacher teacher2 = new Teacher("李四", 35);
        System.out.println(Teacher.getClassNum());
    }
}


这也就是开始说的,静态代码块仅在类首次被加载到JVM时执行一次

相关文章
|
1天前
|
Java
颠覆认知:一向主张可扩展性的Java,为何要推出封闭类?
本文介绍了Java的Sealed Classes(封闭类)功能,探讨了为何Java在强调可扩展性的同时引入这一特性。文章基于JDK 17.0.5,详细解释了Sealed Classes的概念及其作用。通过对比final类和package-private类,阐述了封闭类在提高安全性和控制扩展性方面的优势。最后,通过具体示例展示了如何使用sealed关键字以及相关语法。了解这一新特性有助于我们更好地把握Java未来的发展趋势。
11 2
|
21小时前
|
Java
java构造方法时对象初始化,实例化,参数赋值
java构造方法时对象初始化,实例化,参数赋值
7 1
|
1天前
|
存储 Java
深入理解java对象的访问定位
这篇文章深入探讨了Java对象的访问定位机制,比较了使用句柄和直接指针两种主流的对象访问方式,并指出了它们各自的优势,例如句柄访问在对象移动时的稳定性和直接指针访问的速度优势。
8 0
深入理解java对象的访问定位
|
1天前
|
存储 Java
深入理解java对象的内存布局
这篇文章深入探讨了Java对象在HotSpot虚拟机中的内存布局,包括对象头、实例数据和对齐填充三个部分,以及对象头中包含的运行时数据和类型指针等详细信息。
7 0
深入理解java对象的内存布局
|
2天前
|
Java
java中父类方法return this.对象还是变量,子类去调用this.这个方法的问题
本文探讨了在Java中,当父类的方法返回`this`对象或变量时,子类调用该方法的行为,以及`this`关键字在不同类中调用方法时的指向问题。
6 0
java中父类方法return this.对象还是变量,子类去调用this.这个方法的问题
|
20小时前
|
Java
java的Random类和Arrays.sort类使用实例
java的Random类和Arrays.sort类使用实例
5 0
|
20小时前
|
Java
java值random类的使用
java值random类的使用
5 0
|
20小时前
|
Java
java的Math类和random类
java的Math类和random类
6 0
|
17天前
|
存储 Java
Java编程中的对象和类
【8月更文挑战第55天】在Java的世界中,“对象”与“类”是构建一切的基础。就像乐高积木一样,类定义了形状和结构,而对象则是根据这些设计拼装出来的具体作品。本篇文章将通过一个简单的例子,展示如何从零开始创建一个类,并利用它来制作我们的第一个Java对象。准备好让你的编程之旅起飞了吗?让我们一起来探索这个神奇的过程!
26 10
|
29天前
|
存储 Java
Java的对象和类的相同之处和不同之处
在 Java 中,对象和类是面向对象编程的核心。