JavaSE - 封装、static修饰成员变量或成员方法

渡上舟

已于 2023-07-20 22:19:33 修改

阅读量502

点赞数 10

分类专栏： JavaSE 文章标签： java 开发语言

于 2022-08-07 21:03:57 首次发布

本文链接：https://blog.csdn.net/m0_61731585/article/details/126176156

版权

JavaSE 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1. 封装

1.1 什么是封装

1.2 访问限定符（private、default、protected、public）

3.3 成员变量有无static的赋值对比

3.3.1 给static修饰的静态成员变量进行赋值：

3.3.2 给对象中的成员变量进行赋值：

3.3.3 成员变量既有非静态的又有静态的

4. 代码块

1. 封装

面向对象程序三大特性：封装、继承、多态。

1.1 什么是封装

对类内部的实现细节进行隐藏/封装，对外只提供一些公开的接口，供其他的用户进行访问

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，而访问权限用来控制方法或者字段能否直接在类外使用

1.2 访问限定符（private、default、protected、public）

可以修饰类，成员变量，成员方法，构造方法

private：私有的 ->只能在当前类的内部进行访问【同一个包中的同一个类】

default：默认的 ->只能在【同一个包中】进行访问【什么限定符都不加，就是default权限：默认权限】

protected：受保护的【同一个包中和不同包中的子类】

public：公开的 ->不管在哪里都可以访问它

一般情况下成员变量设置为private，成员方法设置为public。

2. 包

为了更好的管理类，把多个类收集在一起成为一组，称为包

2.1 导入Java提供的现成的包中的类

可以使用 import导入一个包中具体的类，使用import static导入包中静态的方法和字段。

用到哪个类，就导入这个包中的这个类，如用到 java.util.Date这个类就导入 java.util 这个包中的 Date 类（ java.util.Date->完整的类名、Date->不完整的类名，当没有和别的包下的类名产生冲突时，可以直接使用）

如下：先进行实例化，再通过【引用点号】来访问类中的成员

但是我们会发现，有些类中成员的访问不需要实例化，直接【类名.方法名】就可以，如下：

这是为什么呢？

因为java.lang.Math和java.util.Arrays这两个类中提供了大量的静态方法，静态方法属于类，不属于某个对象，所以在调用static修饰的静态方法的时候，直接【类名.方法名】使用即可。

2.2 自定义包

通过类外的 package 语句确定该类在哪个包中

如果一个类外没有 package 语句, 则该类被放到一个默认包（src）中

src里的类可以实例化src里的其他类以及 src里的包中的类，而src里的包中的类却不能实例化src里的类。【即只能实例化同等级及以下的类。】

详解private访问限定符

2.3 常见的包

1. java.lang:系统常用基础类(String、Object)，此包不需要我们导入，编译器会自己导入

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

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

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

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

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

3. static成员

1. 在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的，属于类。类变量存储在方法区当中，只有一份。

2. .通过【类名.属性/方法】去访问，若处于同一个类下，类名可以省略

（虽然也可以通过引用来访问，语法上没错，但不要这样用）

3. 静态成员变量未初始化默认是初始值。

4. static修饰的是成员变量或成员方法，不能修饰成员方法中的局部变量。

5. static修饰的成员变量或成员方法的生命周期伴随类的一生【随着类的创建而产生，随着类的销毁而销毁】

3.1 static修饰成员变量

再谈学生类，若这些学生是同一个班的，就可以定义一个静态成员变量classes

通过【类名.成员变量】进行访问

3.2 static修饰成员方法

通过【类名.成员方法】访问

在静态的成员方法内部，不能直接访问非静态的成员变量和成员方法。

因为func是类名调用，不需要new对象，不需要对象的引用，this在静态方法中根本就不存在

反之非静态可以访问静态。

3.3 成员变量有无static的赋值对比

3.3.1 给static修饰的静态成员变量进行赋值：

1. 定义时就直接赋值

2. 在main函数中通过【类名.成员变量】进行赋值

3. 使用静态成员方法

4. 使用静态代码块

/**
 * 给static修饰的静态成员变量进行赋值
 * 1. 使用静态成员方法
 * 2. 通过静态代码块赋值
 */
public class Peo {
    private static String name;
    private static int age;
    private static String sex = "男";//就地初始化
    private static String lover;

    /**
     * 1. 使用静态成员方法
     */
    public static void setPeople1(String name,int age){
        Peo.name = name;
        Peo.age = age;
    }

    /**
     *  2. 通过静态代码块赋值
     */

    static{
        lover = "骆闻舟";
    }
    public static void printPeople1() {
        System.out.println(Peo.name+" "+Peo.age +" "+Peo.sex+" 爱人："+Peo.lover);
    }
    public static void main(String[] args) {

        Peo.setPeople1("费渡",22);
        Peo.printPeople1();

    }
}

3.3.2 给对象中的成员变量进行赋值：

1. 定义时就直接赋值

2. 在main函数中通过【引用.成员变量】进行赋值

3. 使用成员方法

4. 使用构造方法

（有参数的构造方法、调用本类当中的其他构造方法）

/**
 * 给对象中的成员变量进行赋值
 * 1. 使用成员方法(使用前一定会先调用无参构造方法)
 * 2. 使用构造方法
 * 3. 调用本类当中的其他构造方法
 *
 * 对比后发现，构造方法更好用
 */
public class People {
    private String name;
    private int age;
    private String sex = "男";//就地初始化
    private String lover;

    /**
     * 1. 使用成员方法
     */
    public void setPeople1(String name,int age,String lover){
        this.name = name;
        this.age = age;
        this.lover = lover;
    }
    public void printPeople1() {
        System.out.println(this.age+"岁的"+this.name+"救赎了他的宝贝"+this.lover);
    }

    /**
     *  2. 使用构造方法
     */
    public People(String name,int age,String lover){
        this.name = name;
        this.age = age;
        this.lover = lover;
    }
    public void printPeople2(){
        System.out.println(this.age+"岁的"+this.name+"爱上了只属于他的"+this.lover);
    }

    /**
     *  3. 调用本类当中的其他构造方法进行初始化
     */
    public People(){
        this("陶然",29,"常宁");//this();调用本类中的其他构造方法
    }
    public void printPeople3(){
        System.out.println(this.age+"岁的"+this.name+"追上了它的女神"+this.lover);
    }

    public static void main(String[] args) {
        People people1 = new People();//调用无参构造方法
        people1.setPeople1("骆闻舟",29,"费渡");//重新初始化
        People people2 = new People("费渡",22,"骆闻舟");调用有2个参数的构造方法
        People people3 = new People();//调用无参构造方法

        people1.printPeople1();
        people2.printPeople2();
        people3.printPeople3();
    }
}

3.3.3 成员变量既有非静态的又有静态的

public class Character {
    private String name;
    private String lover;
    private static String novel;

    static{
        novel = "默读";
    }
    public Character(String name,String lover){
        this.name = name;
        this.lover = lover;
    }
    public void printCharacter() {
        System.out.println(" "+Character.novel+":"+this.name+"和"+this.lover+"的相遇相知相爱，是梦开始的地方");
    }

    public static void main(String[] args) {
        Character character = new Character("费渡","骆闻舟");
        character.printCharacter();
    }
}

4. 代码块

普通代码块、静态代码块、实例代码块（也叫构造块）、同步代码块。

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

2. 实例代码块，也叫作构造块，一般用于初始化非静态的成员变量。

3. 静态代码块在类加载的时候就被执行了，它不依赖于对象，且只会执行一次

4. 实例代码块和无参数的构造方法只有在创建对象时才会执行，且创建几个对象执行几次

5. 执行顺序：先静态代码块，再实例代码块，再无参数的构造方法（main方法执行前会先运行完静态代码块和实例代码块

6. 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行

public class Stu {
    public String name;
    public int age;
    public String sex;
    public static String classes = "106Java1班";//静态成员变量

    {
        //实例代码块一般用于初始化非静态的成员变量。
        sex = "男";
        System.out.println("这是实例代码块！");
    }
    static{
        //静态代码块，一般用于初始化静态成员变量。
        classes = "106Java2班";//虽然classes已经被赋值成106Java1班，但要按顺序，最终输出106Java2班
        //类加载的时候 就被执行了，且只执行一次
        System.out.println("这是静态代码块！");
    }
    public Stu(){
        System.out.println("这是无参构造方法！");
    }

    public void setStu(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void printStu(){

        System.out.println(this.name+" "+this.age+" "+sex+" "+Stu.classes);
    }

    public static void main(String[] args) {
        Stu stu = new Stu();
        stu.setStu("zhangsan",18);
        stu.printStu();

        Stu stu2 = new Stu();
        stu2.setStu("lisi",19);
        stu2.printStu();


    }
}