Java —— 类和对象（二）：封装与内部类

神的宠儿yu

已于 2024-09-21 14:30:41 修改

阅读量180

点赞数 1

分类专栏： JavaSE 文章标签： java 开发语言青少年编程

于 2023-11-09 21:12:22 首次发布

本文链接：https://blog.csdn.net/YeZh1Yong_Cr/article/details/134319959

版权

JavaSE 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1. 封装

1.1 封装的概念

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

我们从另一个角度去看封装:
比如我们的电脑或者手机, 我们看到的是一个包装的非常精致的东西, 里面的各种核心(线路板, CPU等)是看不到的, 这就是一个简单的封装.
对于电脑这样一个复杂的设备, 提供给用户的是开关机, 键盘输入, 显示器, USB插孔等功能让用户和计算机进行交互, 但是我们看不到它的内部核心硬件, 就是说它把一些东西给封装起来了, 然后提供一些公开的功能.

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

初步的认识Java代码中的封装:
对类内部的实现细节进行隐藏/封装;
对外只提供一些公开的接口供其他的用户进行访问.

1.2 访问限定符

要实现封装, 就要修改一些数据的权限, 这些权限就由访问修饰限定符来进行修改.

Java中提供了四种访问限定符: private, default, protected, public.

要了解封装需要先行了解访问限定符, 但是我们先通过以下例子来感受一下, 如果没有封装会出现什么问题.

public是公开的, 所有人都能去使用它, 既然使用了就要想到会有这样的问题, 所以封装就是为了解决这种问题.

接下来我们来看一下这些访问限定符.

private私有的(只能在当前类的内部进行访问), default默认的 , protected受保护的, public公开的(不管在哪都可以访问)

class Person {  // 可以定义一个 Person
    // 对类内部细节进行隐藏
    private String name;
    private int age;
    String sex; // 默认是default权限

    // 对类外提供公开接口: setName
    public void setName(String name) {
        this.name = name;
    }

    public String setName() {
        return this.name;
    }

    // 成员方法
    public void show() {
        System.out.println("姓名：" + name + " 年龄: " + age);
    }

    // 编译器可以自动生成getter和setter
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Test2 {
    public static void main(String[] args) {
        Person person = new Person();
        //person.name = "zhangsan";
        person.setName("zhangsan");
        System.out.println(person.getName());
    }
}

No	范围	private	default	protected	public
1	同一包中的同一类	√	√	√	√
2	同一包中的不同类		√	√	√
3	不同包中的子类			√	√
4	不同包中的非子类				√

比如：

public：可以理解为一个人的外貌特征，谁都可以看得到

default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了

private：只有自己知道，其他人都不知道

【说明】

protected主要是用在继承中，继承部分详细介绍
default权限指：什么都不写时的默认权限
访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

2. static成员

2.1 再谈学生类

    public void print() {
        System.out.println(this.name + " => " + this.age + "->" + classes);
    }

    public static void main(String[] args) {
        Student s1 = new Student("Li leilei", 18);
        Student s2 = new Student("Han MeiMei", 19);
        Student s3 = new Student("Jim", 18);

        s1.print();
        s2.print();
        s3.print();
    }

2.2 静态成员的访问

// 在类外对classes赋值
Student.classes = "Java1111";

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

【静态成员变量特性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2. 既可以通过对象访问，也可以通过类名.访问，但一般更推荐使用类名访问

3. 类变量存储在方法区当中

4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

    public void print() {
//        System.out.println(this.name + " => " + this.age + "->" + classes);
        System.out.println(this.name + " => " + this.age + "->" + this.classes);
        // this.时编译器没有提示classes选项, 但写了并不报错(一般不用这种写法)
    }

    // 静态成员方法
    public static void func(){
        // 静态方法中不能调用this
        // this.print();   // err
    }

    public static void main(String[] args) {
        Student.classes = "Java1111";   // 没有new对象也可以访问classes, 并且不管new了多少对象, 它只有一份

        Student student1 = new Student("Li leilei", 18);
        student1.classes = "hello"; // student1.时编译器没有提示classes选项, 但写了并不报错(一般不用这种写法)
        student1.print();   // 不加static必须通过对象的引用来访问

        Student.func();

    }

Java认为这种写法语法上是正确的, 但是classes是静态的, 并不在对象中, 所以一般不写这种代码出来.

一般情况下不去通过this或者对象的引用去访问, 而是通过类名来访问. (静态方法同理)

在静态方法内部, 不能直接访问非静态的数据成员和成员方法.

Java中， 被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。
【静态方法特性】
1. 不属于某个具体的对象，是类方法
2. 可以通过对象 调用，也可以通过类名.静态方法名(...) 方式调用，更推荐使用后者
3. 不能在静态方法中访问任何非静态成员变量
4. 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用
5. 静态方法无法重写，不能用来实现多态.

2.3 static成员变量初始化

注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性

静态成员变量的初始化分为两种：就地初始化和静态代码块初始化。

1. 就地初始化

就地初始化指的是：在定义时直接给出初始值

public class Student{
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom = "Java1111";
    // ...
}

2. 静态代码块初始化

3. 代码块

3.1 代码块概念以及分类

使用{}定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块
构造块
静态块
同步代码块（后续讲解多线程部分再谈）

3.2 普通代码块

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

这种用法较少见

3.3 构造代码块

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

public class Student{

    //实例成员变量
    private String name;
    private String gender;
    private int age;
    private double score;
    public Student() {
        System.out.println("I am Student init()!");
    }

    //实例代码块
    {
        this.name = "Java";
        this.age = 66;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }

    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}

public class Main {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.show();
    }
}

3.4 静态代码块

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

public class Student{
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom;

    //实例代码块
    {
        this.name = "Java";
        this.age = 66;
        this.gender = "man";
        System.out.println("I am instance init()!");
    }

    // 静态代码块
    static {
        classRoom = "Java1111";
        System.out.println("I am static init()!");
    }

    public Student(){
        System.out.println("I am Student init()!");
    }

    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
    }
}

注意事项

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

4. 内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

// OutClass是外部类
public class OutClass {
    // InnerClass是内部类
    class InnerClass{

    }
}

【注意事项】

1. 定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类

public class A{

}

class B{

}
// A 和 B是两个独立的类，彼此之前没有关系

2. 内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

4.1 内部类的分类

先来看下，内部类都可以在一个类的哪些位置进行定义

public class OutClass {
    // 成员位置定义：未被static修饰 --->实例内部类
    public class InnerClass1{

    }

    // 成员位置定义：被static修饰 ---> 静态内部类
    static class InnerClass2{

    }

    public void method(){
        // 方法中也可以定义内部类 ---> 局部内部类：几乎不用
        class InnerClass5{

        }
    }
}

根据内部类定义的位置不同，一般可以分为以下几种形式：

1. 成员内部类(普通内部类：未被static修饰的成员内部类和静态内部类：被static修饰的成员内部类)

2. 局部内部类(不谈修饰符)、匿名内部类

注意：内部类其实日常开发中使用并不是非常多，大家在看一些库中的代码时候可能会遇到的比较多，日常开始中使用最多的是匿名内部类。

4.2 内部类

在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为成员内部类。

4.2.1 实例内部类

即未被static修饰的成员内部类。

class OuterClass {
    private int data1 = 1 ;
    int data2 = 2;
    public static int data3 = 3;

    public void test() {
        //static final int c = 0;
        System.out.println("OuterClass::test()");
        InnerClass innerClass = new InnerClass();
        innerClass.func();
    }

    /**
     *  实例内部类
     *  1. 如何获取 实例内部类的对象
     *          OuterClass.InnerClass innerClass = outerClass.new InnerClass();
     *  2. 实例内部类当中 不能有静态的成员变量. 非要定义，那么只能是被static final修饰的 
     *  3. 在实例内部类当中，如何访问外部类当中，相同的成员变量？
     *          在实例内部类当中 获取外部类的this： OuterClass.this.data1
     */

     class InnerClass {
        public int data1 = 111;
        public int data4 = 4;
        int data5 = 5;
        //public static int data6 = 6; //报错

        public void func() {
            System.out.println("InnerClass::func()");
          /*  OuterClass outerClass = new OuterClass();
            System.out.println(outerClass.data1);*/

            System.out.println(this.data1);
            System.out.println(data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
        }
    }
}

【注意事项】

1. 外部类中的任何成员都可以在实例内部类方法中直接访问

2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束

3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员来访问

4. 实例内部类对象必须在先有外部类对象前提下才能创建

5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用

6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

4.2.2 静态内部类

不想依靠外部类对象创建内部类对象, 那么就可以把这个内部类定义成静态内部类.

被static修饰的内部成员类称为静态内部类。

class OuterClass2 {
    public int data1 = 1;
    int data2 = 2;
    public static int data3 = 3;

    public void test() {
        System.out.println("out::test()");
    }

    /**
     * 1. 如何获取静态内部类对象？
     *          OuterClass2.InnerClass2 innerClass2 = new OuterClass2.InnerClass2();
     * 2. 静态内部类当中，不能访问外部类的非静态成员。外部类的非静态成员，
     *          需要通过外部类的对象的引用才能访问。
     *     非要访问： OuterClass2 outerClass = new OuterClass2();
     *             System.out.println(outerClass.data1);
     */
    static class InnerClass2 {
        public int data4 = 4; 
        int data5 = 5;
        public static int data6 = 6;

        public void func() {
            System.out.println("out::func()");

            /*System.out.println(data1);
            System.out.println(data2);*/

            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
        }
    }
}

【注意事项】

1. 在静态内部类中只能访问外部类中的静态成员

2. 创建静态内部类对象时，不需要先创建外部类对象

4.2.3 局部内部类

定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用，一般使用的非常少，此处简单了解下语法格式。

public class OutClass {
    int a = 10;
    public void method(){
        int b = 10;

        // 局部内部类：定义在方法体内部
        // 不能被public、static等访问限定符修饰
        class InnerClass{
            public void methodInnerClass(){
                System.out.println(a);
                System.out.println(b);
            }
        }

        // 只能在该方法体内部使用，其他位置都不能用
        InnerClass innerClass = new InnerClass();
        innerClass.methodInnerClass();
    }

    public static void main(String[] args) {
    // OutClass.InnerClass innerClass = null; 编译失败
    }
}

【注意事项】

1. 局部内部类只能在所定义的方法体内部使用

2. 不能被public、static等修饰符修饰

3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$内部类名字.class

4. 几乎不会使用

5. 对象的打印

如下所示, 假设我们需要打印Person对象的age和name, 每次都需要自己写一个show方法:

class Person {
    public int age = 66;
    public String name = "Java";

    public void show() {
        System.out.println("姓名：" + name + " 年龄：" + age);
    }
}

字段少的时候还能够接受, 但是字段一多就会降低代码编写速度, 并且代码冗余程度非常高.

public class Test2 {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
    }
}

如果我们直接sout(person), 由于person是引用变量, 存储了new Person()这个对象的地址, 于是会打印出类似地址的东西.

这个运行结果中, @前面的意思是, 输出这个变量的全路径, @后面的字符串我们先暂时简单认为是"地址", 是唯一的.

那么我们怎么知道它是如何打印出来的呢? 我们看一下println:

可以看到, 它是调用的Object的toString, 那么我们就可以重写这个方法.

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

于是再次运行: