• 【JavaSE】类和对象 【封装、static、代码块、对象的打印】(三)


    目录

    前言:

    1、封装

    1.1、封装的概念

    1.2、访问限定符

    1.3、封装扩展之包

    1.3.1、包的概念

    1.3.2、导入包中的类

     1.3.3、自定义包

    1.3.4、常见的包

    1.4、封装的应用

    2、static成员

    2.1、再谈成员变量

    2.2、static修饰成员变量

    2.3、static修饰成员方法

    2.4、static成员变量初始化

    3、代码块

    3.1、代码块概念以及分类

    3.2、普通代码块

    3.4、构造代码块

     3.5、静态代码块

    4、对象的打印 


    前言:

    面向对象的3大特性:封装、继承、多态,今天来说一下封装,来认识一下什么是封装?封装有什么意义?

    1、封装

    1.1、封装的概念

    面向对象程序三大特性:封装、继承、多态。而类和对象阶段,主要研究的就是封装特性。何为封装呢?简单来说就是套壳屏蔽细节。

    举例来说:就电脑这样的一个复杂的设备,提供给用户的就只是:开关机、通过键盘输入、显示器、USB插孔等,让用户来和计算机进行交互,完成日常事务。但实际上:电脑工作的是cpu,显卡,内存等一些硬件元件被封装在主机中。

    封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互。


    1.2、访问限定符

    Java中主要通过类和访问权限来实现封装:类可以将数据以及封装数据的方法结合在一起,更符合人类对事物的认知,而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符:

    java中的四个访问修饰限定符:

     总结:

    1.  public: 所修饰的类、变量、方法,在内外包均具有访问权限;
    2. protected: 这种权限是为继承而设计的,protected所修饰的成员,对所有子类是可访问的,但只对同包的类是可访问的,对外包的非子类是不可以访问;
    3. 包访问权限(default): 只对同包的类具有访问的权限,外包的所有类都不能访问;
    4. private: 私有的权限,只对本类的方法可以使用;

    1、private:

    2、包的访问权限(default)

    只能在同一个包当中使用(同一个类、不同类都可以使用)。

     

     

    3、 protectde 和public在学了继承之后再说。


    1.3、封装扩展之包

    1.3.1、包的概念

    在面向对象体系中,提出里一个软件包的概念,即:为了更好的管理类,把多个类收集在一起成为一组,成为软件包。有点类似于目录。

    比如:为了更好的管理电脑中的歌曲,一种好的方式就是将相同属性的歌曲放在相同文件
    下,也可以对某个文件夹下的音乐进行更详细的分类。

    • 在Java中也引入了包,包是对类、接口等的封装机制的体现,是一种对类或者接口等的很好的组织方式,比如:一个包中的类不想被其他包中的类使用。
    • 包还有一个重要的作用:在同一个工程中允许存在相同名称的类,只要处在不同的包中即可


    1.3.2、导入包中的类

    举例说明:数组当中说过的Arrays,在使用的时候要导包 import java.util.Arrays;用import关键字将某个类(Arrays)的路径导入当前类中。

    Java 中已经提供了很多现成的类供我们使用. 例如Date类:可以使用 java.util.Date 导入 java.util 这个包中的 Date类.

    1. public class Test {
    2.   public static void main(String[] args) {
    3.     java.util.Date date = new java.util.Date();
    4.     //可以看见这种写法有些冗余
    5.     System.out.println(date);
    6.  }
    7. }

    更简洁的写法:使用import语句导入包

    1. import java.util.Date;
    2. public class Test {
    3.    public static void main(String[] args) {
    4.      Date date = new Date();
    5.          System.out.println(date);
    6.   }
    7. }

    当然我们要使用一个包(java.util)当中的其他类,可以使用 import java.util.*

    1. import java.util.*;//这里表示的是通配符
    2. public class Test {
    3.    public static void main(String[] args) {
    4.      Date date = new Date();
    5.      System.out.println(date);
    6.   }
    7. }

     这样写虽然可以导入一个包当中的任意类,就是我们使用那个类,它默认就导入那个类,但是他和C语言当中的#include不相同,在C语言当中通过#include将所有的代码都到导进来,但是在Java当中,他并不会直接将一个包当中所有的类都导入,只会将需要的类导入,随用随取,用到那个类就导哪个类。

    但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.

     这时候就需要这样改

     总结:

    • 当用到一个包当中的多个类,可以使用  .*来使用一个包当中的多个类
    • 当两个包当中有相同的类名,就要使用完整的写法。例如import java.util.Date和import java.sql.Date
    • import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要。
    • import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using

     1.3.3、自定义包

    基本规则

    • 在文件的最上方加上一个 package 语句指定该代码在哪个包中.
    • 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).
    • 包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.
    • 如果一个类没有 package 语句, 则该类被放到一个默认包中.

    操作步骤 

    1、在IDEA中先新建一个包:右键 src -> 新建 ->包

     2、在弹出的对话框中输入包名,例如com.baidu.www

    3、生成一个Java文件 

    4、此时可以看到我们的磁盘上的目录结构已经被IDEA自动创建出来了

     并且我们也会看见 Test.java,在文件的最上面出现了一个package 语句


    1.3.4、常见的包

    1、java.long:系统常用基础类(String、Object),此包从JDK1.1后自动导入。

    2、java.lang.reflect:java 反射编程包;

    3、java.net:进行网络编程开发包。

    4、java.sql:进行数据库开发的支持包。

    5、java.util:是java提供的工具程序包。(集合类等)非常重要

    6、java.io:I/O编程开发包。


    1.4、封装的应用

    看代码

    问题: 当属性和方法都被private修饰后,怎样在同一个包低下的另一个类当中使用。

    解决方法一:想要在Test类当中使用属性name和方法eat,可以使用构造方法来解决这一问题 

     

    这里提一个小知识点,在使用构造方法时,当有多个属性的时候,我们需要多个创建构造方法时可以通过这个方法类创建

    1、第一步

    2、第二步

    3、第三步

      虽然通过构造方法可以对属性赋值,但是使用构造方法解决这个问题有局限性,只能使用一次,随着程序的运行当我们需要修改属性的值,不可能再创建一个对象,这里我们应该怎样做?

    解决方法二:可以通过公开的接口来解决。

    就上述代码而言:name和age被private修饰,通过公开的方法来对name和age进行修改。

    这里通过getName和setName来实现对封装的name进行交互。 

    当然在有多个属性的情况下,每个属性都需要自己写get和set吗?当然不需要这里来说一个idea提供的一个简便方法

    1、第一步

    2、第二步

    3、第三步

     这样就自动生成了公开的接口


    2、static成员

    2.1、再谈成员变量

    创建一个学生类

     

    从上述代码调试中可以看到,三个学生对象的教室都一样,这个教室的属性并不需要每个学生对象中都存储一份,而是要让所有的学生来共享。这个时候就可以使用static这个关键字。


    2.2、static修饰成员变量

    static修饰的成员变量,称为静态成员变量静态成员变量最大的特性:不属于某个具体对象,是所有对象所共享的。

    【静态成员变量属性】

    1. 不属于某个具体的对象,是类的属性,所有对象共享的,不存储在某个对象的空间中
    2. 既可以通过对象访问,也可以通过类名访问,但一般更推荐使用类名访问
    3. 类变量存储在方法区当中(静态成员变量也被称为类变量类成员
    4. 生命周期伴随类的一生(即:随类的加载而创建,随类的卸载而销毁)

     从这里可以看出被static修饰的成员变量是静态成员变量,不属于某个对象,是所有对象共享的。

    那我们该如何访问这个静态成员变量呢?

    先用对象的引用来试一试

     这样访问也可以,编译器不会报错,但是会报警告。

     更标准的写法就是用类名访问

     

    这里有一个问题?

    一般类中的数据成员都设置为private,而成员方法设置为public,那设置之后,Student类中classRoom属性如何在类外访问呢?

    我们可以通过创建接口来实现修改值和返回值

     Java当中,被static修饰的成员方法称为静态成员方法,是类的方法,不是某个对象所特有。静态成员一般是通过静态方法来访问的。


    2.3、static修饰成员方法

    【静态方法特性】

    1、不属于某个具体的对象,是类方法

    2、可以通过对象的引用调用,也可以通过类名.静态方法的方式调用,更推荐后者。

    3、静态方法中不能调用任何非静态方法,因为非静态方法有this参数,在静态方法中调用的时候无法传递this引用

    静态方法中调用静态方法

     静态方法中调用非静态方法

    4、不能在静态方法中直接访问任何非静态成员变量

     如果非要使用,则需要使用实例化一个对象(非静态成员变量和方法想要在静态方法中使用,需要实例化一个对象)

    普通方法内部中可以直接使用静态成员方法

    总结:

    我们建议:获取静态的成员变量或者是设置静态成员变量,此时的方法最好是静态的,若方                    法是非静态的,还得要实例化对象。


    2.4、static成员变量初始化

    对于静态成员变量的初始化:

    1、直接赋值

    2、默认初始化

    3、可以通过提供get和set方法来进行初始化

    4、在构造对象的时候,可以在构造方法中经行赋值 (这样写可以实现目的,但是不建议)

    5、 通过静态代块来进行赋值

    那什么是代码块那?继续向下看:)


    3、代码块

    3.1、代码块概念以及分类

    使用{}定义的一段代码称为代码块,更具代码块顶柜的位置以及关键字,又可以分为以下四种:

    • 普通代码块
    • 构造块--->非静态代码块/实例代码块
    • 静态块
    • 同步代码块(后续讲解多线程部分再谈)

    3.2、普通代码块

    普通代码块:定义在方法中的代码块

     普通代码块的作用(用的不多)

    3.4、构造代码块

     构造块:定义在类中的代码块(不加修饰符)也叫:实例代码块、构造代码块一般用于初始化实例成员变量。

    1、代码中的执行顺序:

    2、初始化成员变量

    第一种情况:带有参数的构造方法和构造代码块之间执行的先后顺序

    第二种情况:不带参数的构造方法和构造代码块之间执行的先后顺序

     

    第三种情况:非静态代码块和非静态成员之间执行的先后顺序

    总结:

    实例代码块在实际应用中不是很多,实际在写代码的时候就通过实例化对象的时候进行赋值就行。


     3.5、静态代码块

    使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量

     

     静态的方法和成员变量是不依赖于对象的,所以代码可以这样写。

     当生成多个对象的时候,静态的代码块被执行几次?

     总结:

    静态代码块的注意事项:

    • 静态代码块不管生成多少个对象,其只会被执行一次
    • 静态成员变量是类的属性,因此是在JVM加载类时开辟空间并初始化的
    • 如果一个类中包含多个静态代码块,在编译时,编译器会按照定义的先后次序依次执行(合并)
    • 实例代码块只有在创建对象的时候才会执行 

    4、对象的打印 

    这样写是一个常见的写法,利用自己写的show方法打印

    1. class Person {
    2. private String name;
    3. private int age;
    4. public Person(String name, int age) {
    5. this.name = name;
    6. this.age = age;
    7. }
    8. public String getName() {
    9. return name;
    10. }
    11. public void setName(String name) {
    12. this.name = name;
    13. }
    14. public void show() {
    15. System.out.println(name+" "+age);
    16. }
    17. }
    18. public class Test2 {
    19. public static void main(String[] args) {
    20. Person person = new Person("zhangsan",10);
    21. person.setName("lisi");
    22. System.out.println(person.getName());
    23. person.show();
    24. }
    25. }

    但是如不用show方法打印,来看一下代码

    1. class Person {
    2. private String name;
    3. private int age;
    4. public Person(String name, int age) {
    5. this.name = name;
    6. this.age = age;
    7. }
    8. public String getName() {
    9. return name;
    10. }
    11. public void setName(String name) {
    12. this.name = name;
    13. }
    14. public void show() {
    15. System.out.println(name+" "+age);
    16. }
    17. }
    18. public class Test2 {
    19. public static void main(String[] args) {
    20. Person person = new Person("zhangsan",10);
    21. System.out.println(person);
    22. //打印的结果是person引用的值,这个值指向的结果是zhangsan 10
    23. }
    24. }

    这里来了解一下输出的结果 

     println函数调用方法的底层是toString方法

     我们可以自己写一个toString方法,来将name和age的结果打印出来

    1. class Person {
    2. private String name;
    3. private int age;
    4. public Person(String name, int age) {
    5. this.name = name;
    6. this.age = age;
    7. }
    8. public String getName() {
    9. return name;
    10. }
    11. public void setName(String name) {
    12. this.name = name;
    13. }
    14. public void show() {
    15. System.out.println(name+" "+age);
    16. }
    17. //自己写一个toString方法
    18. @Override//这个是注解
    19. public String toString() {
    20. return "Person{" +
    21. "name='" + name + '\'' +
    22. ", age=" + age +
    23. '}';
    24. }
    25. }
    26. public class Test2 {
    27. public static void main(String[] args) {
    28. Person person = new Person("zhangsan",10);
    29. System.out.println(person);
    30. }
    31. }

     总结:

    对于你想输出一个对象的引用的值的时候,如果你没有自己写一个toString方法,那么就会调用Object这个类的方法。

    如果自己写了,就会调用自己的!!!


    5、作业练习 

    1、如下代码的输出结果是什么?(D)

    1. public class Test {
    2. public int aMethod(){
    3. static int i = 0;
    4. i++;
    5. return i;
    6. }
    7. public static void main(String args[]){
    8. Test test = new Test();
    9. test.aMethod();
    10. int j = test.aMethod();
    11. System.out.println(j);
    12. }
    13. }

    选项:

    A.0       B.1     C.2       D.编译失败   

    答案解析:

    在方法当中定义的变量是局部变量,而静态的变量属于类变量。随着类的加载而被创建,而局部变量是调用该方法的时候,才创建的。

    所以,此时两种变量的性质是冲突的。Java当中不允许定义局部的静态变量


     2、当你编译和运行下面的代码时,会出现下面选项中的哪种 (B)

    1. public class Pvf{
    2. static boolean Paddy;
    3. public static void main(String args[]){
    4. System.out.println(Paddy);
    5. }
    6. }

    选项:

    A.编译时错误

    B.编译通过并输出结果false

    C.编译通过并输出结果true

    D.编译通过并输出结果null

    答案解析:

    在Java当中,成员变量没有赋初值的时候,会有默认的初始值。基本类型是对应的0值。如:int是0,boolean是false,char类型是'\u0000',引用类型是null,如String。


    3、 已知如下类说明:

    1. public class Test{
    2. private float f=1.0f;
    3. int m=12;
    4. static int n=1;
    5. public static void main(String args[]){
    6. Test t=new Test();
    7. }
    8. }

    如下那些在main函数中使用是正确的(D)

    选项:

    A.t.f = 3.0

    B.this.n

    C.Test.m

    D.Test.n

    答案解析:

    A:f是float类型,3.0默认是double,所以此时不能赋值

    B:n是静态的,需要通过类名访问,不能通过this访问,this代表当前对象的引用,但是静态的成员变量不属于this。

    C:m是实例成员变量,需要通过对象来进行调用。

    D:正确

    故:答案选D


    4、关于以下程序的说明正确的是(A)

    1. public class HasStatic {// 1
    2. private static int x = 100;// 2
    3. public static void main(String args[]) {// 3
    4. HasStatic hsl = new HasStatic();// 4
    5. hsl.x++;// 5
    6. HasStatic hs2 = new HasStatic();// 6
    7. hs2.x++;// 7
    8. hsl = new HasStatic();// 8
    9. hsl.x++;// 9
    10. HasStatic.x--;// 10
    11. System.out.println(" x=" + x);// 11
    12. }

    选项:

    A.程序通过编译,输出结果为:x=102

    B.程序通过编译,输出结果为:x=103

    C.10行不能通过编译.因为x星私有静态变量

    D.5行不能通过编译.因为引用了私有静态变量

    答案解析:

    1. 本题中的静态成员变量x,属于类变量,只有一份。所有对x的操作针对的都是同一份。
    2. 静态成员变量的访问需要通过类名访问,这是正确的访问方式。本题中虽然使用了对象引用访问,但是不会报错,我们不建议这样访问,但不是错误,所以,不会编译报错。

    综合以上2点,得出结论:本题可以正常通过编译和运行,输出结果是102


    5、

    1. public class Test{
    2. static int cnt = 6;
    3. static{
    4. cnt += 9;
    5. }
    6. public static void main(String[] args){
    7. System.out.println("cnt = " + cnt);
    8. }
    9. static{
    10. cnt /=3;
    11. };
    12. }

     cnt的值是()

    选项:

    A.cnt=5    B. cnt=2    C.cnt=3     D.cnt=6

    答案解析:

    本题考察的是代码块的执行顺序。带代码中存在代码块和构造方法的时候。执行顺序为:

    1.静态代码块

    2.实例代码块

    3.调用的对应的构造方法

    第2种情况:当存在相同类型的代码块和成员变量的时候,需要看定义顺序执行。


    6、给定以下代码:

    1. class Test{
    2. public String toString() {
    3. System.out.print("aaa");
    4. return "bbb";
    5. }
    6. }
    7. public static void main(String[] args) {
    8. Test test = new Test();
    9. System.out.println(test);
    10. }

    程序输出结果为()

    选项:

    A.aaa   B.bbb    C.aaabbb     D.bbbaaa

    答案解析:

    本题中主要考察toString 方法

    在执行println函数的时候,会调用Object类的toString方法,此时当我们自己类重新通过编译器实现了toString方法之后,会调用我们自己写的方法。此处具体的原因,我们会在继承,多态章节讲到的。大家先用起来。

    根据上面所述,调用我们自己写的toString方法后,执行输出语句,输出aaa,返回bbb交给println函数,输出bbb。

  • 相关阅读:
    设计模式之组合模式与观察者模式应用例题
    【项目管理】中途接手的项目应对实用指南
    亲测可用国产GPT人工智能
    Python中的依赖注入
    c#弹性和瞬态故障处理库Polly
    基于最小二乘支持向量机(LS-SVM)进行分类、函数估计、时间序列预测和无监督学习附Matlab代码
    数据结构错题总结(选择题+填空题)
    14设计模式-行为型模式-状态模式
    40 - 前置操作符和后置操作符
    C++中的代码重用
  • 原文地址:https://blog.csdn.net/m0_73067372/article/details/127910849