Java--面向对象之封装篇!!!

目录

1. 封装
2. static关键字
3. 代码块

引用

我们学习面向对象的语言时，应该都了解它有三大特性。

面向对象的三大特性：封装、继承和多态。这篇博客主要介绍的就是封装。

1.封装

1.1什么是封装

封装就像是把东西放在⼀个盒子里，并且控制谁可以打开这个盒子，以及如何使用盒子里的东西。在编程中，它指的是将数据（属性）和操作这些数据的方法（函数）包装在⼀个单元（通常是类）内。仅对外公开一些接口来和对象进行交互。

1.2为什么要封装

1.降低耦合性

封装可以降低对象和对象之间的耦合度，当对象内部发生变化时，只需要修改对象内部即可，不会影响到外部程序，因为公开的接口是不会发生改变的。

2.降低复杂性

封装隐藏对象内部的细节，只对外公开接口给外部，使用起来更便捷。

3.提高安全性

同理封装隐藏了对象内部细节，阻止外部程序直接访问对象的内部状态，从而保护数据不被意外修改或破坏。

1.3如何封装

封装采用访问限定符：

使用范围如下：

• private修饰的成员变量只能在同一类中使用
• default表示什么修饰符都不加，只能在同一包中访问
• protected修饰的方法可以在同一包中访问，如果想要在不同包中访问，只能是继承关系下的子类才能访问。
• public表示所有范围都能使用

2.static关键字

static关键字可以修饰成员变量和成员方法。

2.1static修饰成员变量

被static修饰的成员变量称为静态成员变量，该变量不在独属于某一对象，而是属于类，是类变量，所有对象共享该类变量。存在于方法区中。

首先，我们定义两个变量，一个成员变量author,一个被static修饰的静态成员变量name。然后我们在main方法中创建两个对象，分别用变量test1和test2引用两对象。最后打印两个对象。

代码如下：

public class Test {

    private String author;
    private static String name;

    public Test(String author) {
        this.author = author;
    }

    @Override
    public String toString() {
        return "Test{" +
                "author='" + author + '\'' +
                "name='" + name + '\''+
                '}';
    }

    public static void main(String[] args) {
        Test test1 = new Test("lishi");
        Test test2 = new Test("wangwu");
        Test.name = "zhangsan";//不依赖于对象的引用，通过类名直接访问
        System.out.println(test1);
        System.out.println(test2);
    }
}

运行结果：证明了所有对象共享类变量

思维导图：不同对象是如何调用静态变量

类型的变量创建在栈上，对象创建在堆上，而静态变量存放在方法区

2.2静态成员变量的特性

• 不属于具体的某一个对象，所有对象共享
• 不依赖于对象，通过类名进行访问
• 存储在方法区中
• 生命周期伴随类的加载而创建，类的卸载而销毁

我们演示下最后一个特性：首先我们给静态成员变量name就地初始化"七七",没有创建任何对象，直接通过类名进行访问，然打印出来。

代码如下：

public class Test {

    private String author;
    private static String name = "qiqi";
    
    public static void main(String[] args) {
        System.out.println(Test.name);
    }
}

运行结果：

2.3static修饰成员方法

同理被static修饰的成员方法称为静态成员方法，是类方法，它不再具体属于某一个对象。

2.4静态成员方法的特性

• 是类方法，不单独属于某一对象
• 通过类名所调用
• 在静态成员方法中不能访问任何非静态成员变量
• 在静态方法中不能调用任何非静态方法，因为非静态方法中有this参数（通过this引用非静态成员变量），在静态方法中调用时无法传递this引用（静态方法不能访问任何非静态成员变量）
• 同理在静态方法中不能使用super引用。

public class Test {

    private String author;
    private static String name = "qiqi";

    public Test(String author) {
        this.author = author;
    }

    @Override
    public String toString() {
        return "Test{" +
                "author='" + author + '\'' +
                "name='" + name + '\''+
                '}';
    }

    public void testStatic1(){

    }

    public static void testStatic2(){

    }

    public static void func(){
        //author = "zhangsan" //编译失败：Error:(31, 48) java: ⽆法从静态上下⽂中引⽤⾮静态 变量 author
        //this.author = "zhangsan";//依赖于对象的引用
        name = "xixi";
        Test.name = "xixi";//不依赖于对象的引用，通过类名直接访问

        //testStatic1(); //编译报错：Error:(36, 41) java: ⽆法从静态上下⽂中引⽤⾮静态 ⽅法 doClass()
        testStatic2();
    }
}

2.5static修饰的成员变量初始化

有两种初始化方法，一种是就地初始化，一种是在静态代码块初始化。就地初始化就是定义时直接给出初始值

public class Test {

    private static String name = "qiqi";
}

那什么是静态代码块呢？

3.代码块

分为静态代码块，实例代码块，构造代码块和普通代码块。

3.1静态代码块

被static修饰的代码块就是静态代码块，⼀般⽤于初始化静态成员变量。

public class Test {

    private static String name;
    //静态代码块
    static {
        name = "xixi";
    }
}

3.2实例代码块

不加修饰符的代码块就是实例代码块，⼀般⽤于初始化实例成员

变量。

public class Test {

    //实例化成员变量
    private String author;
    private int age;
    private double price;
    //静态成员变量
    private static String name;
    private static String classname;
    private static int id;

    //实例化代码块
    {
        author = "gugu";
        age = 18;
        price = 23.6;
    }
}

3.3构造代码块

在构造方法内的代码块称为构造代码块

public class Test {

    private String author;
    //构造代码块
    public Test(String author) {
        this.author = author;
    }
}

3.4普通代码块

定义在方法中的代码块

public class Main{
	public static void main(String[] args) {
	{ //直接使⽤{}定义，普通⽅法块
		int x = 10 ;
		System.out.println("x1 = " +x);
	}
}