【面向对象（二）】内部类、封装

Amireux yj

已于 2022-04-11 23:45:35 修改

阅读量447

点赞数 16

分类专栏： JavaSE 文章标签： java intellij-idea 数据结构

于 2022-04-09 22:54:55 首次发布

本文链接：https://blog.csdn.net/weixin_57218530/article/details/124064501

版权

JavaSE 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

上次的学习，我们学习了面向对象的编程语言的基本知识。类和对象是Java程序的基本组成因素。类描述了同一类对象都具有的数据和行为。Java语言中的类将这些数据进行了封装，形成了一种复合数据结构。本次的学习我们将重点转移到面向对象当中的内部类和封装。

1、内部类

当一个类定义在另一个类的内部，前者就是后者的内部类，后者就是前者的外部类。从类的定义来看，内部类和外部类没有区别，它们都可以定义自己的成员变量和方法，但是内部类因其位置的独特性，在定义成员变量时多了诸多限制。

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

内部类可以独立的继承或者实现一个类或接口，无论外部类是否继承或者实现，内部类不受影响。如果说接口解决了一些问题，而内部类则让多重继承趋于完美。这种利用内部类实现某些接口或者继承某些类的方式增强了类的自由性，让类不拘泥于死板的继承或者实现，让代码更加优雅与简化，结构更加清晰明了。

内部类的特性如下：

*在内部类可以有多个实例，每个实例都有自己的状态信息，并与其他外部类对象的信息相互独立；

*在单个内部外中，可以让多个内部类以不同的方式实现同一个接口或者继承同一个类；

*内部类的对象创建不依赖与外部类的对象创建；

*内部类是一个独立的实体；

*内部类提供了更好的封装，这些封装仅仅提供给外部类，其它类均不能访问。

1.1内部类的分类

1.1.1 静态内部类

被static修饰的成员内部类

代码如下：

public class OutClass {
        private int a;
        static int b;
        public void methodA(){
            a = 10;
            System.out.println(a);
        }
        public static void methodB(){
            System.out.println(b);
        }
        // 静态内部类：被static修饰的成员内部类
        static class InnerClass{
            public void methodInner(){

                // 在内部类中只能访问外部类的静态成员
                // a = 100; // 编译失败，因为a不是类成员变量
                b =200;
                // methodA(); // 编译失败，因为methodB()不是类成员方法
                methodB();
            }
        }
        public static void main(String[] args) {
            // 静态内部类对象创建 & 成员访问
            OutClass.InnerClass innerClass = new OutClass.InnerClass();
            innerClass.methodInner();
        }
}

运行结果：

关键字static可以修饰成员变量、方法、代码块和内部类。static修饰的内容是跟随类加载而加载的，而且内容只有一份，不能随对象的创建而变化，且所有的类对象都能访问。static修饰的方法使用“类名.方法名”的方式调用，而不需要初始化对象去调用。

【注意事项】
1. 在内部类中只能访问外部类中的静态成员
2. 创建内部类对象时，不需要先创建外部类对象
3. 成员内部类，经过编译之后会生成独立的字节码文件，命名格式为：外部类名称$内部类名称

1.1.2普通内部类

未被static定义的成员内部类

代码如下：

package bit;

public class OutClass {
    private int a;
    static int b;
    int c;
    public void methodA(){
        a = 10;
        System.out.println(a);
    }
    public static void methodB(){
        System.out.println(b);
    }
    // 成员内部类：未被static修饰
    class InnerClass{
        int c;
        public void methodInner(){

            // 在内部类中可以直接访问外部类中：任意访问限定符修饰的成员
            a = 100;
            b =200;
            methodA();
            methodB();

            // 如果外部类和内部类中具有相同名称成员时，优先访问的是内部类自己的
            c = 300;
            System.out.println(c);

            // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
            OutClass.this.c = 400;
            System.out.println(OutClass.this.c);
        }
    }
    public static void main(String[] args) {

        // 外部类：对象创建 以及 成员访问
        OutClass outClass = new OutClass();
        System.out.println(outClass.a);
        System.out.println(OutClass.b);
        System.out.println(outClass.c);
        outClass.methodA();
        outClass.methodB();
        System.out.println("=============内部类的访问=============");

        // 要访问普通内部类中成员，必须要创建普通内部类的对象
        // 而普通内部类定义与外部类成员定义位置相同，因此创建普通内部类对象时必须借助外部类
        // 创建内部类对象
        OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
        // 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建内部类对象
        OutClass.InnerClass innerClass2 = outClass.new InnerClass();
        innerClass2.methodInner();
    }

运行结果：

【注意事项】
1. 外部类中的任何成员都可以被在普通内部类方法中直接访问
2. 普通内部类所处的成员与外部类成员位置相同，因此也受public、private等访问限定符的约束
3. 在内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.
同名成员来访问
4. 普通内部类对象必须在先有外部类对象前提下才能创建
5. 普通内部类的非静态方法中包含了一个指向外部类对象的引用
6. 外部类中，不能直接访问内部类中的成员，如果要访问必须先要创建外部类的对象。

1.1.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. 编译器也有自己独立的字节码文件，命名格式：外部类名字$x内部类名字.class，x是一个整数。
4.几乎不会用

2、封装

在现实生活中，封装是个很常见的事情。例如，你无需关心手电筒怎样工作，当你买了一个手电筒之后，只需要充电就可以了，手电筒就可以工作了。在面向对象中，封装是指无需关注实现，你只需要知道那些已经包装好的类和方法提供的逻辑，可以实现对应的逻辑即可。

在面向对象编程中，封装又叫隐藏实现。2.

2.1方法封装

代码如下：

public class LoanRate {
    public double getInterrestRate(String term,double floatScale){
        //获取最后一位字符，Y代表年，M代表月，D代表天
        String type=term.substring(term.length()-1);
        //获取对应的贷款期限
        int terms=Integer.parseInt(term.substring(0,(term.length()-1)));
        double loanRate=0.0;
        //短期期限1年以内，基础利率4.38
        if(!"Y".equals(type)){
            loanRate=getShortBase()*(1+floatScale);
            System.out.println("货款期限是"+term+",根据进准利率"+getShortBase()+"和浮动比例"+floatScale+",计算出来的贷款利率是:"+loanRate);
        }else{
            if(5>terms){
                //中期期限为1~5年，基础理论为4.75
                loanRate=getMidBase()*(1+floatScale);
                System.out.println("货款期限是"+term+",根据进准利率"+getMidBase()+"和浮动比例"+floatScale+",计算出来的贷款利率是:"+loanRate);
            }else{
                //长期期限为5年以上，基础利率为5.25
                loanRate=getLongBase()*(1+floatScale);
                System.out.println("货款期限是"+term+",根据进准利率"+getLongBase()+"和浮动比例"+floatScale+",计算出来的贷款利率是:"+loanRate);
            }
        }
        //返回贷款利率，基础利率*（1+上浮比例）
        return loanRate;
    }
    //短期基准利率
    public double getShortBase(){
        return 4.38;
    }
    //中期基准利率
    public double getMidBase(){
        return 4.75;
    }
    //长期基准利率
    public double getLongBase(){
        return 5.25;
    }

    public static void main(String[] args) {
        LoanRate Ir=new LoanRate();
        double loanRateShort= Ir.getInterrestRate("8M",0.7);//短期利率
        double loanRateMid= Ir.getInterrestRate("4Y",0.7);//中期利率
        double loanRateLong= Ir.getInterrestRate("6Y",0.6);//长期利率
    }


}

运行结果：

2,2属性封装

代码如下：

public class PeopleDemo {
    public static void main(String[] args) {
        People person=new People("张三",15,100);
        System.out.println(person.toString());//格式化输出person的信息
        //person.age=50;//编译报错
        person.num=200;//修改公共属性
        System.out.println(person.toString());
        person.setAge(50);//调用包装方法设置年龄
        System.out.println(person.toString());
        System.out.println(person.getAge());//使用包装方法获取年龄属性的值
    }
}
    //定义一个People
    class People{
        private String name;
        private int age;
        public int num;

    //根据姓名、年龄和编号初始化对象
    public People(String name,int age,int num){
        this.name=name;
        this.age=age;
        this.num=num;
    }
    //获取姓名
    public String getName(){
        return name;
    }
    //设置姓名
    public void setName(String name){
        this.name=name;
    }


        //获取年龄
        public int getAge() {
            return age;
        }
        //设置年龄
        public void setAge(int age) {
            this.age = age;
        }
        //获取编号
        public int getNum() {
            return num;
        }
        //设置编号
        public void setNum(int num) {
            this.num = num;
        }

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

运行结果：

封装的好处在于某个方法只是为了实现某个特定的功能，而这个功能仅仅供人使用。

封装是面向对象的三大特征之一，其优点如下：

1、封装使得对代码的修改更加安全和容易。因为代码是一个相对独立的单元，修改不会对其它单元产生影响。

2、封装使得整个软件开发复杂难度大大降低。在协同开发时，只需要关注方法的输入和输出，无需关注其内部实现，它使得不同开发者可以使用其他人写好的代码，加快了开发速度。