Java的类与对象.封装（进阶版——建议收藏）

Java的类与对象.封装（进阶版——建议收藏）

为什么叫做进阶版呢？
因为我们已经讲过一期类与对象了，如果你还没有看，恰好你对类与对象又不是很懂，建议你先去看一下再过来！

传送门—> Java的类与对象——你真的懂了吗？.

上一期我们主要讲了类与对象的一些关系以及组成，这一期我们来讲创建类涉及到的一些关键字，涉及到封装的部分重点，接下来正文开始

目录

• staic关键字
• • 1.修饰变量
  • 2.修饰方法
  • 3.定义mian时为什么要使用static？
• this 关键字
• • 1.this.变量名
  • 2.this.方法
  • 3.this()访问构造方法
• 访问控制修饰符
• • 1. private
  • 2. friendly（默认）
  • 3. protected
  • 4. public
• 结言

staic关键字

static的汉语意思是静态的，它在Java中的作用也是差不多的。

其实static主要是帮助程序员来管理内存的，static关键字可以使用在变量，方法，块中。

接下来你要记住这么一句话： static关键字属于类，而不是类的实例

带着搞清楚这句话的目的去阅读下面的文章，你将会事半功倍！

1.修饰变量

static修饰变量只需要把static加在该变量类型前面就行了如下：
y哦那个是

static int a=10;

变量被static修饰后变量有什么变化呢？

变量被static修饰后该变量属于它所在的类，被实例化产生对象时该变量还是属于类，不属于对象。

1.当在其它类里面需要调用被static修饰的变量时只需要直接使用类名来调用，不需要实例化用对象来调用，如下：

class Baibai{
    int a=5;
    static String s="hello,baibai!";
}

public class Text_0 {
    public static void main(String[] args){
//      报错：java: 无法从静态上下文中引用非静态 变量 a
//      System.out.println(Baibai.a);#因为变量a是非静态的
        System.out.println(Baibai.s);
    }
}

运行结果为：
hello,baibai!

如果我们创建对象来引用静态变量，也是可以实现的但是会有警告，所以不要使用对象来引用静态变量

2.对静态变量进行更改时，它的值就真正的发生了变化（因为它属于类，只有一个它）；而其他普通变量属于对象，对它的量改变时只改变了它所对应对象的它的量（注意：不要被绕进去，仔细理一理）如下：

class Baibai{
    int a=5;
    static String s="hello,baibai!";
}

public class Text_0 {
    public static void main(String[] args){

        Baibai B = new Baibai();
        System.out.println(B.a);
//B.s会出现警告，这里单纯为了测试使用，平时千万不要用对象来引用静态变量
        System.out.println(B.s);
        System.out.println(Baibai.s);
        B.a=10;
        B.s="123";
        Baibai B1 = new Baibai();
        System.out.println(B1.a);
        System.out.println(B1.s);
        System.out.println(Baibai.s);
    }
}

运行结果为：
5
hello,baibai!
hello,baibai!
5
123
123

大家注意理解记忆

2.修饰方法

static修饰方法其实和修饰变量是类似的，有以下特点

静态方法属于类，而不属于类所实例化的对象
调用静态方法时，无需创建对象
静态方法只能访问静态数据成员，并且可以更改静态数据成员的值

废话不多说，直接上代码

class Baibai{
    int a=5;
    static String s="hello,baibai!";
    public static void Bai(){
//      System.out.println(a);#报错：无法从静态上下文中引用非静态 变量 a
        s="123";
        System.out.println(s);
    }
    public void Aai(){
        s="888";
        System.out.println(s);
    }
}

public class Text_0 {
    public static void main(String[] args){
        System.out.println(Baibai.s);
        Baibai.Bai();
//        Baibai.Aai();#报错：无法从静态上下文中引用非静态 方法 Aai()
        Baibai B = new Baibai();
        B.Aai();
    }
}

运行结果为：
hello,baibai!
123
888

通过上面我们可以知道：

静态方法只可以访问静态变量， 不需要创建对象
普通方法可以访问普通的变量，也可以访问修改静态变量，不过需要创建对象

3.定义mian时为什么要使用static？

如果我们不加static，它能运行吗？

public class Text_0 {
    public  void main(String[] args){
        System.out.println(10);
    }
}

经过试验后得到答案是：不能

如果要使用非静态方法那我们就需要，创建对象来使用，而创建对象的地方又在main（）内部，这属实是在套娃哇！

不能再绕了，再绕脑袋直接短路了。

至于main()为什么必须要static来修饰呢？

因为静态方法不需要类进行实例化

staic还能修饰块，这里就不细说了，等到块的时候一起讲

this 关键字

this 关键字是 很常见的关键字之一，它可用于任何实例方法内指向当前对象，也可指向对其调用当前方法的对象，或者在需要当前类型对象引用时使用。

上面的如果不太懂，那你记住this代表当前对象就行；

1.this.变量名

如果类的某一变量被private修饰就代表了，这个变量不能被其他类所访问了，但是只要我们创建一个方法，在这个方法里面进行修改，我们就可以对它进行访问

class Baibai{
    private String s1 = "私有变量";
    public void text(String s){
        this.s1 = s;
        System.out.println(s1);
    }
}

public class Text_0 {
    public static void main(String[] args) {
        Baibai B = new Baibai();
        B.text("1234");
    }
}

输出为：
1234

这里的this代表当前对象，也就是这里的B，他代表 B的访问这个私有的变量，这里其实就体现出来的Java的封装思想。

注意：这里的this是可以省略掉的，

//this.s1 = s;
s1=s;

你可以不写这个this. 但是你必须知道这个s1是属于当前对象的，并不是属于类

2.this.方法

方法其实和变量是同一个道理，我们之前学过想要调用一个类的方法就需要来对这个类进行实例化，然后用对象来调用

那我们在这个类的某一个方法中调用这个类的其他方法，是不是也要通过创建对象来时间呢？
我们所知道的是“调用一个类的方法就需要来对这个类进行实例化，然后用对象来调用”这句话没有错，说明的确需要对象来引用某类的方法，来具体看看
代码如下：

class Baibai{
    public void text(){
       System.out.println("text方法");
    }
    public void bai(){
        Baibai A = new Baibai();
        A.text();
        System.out.println("baibai!");
    }
}

public class Text_0 {
    public static void main(String[] args) {
        Baibai B = new Baibai();
        B.bai();
    }
}

输出为：
text方法
baibai!

看来这样是对的，但是我们访问同一个类，确对该类例化了两遍，这不太好，就像你需要使用微信和QQ两个App，你需要为了这两个App来各准备一个手机吗？肯定不需要哇，没十年脑血栓都干不出这种事。

那我们如何来解决呢？

当然是用this啊！因为我现在就在讲this啊（手动狗头）
上代码：

class Baibai{
    public void text(){
       System.out.println("text方法");
    }
    public void bai(){
        this.text();
        System.out.println("baibai!");
    }
}

public class Text_0 {
    public static void main(String[] args) {
        Baibai B = new Baibai();
        B.bai();
    }
}

这样就好了，既符合生活逻辑，又符合代码原则；

同样的这里的this也可以省略

//this.text();
 text();

但是你也要知道这个方法属于当前对象，而不是类。

3.this()访问构造方法

首先你得知道：

this()方法只能在构建方法中使用，不能在普通方法中使用
在构造方法中使用时，必须在第一行使用
this( )用来访问本类的构造方法，括号中可以有参数，如果有参数就是调用指定的有参构造方法，

如下：

class Baibai{
    public  Baibai(){
        this(2);
        System.out.println("构造方法");
    }
    public Baibai(int a){
        System.out.println("构造方法——"+a);
    }
}

public class Text_0 {
    public static void main(String[] args) {
        Baibai B = new Baibai();
    }
}

输出为：
构造方法——2
构造方法

如果在构造方法中调用自己，那就属于是递归构造器了，这里不展开！

访问控制修饰符

首先我们得知道为什么要控制访问呢？

疫情期间，假如你要返校，你就得拿着24小时内的核酸报告来，学校审核通过之后才会让你进来。如果疫情期间，学校能随便出入，那万一有一个感染者进来岂不是麻烦大了

在程序中道理也是这样的，如果没有访问控制，写出来的东西复杂不复杂暂且不说。那我们什么都能访问了，万一不小心把父类方法里面的源码改掉，一切岂不是乱套了，整个语言被破坏了…所以我们写程序需要用到封装，它保证了程序的自身的稳定性

类的访问控制符只能是空（friendly）或者 public，方法和属性的访问控制符有 4 个，分别是 public、 private、protected 和friendly，其中 friendly 是一种没有定义专门的访问控制符的默认情况。

1. private

用 private 修饰的类成员，只能被该类自身的方法访问和修改，而不能被任何其他类（包括该类的子类）访问和引用。因此，private修饰符具有最高的保护级别。

class Baibai{
    private int a =5;
    private void text(){
       System.out.println("私有方法");
    }
    public void bai(){
     text();
     a=10;
     System.out.println(a);
    }
}

public class Text_0 {
    public static void main(String[] args) {
        Baibai B = new Baibai();
        B.bai();
    }
}

就像这里对象 B 无法直接访问a与text()方法，但是我们可以通过留出来的bai()方法来访问，这完美的诠释了什么叫封装！！注意理解

2. friendly（默认）

如果一个类没有访问控制符，说明它具有默认的访问控制特性。这种默认的访问控制权规定，该类只能被同一个包中的类访问，而不能被其他包中的类使用。这种访问特性又称为包访问性（包内）。

同样的，类内的成员如果没有访问控制符，也说明它们具有包访问性。定义在同一个文件夹中的所有类属于一个包，所以前面的程序要把用户自定义的类放在同一个文件夹中（Java项目默认的包），以便不加修饰符也能运行。

3. protected

用保护访问控制符 protected 修饰的类成员可以被三种类所访问：该类自身、与它在同一个包中的其他类以及在其他包中的该类的子类。就看到这里其实它与friendly是一样的，但其实并不一样
使用protected 修饰符的主要作用，是允许其他包中它的子类来访问父类的特定属性和方法

4. public

当一个类被声明为 public 时，它就具有了被其他包中的类访问的可能性，只要包中的其他类在程序中使用 import 语句引入 public 类，就可以访问和引用这个类

结言

看完上面其实我们就可以想到，我们常用的println();其实也是如此，接下来给大家看个好玩的

Ps：我写java用的是IDEA，首先这个很好用，其次大学生可以申请学生认证来免费试用正版，还有自带的正版汉化包可以用，有一说一真的香

我们在IDEA中随便打开一个Java程序按住Ctrl然后点一下println
然后大家就会发现，我们的printin其实是这样的

大家可以发现为什么它会自动换行了，在按住Ctrl然后点一下print

你会发现这里又使用了write的方法，还可以一直点下去，最后你会发现，我们使用的方法，是好多原始方法封装，继承过来的，如果没有访问权限那就会很难做到这么有规律！！

个人理解，多谢指教！