关于java:如何讲清楚-Java-面向对象的问题与知识类与对象封装继承多态接口内部类

29次阅读

共计 15460 个字符，预计需要花费 39 分钟才能阅读完成。

写在最后面

这个我的项目是从 20 年末就立好的 flag，通过几年的学习，回过头再去看很多知识点又有新的了解。所以趁着找实习的筹备，联合以前的学习储备，创立一个次要针对应届生和初学者的 Java 开源常识我的项目，专一 Java 后端面试题 + 解析 + 重点常识详解 + 精选文章的开源我的项目，心愿它能随同你我始终提高！

阐明：此我的项目我的确有很用心在做，内容全副是我参考了诸多博主（已注明出处），材料，N 本书籍，以及联合本人了解，从新绘图，从新组织语言等等所制。集体之力菲薄，或有不足之处，在劫难逃，但更新 / 欠缺会始终进行。大家的每一个 Star 都是对我的激励！心愿大家能喜爱。

注：所有波及图片未应用网络图床，文章等均开源提供给大家。

我的项目名: Java-Ideal-Interview

Github 地址：Java-Ideal-Interview – Github

Gitee 地址：Java-Ideal-Interview – Gitee（码云）

继续更新中，在线浏览将会在前期提供，若认为 Gitee 或 Github 浏览不便，可克隆到本地配合 Typora 等编辑器舒服浏览

若 Github 克隆速度过慢，可抉择应用国内 Gitee 仓库

<!– @import “[TOC]” {cmd=”toc” depthFrom=1 depthTo=6 orderedList=false} –>

<!– code_chunk_output –>

  • 二 Java 面向对象

    • 1. 类和对象

      • 1.1 什么是面向过程？什么又是面向对象？

        • 1.1.1 能举个例子谈谈你对面向过程和面向对象的了解吗
        • 1.1.2 面向过程和面向对象的优缺点
      • 1.2 说一说类、对象、成员变量和成员办法的关系和了解

      • 1.3 成员变量和局部变量有什么区别？

        • 1.3.1 为什么局部变量存在于栈中而不是堆中
      • 1.4 拜访权限修饰符 public、private、protected, 以及不写（默认）时的区别
      • 1.5 类在初始化的时候做了些什么？

      • 1.6 static 关键字润饰的作用？

        • 1.6.1 什么是静态方法
        • 1.6.2 什么是动态变量
        • 1.6.3 什么是 动态代码块

    • 2. 面向对象三大特色

      • 2.1 封装
      • 2.2 继承
      • 2.3 多态

    • 3. 其余

      • 3.3 抽象类和接口

        • 3.3.1 谈谈你对抽象类和接口的意识

          • 运行后果：
        • 3.3.2 抽象类和接口的区别（重要）

      • 3.4 谈谈几种外部类和应用外部类的起因

        • 3.4.1 几种外部类
        • 3.4.2 为什么应用外部类

<!– /code_chunk_output –>

二 Java 面向对象

1. 类和对象

1.1 什么是面向过程？什么又是面向对象？

面向过程——步骤化

  • 面向过程就是剖析出实现需求所须要的步骤，通过函数（办法）一步一步实现这些步骤，接着顺次调用即可

面向对象——行为化（概念绝对形象，可联合上面的例子了解）

  • 面向对象是把整个需要依照特点、性能划分，将这些存在共性的局部封装成类（类实例化后才是对象），创立了对象不是为了实现某一个步骤，而是形容某个事物在解决问题的步骤中的行为

1.1.1 能举个例子谈谈你对面向过程和面向对象的了解吗

例如咱们设计一个桌球游戏（略过开球，只思考两头过程）

A：面向过程形式思考：

把下述的步骤 通过函数一步一步实现，这个需要就实现了。（只为演示概念，不细究逻辑问题）。

① palyer1 击球 —— ② 实现画面击球成果 —— ③ 判断是否进球及无效 —— ④ palyer2 击球

⑤ 实现画面击球成果 —— ⑥ 判断是否进球及无效 —— ⑦ 返回步骤 1—— ⑧ 输入游戏后果

B：面向对象形式思考：

通过察看咱们能够看到，其实在下面的流程中存在很多 共性 的中央，所以咱们将这些共性局部全集中起来，做成一个 通用的构造

  1. 玩家零碎：包含 palyer1 和 palyer2
  2. 击球成果零碎：负责展现给用户游戏时的画面
  3. 规定零碎：判断是否犯规，输赢等

咱们将繁琐的步骤，通过行为、性能，模块化，这就是面向对象，咱们甚至能够利用该程序，别离疾速实现 8 球和斯诺克的不同游戏（只须要批改规定、地图和球色即可，玩家零碎，击球成果零碎都是统一的）

1.1.2 面向过程和面向对象的优缺点

A：面向过程

长处：性能上它是优于面向对象的，因为类在调用的时候须要实例化，开销过大。

毛病：不易保护、复用、扩大

用处：单片机、嵌入式开发、Linux/Unix 等对性能要求较高的中央

B：面向对象

长处 ：易保护、易复用、易扩大，因为面向对象有 封装 、 继承 、 多态性 的个性，能够设计出 低耦合 的零碎，使零碎更加灵便、更加易于保护

毛病：一般来说性能比面向过程低

低耦合：简略的了解就是说，模块与模块之间尽可能的独立，两者之间的关系尽可能简略，尽量使其独立的实现成一些子性能，这防止了牵一发而动全身的问题。这一部分咱们会在面向对象学习完结后进行零碎的整顿和总结。

总结：只通过教科书后的例题是无奈领会到面向过程所存在的问题的，在一些小例程中，面向过程感觉反而会更加的简略，然而一旦面临较大的我的项目，咱们须要编写 N 个性能类似的函数，函数越来越多，代码量越来越多，你就晓得这是一场噩梦了。

阐明：对于性能的问题，这里只是在抽象意义上来说，具体性能优劣，须要联合具体程序，环境等进行比对

1.2 说一说类、对象、成员变量和成员办法的关系和了解

类：一组相干的属性和行为的汇合，是一个形象的概念。

对象：该类事物的具体表现形式，具体存在的个体。

成员变量：事物的属性

成员办法：事物的行为

下面咱们说了这几个概念，那么到底应该怎么了解呢？

类就是对一些具备 共性特色 ，并且 行为类似 的个体的形容。

比方小李和老张都有姓名、年龄、身高、体重等一些 属性，并且两人都可能进行聊天、静止等 类似的行为。

因为这两个人具备这些共性的中央，所以咱们把它形象进去，定义为一个 类——人类，而小李、老王正是这个类中的个体（对象），而每一个个体才是真正具体的存在，光提到人类，你只晓得应该有哪些属性行为，但你不晓得他具体的一些属性值，比方你晓得他属于“人类”所以他应该领有姓名，年龄等属性，但你并不知道他具体叫什么，年龄多大了。而小李和老王这两个具体的对象，却可能实实在在的晓得老王往年 30 岁了、身高 175 等值。

所以能够得出后果：类是对象的形象，而对象是类的具体实例。类是形象的，不占用内存，而真正依据类实例化出具体的对象，就须要占用内存空间了。

1.3 成员变量和局部变量有什么区别？

A：在类中的地位不同

  • 成员变量：类中办法外
  • 局部变量：代码块，办法定义中或者办法申明上（办法参数）

B：在内存中的地位不同

  • 成员变量：在堆中
  • 局部变量：在栈中

C：生命周期不同

  • 成员变量：随着对象的创立而存在，随着对象的隐没而隐没
  • 局部变量：随着办法的调用而存在，随着办法的调用结束而隐没

D：初始化值不同

  • 成员变量：有默认值（构造方法对它的值进行初始化）
  • 局部变量：没有默认值，必须定义，赋值，而后能力应用

1.3.1 为什么局部变量存在于栈中而不是堆中

有一个问题，在咱们学习 Java 中内存调配的时候，有这样一句话，“堆内存用来寄存 new 创立的对象和数组”。换句话说对象存在于堆中，而成员变量又存在于类中，而且对象是类具体的个体，所以成员变量也存在于堆中，那么问题就来了，同理，是不是办法也和成员变量一样存在于对象中，而局部变量又定义在办法中，岂不就是说，局部变量也存在于堆中呢？这显著与咱们下面的定义有区别

解释 ：一个类能够创立 n 个不同的对象，当咱们 new 一个对象后，这个对象实体，曾经在堆上调配了内存空间，因为 类的成员变量在不同的对象中各不相同（例如，小李和老王的姓名不同），都须要本人各自的存储空间，所以类的成员变量会随着对象存储在堆中，而因为类的办法是所有对象通用的，所以创建对象时，办法还未呈现，只有申明，办法外面的局部变量也并没有被创立，只有等到对象应用办法的时候才会被压入栈。

补充：类变量（动态变量）存在于办法区，援用类型的局部变量申明在栈，存储在堆

1.4 拜访权限修饰符 public、private、protected, 以及不写（默认）时的区别

拜访权限 类 包 子类 其余包
public √ √ √ √
protect √ √ √
default √ √
private √
  • public：公共的，能够被我的项目中所有的类拜访。
  • protected：受爱护的，能够被这个类自身拜访；被同一个包中的类拜访；被它的子类（同一个包以及不同包中的子类）拜访。
  • default：默认的，能够被这个类自身拜访；被同一个包中的类拜访。
  • private：公有的，只能被这个类自身拜访。

1.5 类在初始化的时候做了些什么？

public class Student {
    private String name = "BWH_Steven";
    private Integer age = 22;
    
    // 是个无参结构，为了演示初始化程序，特意加了两个赋值语句
    public Student (){ 
        name = "阿文";
        age = 30;
    }
}

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

例如：Student stu = new Student(); 其在内存中做了如下的事件：

首先加载 Student.class（编译成字节码文件）文件进内存，在栈内存为 stu 变量开拓一块空间，在堆内存为 Student 类实例化出的学生对象开拓空间，对学生对象的成员变量进行默认初始化（例如 name = null，age = 0），对学生对象的成员变量进行显示初始化（例如 name = “BWH_Steven”，age = 22），接着就会通过构造方法对学生对象的成员变量赋值（执行构造函数内，咱们特意加的赋值语句 name = “ 阿文 ”，age = 30）学生对象初始化结束，把对象地址赋值给 stu 变量

1.6 static 关键字润饰的作用？

static 办法就是没有 this 的办法。在 static 办法外部不能调用非静态方法，反过来是能够的。而且能够在没有创立任何对象的前提下，仅仅通过类自身来调用 static 办法。这实际上正是 static 办法的主要用途。——《Java 编程思维》P86

能够晓得，被 static 关键字润饰的办法或者变量不须要依赖于对象来进行拜访，只有类被加载了，就能够通过类名去进行拜访。也就是说，即便没有创建对象也能够进行调用（办法 / 变量）

static 能够用来润饰类的成员办法、类的成员变量，另外能够编写 static 代码块来优化程序性能。

1.6.1 什么是静态方法

static 润饰的办法个别叫做静态方法，静态方法不依赖于对象拜访，因而没有 this 的概念（this 代表所在类的对象援用），正因如此静态方法可能拜访的成员变量和成员办法也都必须是动态的

  • 例如在静态方法 A 中 调用了非动态成员 B，如果通过 类名.A 拜访静态方法 A，此时对象还不存在，非动态成员 B 天然也基本不存在，所以就会有问题。调用非静态方法 C 也是如此，你不分明这个办法 C 中是否调用了费动态变量

1.6.2 什么是动态变量

static 润饰的变量也称作动态变量，动态变量属于类，所以也称为类变量，存储于办法区中的动态区，随着类的加载而加载，隐没而隐没，能够通过类名调用，也能够通过对象调用。

1.6.3 什么是 动态代码块

动态代码块是在类中（办法中不行）应用 static 关键字和{} 申明的代码块

static {... 内容}

执行： 动态代码块在类被加载的时候就运行了，而且只运行一次，并且优先于各种代码块以及构造函数。

作用： 个别状况下，如果有些代码须要在我的项目启动的时候就执行，这时候 就须要动态代码块。比方一个我的项目启动须要加载的 很多配置文件等资源，咱们就能够都放入动态代码块中。

1.6.3.1 结构代码块（补充）

概念 ：在 java 类中应用{} 申明的代码块（和动态代码块的区别是少了 static 关键字）

执行：结构代码块在创建对象时被调用，每次创建对象都会调用一次，然而优先于构造函数执行。

作用：和构造函数的作用相似，都能对对象进行初始化，并且只创立一个对象，结构代码块都会执行一次。然而反过来，构造函数则不肯定每个对象建设时都执行（多个构造函数状况下，建设对象时传入的参数不同则初始化应用对应的构造函数）。

因为每个构造方法执行前，首先执行结构代码块，所以能够把多个构造方法中雷同的代码能够放到这里，

2. 面向对象三大特色

2.1 封装

封装的概念

封装是指暗藏对象的属性和实现细节，仅对外提供公共拜访形式

  • 简略的来说就是我将不想给他人看的数据，以及他人无需晓得的外部细节，“锁起来”，咱们只留下一些入口，使其与内部产生分割。

咱们如何给咱们的数据“上锁”呢？

  • 咱们应用，public、private、protected 等权限修饰符 在类的外部设定了边界，这些不同水平的”锁“决定了紧跟其后被定义的货色可能被谁应用。

封装的益处

暗藏实现细节，提供公共的拜访形式，进步了代码的复用性，进步安全性

益处 1：暗藏实现细节，提供公共的拜访形式

暗藏实现细节怎么了解呢？

  • 咱们将一些性能封装到类中，而客户端的程序员，不须要晓得类中的这个办法的逻辑原理，类程序员只须要给他一个对外的接口，客户端程序员只须要可能调用这个办法即可，
  • 例如：夏天宿舍很热，咱们（用户）只须要操作遥控器即可应用空调，并不需要理解空调外部是如何运行的

提供公共的拜访形式又怎么了解呢？

咱们先来看一段规范案例

public class Student {
    // 定义成公有成员变量（private）private String name;
    private int age;
    
    // 无参结构
    public Student() {super();
    }

    // 带参结构
    public Student(String name, int age) {super();
        this.name = name;
        this.age = age;
    }
    
    // 成员变量的 set 和 get 办法（与外界分割的桥梁）public void setName(String name) {this.name = name;}

    public String getName() {return name;}

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

    public int getAge() {return age;}
}
public class StudentTest {public static void main(String[] args) {
        // 创立学生类对象 s
        Student s = new Student()；// 对象 s 调用类中的公共办法 setName()和 setAge()
        //set 办法给成员变量赋值
        s.setName("BWH_Steven");
        s.setAge(20);
        
        //get 办法获取成员变量
        System.out.println(s.getName() + s.getAge());
    }
}

咱们能够看到在下面的案例中，成员变量都应用 private 润饰，而上面的 get 和 set 办法均应用了 public 润饰，其实被 private 润饰的属性就是咱们想要 锁起来 的数据，而 set、get 办法就是咱们关上这把锁的钥匙

被 private 所润饰的内容是，除 类型创建者和类型的外部办法之外的任何人都不能拜访的元素，所以咱们这些数据就被咱们通过 private“锁”了起来，而咱们外界是能够通过创建对象来调用一个类中的公共办法的，所以被 public 润饰的 set 和 get 办法外界所能拜访的，而这两个办法又能够间接拜访咱们的公有成员变量，所以 set 和 get 办法就成为了公有成员与外界沟通的钥匙。

益处 2：进步了代码的复用性

性能被封装成了类，通过基类与派生类之间的一些机制（组合和继承），来进步代码的复用性

益处 3：进步安全性（此处待批改）

对于安全性的问题，实际上还是存在争议的，咱们先看一种说法：

public class Student {

    private String name;
    private int age;

    public Student() {super();
    }

    public Student(String name, int age) {super();
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {this.name = name;}

    public String getName() {return name;}

    // 在 setAge()办法中退出了校验的内容
    // 不非法数据是不容许传递给成员变量的
    public void setAge(int age) {if (age < 0 || age > 120) {System.out.println("Error");
        }else {this.age = age;}     
    }

    public int getAge() {return age;}
}

public class StudentTest {public static void main(String[] args) {Student s = new Student();
        System.out.println(s.getName() + s.getAge());
        
        // 谬误的形式！！！s.name = "BWH_Steven";
        s.age = 20;
        System.out.println(s.getName() + s.getAge());
        
           // 正确的形式！！！s.setName("BWH_Steven");
        s.setAge(20);
    }
}

咱们用 private 来润饰咱们的成员变量不是没有任何根据的，如果咱们的成员变量修饰符改为 public，这句意味着外界能够应用对象间接拜访，批改这个成员变量，这可能会造成一些重大的问题

例如：外界通过对象去给成员变量赋值，能够赋值一些非法的数据，这显著是不合理的。所以在赋值之前应该先对数据进行判断。StudenTest 是一个测试类，测试类个别只创建对象，调用办法，所以这个判断应该定义在 Student 类中。须要应用逻辑语句，而逻辑语句应该定义在办法中。所以在 Student 类中提供一个办法来对数据进行校验然而如果偏偏不调用办法来赋值，还是通过 对象名. 变量 间接赋值，这样咱们的办法内的逻辑就没有起作用所以咱们必须强制要求应用我的办法，而不能间接调用成员变量这也正是咱们应用 private 润饰成员变量的起因！

注：此处举例为 JavaBean 类，个别很少在 set get 中去增加一些逻辑，个别都是一种简略的赋值，而且诸多框架和不错的我的项目均应用了这种标准办法。

2.2 继承

继承就是在一个已有类的根底上派生出新类（例如动物类能够派生出狗类和猫类），子类继承父类的特色和行为，使得子类对象（实例）具备父类的实例域和办法，或子类从父类继承办法，使得子类具备父类雷同的行为

进步了代码的复用性，进步了代码的维护性（通过大量的批改，满足一直变动的具体要求），让类与类产生了一个关系，是多态的前提。然而毛病也很显著：让类的耦合性加强，这样某个类的扭转就会影响其余和该类相干的类。

特点：Java 只反对单继承，不反对多继承(C++ 反对)，然而 Java 反对多层继承（继承体系）形象的说就是：儿子继承爸爸，爸爸继承爷爷，儿子能够通过爸爸继承爷爷。

留神：

A: 子类只能继承父类所有非公有成员（成员办法和成员变量）

B：子类不能继承父类的构造方法，然而能够通过 super 关键字去拜访办法

C: 不要为了局部性能而继承（多层继承会使得子类继承多余的办法）

2.3 多态

多态是同一个行为具备多个不同表现形式或状态的能力，例如：黑白打印机和彩色打印机雷同的打印行为却有着不同的打印成果，

  • 对象类型和援用类型之间存在着继承（类）/ 实现（接口）的关系；
  • 当应用多态形式调用办法时，首先查看父类中是否有该办法，如果没有，则编译谬误；如果有，再去调用子类的同名办法。
  • 如果子类重写了父类的办法，最终执行的是子类笼罩的办法，如果没有则执行的是父类的办法。

3. 其余

3.3 抽象类和接口

3.3.1 谈谈你对抽象类和接口的意识

抽象类：咱们创立一个动物类，并且在这个类中创立动物对象，然而当你提到动物类，你并不知道我说的是什么动物，只有看到了具体的动物，你才晓得这是什么动物，所以说动物自身并不是一个具体的事物，而是一个形象的事物。只有真正的猫，狗才是具体的动物，同理咱们也能够推理不同的动物，他们的行为习惯应该是不一样的，所以咱们不应该在动物类中给出具体体现，而是给出一个申明即可。

接口：常见的猫狗案例，猫和狗它们仅仅提供一些基本功能。但有一些不是动物自身就具备的，比方：猫钻火圈，狗跳低等性能是在前面的造就中训练进去的，这种额定的性能，java 提供了接口示意。

3.3.1.1 为什么抽象类必须重写所有形象办法

“猫”和“狗”都是“动物”这个类的实体，比方动物都有 eat() 这个办法，然而狗是吃肉的，猫是吃鱼的。所以每个动物对于具体吃的形式是须要在子类中重写的，不然的话，狗和猫不就一样了吗？

// Animal 类

public abstract class Animal {public void sleep() {System.out.println("我趴着睡");
    }
    public abstract void eat();}
// Dog 类
public class Dog extends Animal {public Dog() {super();
    }
    
    @Override
    public void eat() {System.out.println("我实现了父类办法，狗吃肉");
    }
}
// Cat 类
public class Cat extends Animal{public Cat() {super();
    }

    @Override
    public void eat() {System.out.println("我实现了父类办法，猫吃鱼");
    }
}
// 测试类
public class AnimalTest {public static void main(String[] args) {Animal a1 = new Dog();
        a1.sleep();
        a1.eat();
        System.out.println("-------------------------");
        Animal a2 = new Cat();
        a2.sleep();
        a2.eat();}
}
运行后果：
我趴着睡
我实现了父类办法，狗吃肉
-------------------------
我趴着睡
我实现了父类办法，猫吃鱼

通过下面的例子咱们能够看到，Dog 和 Cat 两个子类继承 Animal，两者 sleep() 办法是一样的均继承于 Animal 类，而 eat() 办法因为个性不同则在 Animal 类中定义为形象办法，别离在子类中实现。

3.3.2 抽象类和接口的区别（重要）

咱们从咱们理论设计场景中来切入这个话题

先来举一个简略的例子：

狗都具备 eat()、sleep() 办法，咱们别离通过抽象类和接口定义这个抽象概念

// 通过抽象类定义
public abstract class Dog {public abstract void eat();
    public abstract void sleep();}
// 通过接口定义
public interface Dog {public abstract void eat();
    public abstract void sleep();}

然而咱们当初如果须要让狗领有一项非凡的技能——钻火圈 DrillFireCircle()，如何减少这个行为呢？

思考：

  1. 将钻火圈办法与后面两个办法一起写入抽象类中，然而这样的话，凡是继承这个抽象类狗都具备了钻火圈技能，显著不适合
  2. 将钻火圈办法与后面两个办法一起写入接口中，当须要应用钻火圈性能的时候，就必须实现 接口中的 eat()、sleep() 办法（重写该接口中所有的办法）显然也不适合

那么该如何解决呢 ? 咱们能够认真想一想，eat 和 sleep 都是狗自身所应该具备的一种行为，而钻火圈这种行为则是先天训练进去的，只能算是对狗类的一种附加或者延长，两者不应该在同一个领域内，所以咱们思考将这个独自的行为，独立的设计一个接口，其中蕴含 DrillFireCircle()办法，Dog 设计为一个抽象类，其中又包含 eat()、sleep() 办法。

一个 SpecialDog 即可继承 Dog 类并且实现 DrillFireCircle()接口

上面给出代码:

// 定义接口，含有钻火圈办法
public interface DrillFireCircle() {public abstract void drillFireCircle();
}

// 定义抽象类狗类
public abstract class Dog {public abstract void eat();
    public abstract void sleep();}
 
// 继承抽象类且实现接口
class SpecialDog extends Dog implements drillFireCircle {public void eat() {// ....}
    public void sleep() {// ....}
    public void drillFireCircle() () {// ....}
}

总结：继承是一个 “ 是不是 ” 的关系，而 接口 实现则是 “ 有没有 ” 的关系。如果一个类继承了某个抽象类，则子类必然是抽象类的品种，而接口实现则是有没有、具备不具备的关系，比方狗是否能钻火圈，能则能够实现这个接口，不能就不实现这个接口。

3.4 谈谈几种外部类和应用外部类的起因

3.4.1 几种外部类

概述：把类定义在另一个类的外部，该类就被称为外部类。

举例：把类 Inner 定义在类 Outer 中，类 Inner 就被称为外部类。

class Outer {class Inner {}
}

拜访规定：外部类能够间接拜访外部类的成员，包含公有。外部类要想拜访外部类成员，必须创建对象

外部类的分类：A：成员外部类、B：部分外部类、C：动态外部类、D：匿名外部类

3.4.1.1 成员外部类

成员外部类——就是位于外部类成员地位的类

特点：能够应用外部类中所有的成员变量和成员办法（包含 private 的）

A：格局：

class Outer {
    private int age = 20;
    // 成员地位
    class Inner {public void show() {System.out.println(age);
        }
    }
}

class Test {public static void main(String[] ages) {
        // 成员外部类是非动态的演示
        Outer.Inner oi = new Outer().new Inner();
        oi.show();}
}

B：创建对象时：

// 成员外部类不是动态的：外部类名. 外部类名 对象名 = new 外部类名.new 外部类名();

// 成员外部类是动态的：外部类名. 外部类名 对象名 = new 外部类名. 外部类名();

C：成员外部类常见修饰符：

a：private

如果咱们的外部类不想轻易被任何人拜访，能够抉择应用 private 润饰外部类，这样咱们就无奈通过创建对象的办法来拜访，想要拜访只须要在外部类中定义一个 public 润饰的办法，间接调用。这样做的益处就是，咱们能够在这个 public 办法中减少一些判断语句，起到数据安全的作用。

class Outer {
    private class Inner {public void show() {System.out.println(“明码备份文件”);
        }
    }
    
    public void method() {if(你是管理员){Inner i = new Inner();
            i.show();}else {System.out.println(“你没有权限拜访”);
        }
       }
}

上面咱们给出一个更加标准的写法

class Outer {
    private class Inner {public void show() {System.out.println(“明码备份文件”);
        }
    }
    // 应用 getXxx()获取成员外部类，能够减少校验语句（文中省略）public Inner getInner() {return new Inner();
       }
    
    public static void main(String[] args) {Outer outer = new Outer();
        Outer.Inner inner = outer.getInner();
        inner.show();}
}

b：static

这种被 static 所润饰的外部类，按地位分，属于成员外部类，但也能够称作动态外部类，也常叫做嵌套外部类。具体内容咱们在上面具体解说。

D：成员外部类经典题(填空)

请在三个 println 后括号中填空使得输入 25,20,18

class Outer {
    public int age = 18;    
    class Inner {
        public int age = 20;    
        public viod showAge() {
            int age  = 25;
            System.out.println(age);// 空 1
            System.out.println(this.age);// 空 2
            System.out.println(Outer.this.age);// 空 3
        }
    }
}

3.4.1.2 部分外部类

部分外部类 —— 就是定义在一个办法或者一个作用域外面的类

特点：次要是作用域产生了变动，只能在本身所在办法和属性中被应用

A 格局：

class Outer {public void method(){class Inner {}
    }
}

B：拜访时：

// 在部分地位，能够创立外部类对象，通过对象调用和外部类办法
class Outer {
    private int age = 20;
    public void method() {
        final int age2 = 30;
        class Inner {public void show() {System.out.println(age);
                // 从外部类中拜访办法内变量 age2，须要将变量申明为最终类型。System.out.println(age2);
            }
        }
        
        Inner i = new Inner();
        i.show();}
}

C: 为什么部分外部类拜访局部变量必须加 final 润饰呢？

因为局部变量是随着办法的调用而调用，应用结束就隐没，而堆内存的数据并不会立刻隐没。

所以，堆内存还是用该变量，而该变量曾经没有了。为了让该值还存在，就加 final 润饰。

起因是，当咱们应用 final 润饰变量后，堆内存间接存储的是值，而不是变量名。

（即上例 age2 的地位存储着常量 30 而不是 age2 这个变量名）

3.4.1.3 动态外部类

咱们所晓得 static 是不能用来润饰类的，然而成员外部类能够看做外部类中的一个成员，所以能够用 static 润饰，这种用 static 润饰的外部类咱们称作动态外部类，也称作嵌套外部类。

特点：不能应用外部类的非 static 成员变量和成员办法

解释：非动态外部类编译后会默认的保留一个指向外部类的援用，而动态类却没有。

简略了解：即便没有外部类对象，也能够创立动态外部类对象，而外部类的非 static 成员必须依赖于对象的调用，动态成员则能够间接应用类调用，不用依赖于外部类的对象，所以动态外部类只能拜访动态的内部属性和办法。

class Outter {
    int age = 10;
    static age2 = 20;
    public Outter() {}
     
    static class Inner {public method() {System.out.println(age);// 谬误
            System.out.println(age2);// 正确
        }
    }
}

public class Test {public static void main(String[] args)  {Outter.Inner inner = new Outter.Inner();
        inner.method();}
}

3.4.1.4 匿名外部类

一个没有名字的类，是外部类的简化写法

A 格局：

new 类名或者接口名() {重写办法();
}

实质：其实是继承该类或者实现接口的子类匿名对象

这也就是下例中，能够间接应用 new Inner() {}.show(); 的起因等于 子类对象.show();

interface Inter {public abstract void show();
}

class Outer {public void method(){new Inner() {public void show() {System.out.println("HelloWorld");
            }
        }.show();}
}

class Test {public static void main(String[] args)  {Outer o = new Outer();
        o.method();}
}

如果匿名外部类中有多个办法又该如何调用呢？

Inter i = new Inner() {  // 多态，因为 new Inner(){}代表的是接口的子类对象
    public void show() {System.out.println("HelloWorld");
    }
};

B：匿名外部类在开发中的应用

咱们在开发的时候，会看到抽象类，或者接口作为参数。

而这个时候，理论须要的是一个子类对象。

如果该办法仅仅调用一次，咱们就能够应用匿名外部类的格局简化。

3.4.2 为什么应用外部类

3.4.2.1 封装性

作为一个类的编写者，咱们很显然须要对这个类的应用访问者的拜访权限做出肯定的限度，咱们须要将一些咱们不违心让他人看到的操作暗藏起来，

如果咱们的外部类不想轻易被任何人拜访，能够抉择应用 private 润饰外部类，这样咱们就无奈通过创建对象的办法来拜访，想要拜访只须要在外部类中定义一个 public 润饰的办法，间接调用。

public interface Demo {void show();
}
class Outer {
    private class test implements Demo {public void show() {System.out.println("明码备份文件");
        }
    }
    
    public Demo getInner() {return new test();
    }
    
}

咱们来看其测试

    public static void main(String[] args) {Outer outer = new Outer();
        Demo d = outer.getInner();
        i.show();}

// 运行后果
明码备份文件

这样做的益处之一就是，咱们能够在这个 public 办法中减少一些判断语句，起到数据安全的作用。

其次呢，咱们的对外可见的只是 getInner() 这个办法，它返回了一个 Demo 接口的一个实例，而咱们真正的外部类的名称就被暗藏起来了

3.4.2.1 实现多继承

咱们之前的学习晓得，java 是不能够实现多继承的，一次只能继承一个类，咱们学习接口的时候，有提到能够用接口来实现多继承的成果，即一个接口有多个实现，然而这里也是有一点弊病的，那就是，一旦实现一个接口就必须实现外面的所有办法，有时候就会呈现一些累赘，然而应用外部类能够很好的解决这些问题

public class Demo1 {public String name() {return "BWH_Steven";}
}
public class Demo2 {public String email() {return "xxx.@163.com";}
}
public class MyDemo {

    private class test1 extends Demo1 {public String name() {return super.name();
        }
    }

    private class test2 extends Demo2  {public String email() {return super.email();
        }
    }

    public String name() {return new test1().name();}

    public String email() {return new test2().email();}

    public static void main(String args[]) {MyDemo md = new MyDemo();
        System.out.println("我的姓名:" + md.name());
        System.out.println("我的邮箱:" + md.email());
    }
}

咱们编写了两个待继承的类 Demo1 和 Demo2，在 MyDemo 类中书写了两个外部类，test1 和 test2 两者别离继承了 Demo1 和 Demo2 类，这样 MyDemo 中就间接的实现了多继承

3.4.2.3 用匿名外部类实现回调性能

咱们用艰深解说就是说在 Java 中，通常就是编写一个接口，而后你来实现这个接口，而后把这个接口的一个对象作以参数的模式传到另一个程序办法中，而后通过接口调用你的办法，匿名外部类就能够很好的展示了这一种回调性能

public interface Demo {void demoMethod();
}
public class MyDemo{public test(Demo demo){System.out.println("test method");
    }
    
    public static void main(String[] args) {MyDemo md = new MyDemo();
        // 这里咱们应用匿名外部类的形式将接口对象作为参数传递到 test 办法中去了
        md.test(new Demo){public void demoMethod(){System.out.println("具体实现接口")
            }
        }
    }
}

3.4.2.4 解决继承及实现接口呈现同名办法的问题

public interface Demo {void test();
}
public class MyDemo {public void test() {System.out.println("父类的 test 办法");
    }
    
}
public class DemoTest extends MyDemo implements Demo {public void test() {}}

这样的话我就有点懵了，这样如何辨别这个办法是接口的还是继承的，所以咱们应用外部类解决这个问题

public class DemoTest extends MyDemo {

    private class inner implements Demo {public void test() {System.out.println("接口的 test 办法");
        }
    }
    
    public Demo getIn() {return new inner();
    }
    
    
    public static void main(String[] args) {// 调用接口而来的 test()办法
        DemoTest dt = new DemoTest();
        Demo d = dt.getIn();
        d.test();
        
        // 调用继承而来的 test()办法
        dt.test();}
}

// 运行后果
接口的 test 办法
父类的 test 办法

正文完
java
发表至： java
2021-01-28
 0
关于java:Java-基础常见知识点面试题总结上2022-最新版-JavaGuide
关于java:Spring-Cloud-Alibaba-的服务注册与发现
【从蛋壳到满天飞】JAVA 数据结构解析和算法实现-链表
关于java:ssm框架理解