【Java复健指南13】OOP高级04【告一段落】-四大内部类
四大内部类
一个类的内部又完整的嵌套了另一个类结构。
class Outer{ //外部类
class lnner{
//内部类
}
}
class Other{//外部其他类
}
被嵌套的类称为内部类(inner class),嵌套其他类的类称为外部类(outer class)。
内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系
public class InnerClass01 { //外部其他类
public static void main(String[] args) {
}
}
class Outer { //外部类
private int n1 = 100;//属性
public Outer(int n1) {//构造器
this.n1 = n1;
}
public void m1() {//方法
System.out.println("m1()");
}
{//代码块
System.out.println("代码块...");
}
class Inner { //内部类, 在Outer类的内部
}
}
内部类的分类
定义在外部类局部位置上(比如方法内)：
1)局部内部类(有类名)
2)匿名内部类(没有类名，重点!)
定义在外部类的成员位置上:
1)成员内部类(没用static修饰)
2)静态内部类(使用static修饰)
局部内部类
使用说明
局部内部类定义在外部类的局部位置，比如方法中，并且有类名
1.可以直接访问外部类的所有成员（包含私有的）
2.不能添加访问修饰符
因为它的地位就是一个局部变量。
局部变量是不能使用修饰符的。
但是可以使用final修饰，因为局部变量也可以使用final
3.作用域:仅仅在定义它的方法或代码块中。
4.局部内部类---访问---->外部类的成员
访问方式:直接访问
5.外部类---访问---->局部内部类的成员
访问方式:创建对象,再访问(注意:必须在作用域内)
其实就是在包裹局部内部类的外面那个类里面像正常使用类的方式去使用局部内部类即可
要点：(1)局部内部类定义在方法/代码块中(2)其作用域在方法体/代码块中(3)本质上还是个类
6.外部其他类---不能访问----->局部内部类（因为局部内部类地位是一个局部变量)
7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访包
例子
class Outer02 {//外部类
private int n1 = 100;
private void m2() {
System.out.println("Outer02 m2()");
}//私有方法
public void m1() {//方法
//1.局部内部类是定义在外部类的局部位置,通常在方法
//3.不能添加访问修饰符,但是可以使用final 修饰
//4.作用域 : 仅仅在定义它的方法或代码块中
final class Inner02 {//局部内部类(本质仍然是一个类)
//2.可以直接访问外部类的所有成员，包含私有的
private int n1 = 800;
public void f1() {
//5. 局部内部类可以直接访问外部类的成员，比如下面 外部类n1 和 m2()
//7. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，
// 使用 （外部类名.this.成员）去访问
// Outer02.this 本质就是外部类的对象, 即哪个对象调用了m1, Outer02.this就是哪个对象
System.out.println("n1=" + n1 + " 外部类的n1=" + Outer02.this.n1);
System.out.println("Outer02.this hashcode=" + Outer02.this);
m2();
}
}
//6. 外部类在方法中，可以创建Inner02对象，然后调用方法即可
Inner02 inner02 = new Inner02();
inner02.f1();
}
}
/**
* 演示局部内部类的使用
*/
public class LocalInnerClass {//
public static void main(String[] args) {
//演示一遍
Outer02 outer02 = new Outer02();
outer02.m1();
System.out.println("outer02的hashcode=" + outer02);
}
}
匿名内部类
注意：这个点涉及继承、多态，非常综合也非常优雅
匿名内部类定义在外部类的局部位置，比如方法中，但是没有类名（系统分配类名）
关键点：(1)本质还是一个类；(2)是一个内部类；(3)该类没有名字；(4)同时还是一个对象；
基于接口的匿名内部类
需求： 想使用IA接口,并创建对象
按传统方式，我们会写一个类去实现该接口，并创建对象
但是Tiger/Dog类我只是使用一次，后面再不使用，如果为了一次使用就写一个类，太浪费了
因此可以使用匿名内部类来简化开发
例子
class Outer04 { //外部类
private int n1 = 10;//属性
public void method() {//方法
//基于接口的匿名内部类
//1.tiger的编译类型 ? IA
//2.tiger的运行类型 ? 就是匿名内部类 Outer04$1
//简单来说：
//如果只是IA tiger = new IA()那就是错的，因为接口不能实例化
//如果IA tiger = new IA()后面带{}那么就表明使用了匿名内部类
/*
我们看底层 会分配 类名 Outer04$1
class Outer04$1 implements IA {
@Override
public void cry() {
System.out.println("老虎叫唤...");
}
}
*/
//3. jdk底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1实例，并且把地址
// 返回给 tiger
//4. 匿名内部类使用一次，就不能再使用
IA tiger = new IA() {
@Override
public void cry() {
System.out.println("老虎叫唤...");
}
};
System.out.println("tiger的运行类型=" + tiger.getClass());
tiger.cry();
tiger.cry();
tiger.cry();
// IA tiger = new Tiger();
// tiger.cry();
}
}
interface IA {//接口
public void cry();
}
//class Tiger implements IA {
//
// @Override
// public void cry() {
// System.out.println("老虎叫唤...");
// }
//}
//class Dog implements IA{
// @Override
// public void cry() {
// System.out.println("小狗汪汪...");
// }
//}
基于类/抽象类的匿名内部类
class Outer04 { //外部类
private int n1 = 10;//属性
public void method() {//方法
//演示基于类的匿名内部类
//分析
//1. father编译类型 Father
//2. father运行类型 Outer04$2 （有{},不带{}那运行类型还是Father）
//3. 底层会创建匿名内部类
/*
class Outer04$2 extends Father{
@Override
public void test() {
System.out.println("匿名内部类重写了test方法");
}
}
*/
//4. 同时也直接返回了 匿名内部类 Outer04$2的对象
//5. 注意("jack") 参数列表会传递给 构造器
Father father = new Father("jack"){
@Override
public void test() {
System.out.println("匿名内部类重写了test方法");
}
};
System.out.println("father对象的运行类型=" + father.getClass());//Outer04$2
father.test();
//基于抽象类的匿名内部类
Animal animal = new Animal(){
@Override
void eat() {
System.out.println("小狗吃骨头...");
}
};
animal.eat();
}
}
interface IA {//接口
public void cry();
}
//class Tiger implements IA {
//
// @Override
// public void cry() {
// System.out.println("老虎叫唤...");
// }
//}
//class Dog implements IA{
// @Override
// public void cry() {
// System.out.println("小狗汪汪...");
// }
//}
class Father {//类
public Father(String name) {//构造器
System.out.println("接收到name=" + name);
}
public void test() {//方法
}
}
abstract class Animal { //抽象类
abstract void eat();
}
注意事项
匿名内部类的语法比较奇特，因为匿名内部类既是一个类的定义同时它本身也是一个对象
从语法上看,它既有定义类的精征，也有创建对象的特征，对前面代码分析可以看出这个特点,因此可以调用匿名内部类方法。
class Outer05 {
private int n1 = 99;
public void f1() {
//也可以直接调用, 匿名内部类本身也是返回对象
// class 匿名内部类 extends Person {}
new Person(){
@Override
public void hi() {
System.out.println("匿名内部类重写了 hi方法,哈哈...");
}
@Override
public void ok(String str) {
super.ok(str);
}
}.ok("jack");
}
}
class Person {//类
public void hi() {
System.out.println("Person hi()");
}
public void ok(String str) {
System.out.println("Person ok() " + str);
}
}
//抽象类/接口...
使用场景
将其当做实参直接传递
public class InnerClassExercise01 {
public static void main(String[] args) {
//把匿名内部类当做实参直接传递，简洁高效
//如果某个类只用一次，这是合理的
f1(new IL() {
@Override
public void show() {
System.out.println("这是一副名画~~...");
}
});
//传统方法，把实现了接口IL的Picture类传入f1
//缺点是需要单独再写一个Picture类
f1(new Picture());
}
//静态方法,形参是接口类型
public static void f1(IL il) {
il.show();
}
}
//接口
interface IL {
void show();
}
//类->实现IL => 编程领域 (硬编码)
class Picture implements IL {
@Override
public void show() {
System.out.println("这是一副名画XX...");
}
}
练习2
1.有一个铃声接口Bell，里面有个ring方法。
2.有一个手机类Cellphone,具有闹钟功能alarmclock,参数是Bell类型
3.测试手机类的闹钟功能,通过匿名内部类(对象)作为参数,打印:懒猪起床了
4.再传入另一个匿名内部类(对象),打印:上班了
首先，有一个铃声接口Bell和手机类Cellphone
interface Bell{//接口
void ring();//方法
}
//Cellphone通过传入的Bell接口类型完成对接口的实现
class Cellphone{
public void alarmClock(Bell bell){
bell.ring();
}
}
注意，从逻辑上来看，alarmClock只知道你传给它的是一个实现（重写）了Bell中ring()方法的类
至于具体是什么类它不关心，好，继续
在主类中这样写
public class InnerClassExercise02 {
public static void main(String[] args) {
Cellphone cellphone = new Cellphone();
cellphone.alarmClock();
}
}
创建一个Cellphone类的对象cellphone
cellphone需要一个实现了Bell接口中ring()方法的类作为输入，但是显然这个ring()我只想用一次
因此使用匿名内部类的方式实现Bell接口，重写ring()方法并传入alarmClock，如下
public class InnerClassExercise02 {
public static void main(String[] args) {
Cellphone cellphone = new Cellphone();
cellphone.alarmClock(new Bell() {
@Override
public void ring() {
System.out.println("懒猪起床了");
}
});
//同理
cellphone.alarmClock(new Bell() {
@Override
public void ring() {
System.out.println("上班了");
}
});
综上，我们达成了一个什么目的呢？
通过匿名内部类
- Cellphone甚至都不用特意去加implements来先实现接口，但却可以随时使用接口中的方法【体现多态？】
- 因为接口的实现是在匿名内部类中完成，所以可以很方便地加入不同功能
完整代码
public class InnerClassExercise02 {
public static void main(String[] args) {
Cellphone cellphone = new Cellphone();
cellphone.alarmClock(new Bell() {
@Override
public void ring() {
System.out.println("懒猪起床了");
}
});
//同理
cellphone.alarmClock(new Bell() {
@Override
public void ring() {
System.out.println("上班了");
}
});
}
}
interface Bell{//接口
void ring();//方法
}
//Cellphone通过传入的Bell接口类型完成对接口的实现
class Cellphone {
public void alarmClock(Bell bell){
bell.ring();
}
}
成员内部类
成员内部类是定义在外部类的成员位置，与定义方法的位置一样，并且没有static修饰。
特点
1.可以直接访问外部类的所有成员，包含私有的
class Outere8 {//外部类
private int n1 = 10;
public String name =“张三"";
//注意: 成员内部类，是定义在外部内的成员位置上
class Innere8 {//成员内部类
public void say() {
//可以直接访问外部类的所有成员,包含私有的
System.out.println("n1 =" +n1+ " name = " +name);
}
}
}
怎么使用呢？先写一个方法t1，在该方法中使用成员内部类，然后别处再想用这个成员内部类只需创建外部类对象，再调用该方法即可
public void t1(){
//使用成员内部类
Inner08 inner08 = new Inner08();
innere8.say();
}
然后在主类调用即可
public class MemberInnerClass01 {
public static void main(String[] args) {
Outer08 outer08 = new Outer08();
outer08.t1();
}
}
2.可以添加任意访问修饰符(public、protected、默认、private)，因为它的地
位就是一个成员。
//2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
public class Inner08 {//成员内部类
public void say() {
System.out.println("n1 = " + n1 + " name = " + name);
}
}
3.其作用域和外部类的其他成员一祥，为整个类体
比如前面案例，在外部类的成员方法中创建成员内部类对象，再调用方法。
即，Inner08在整个外部类Outere8中都可以使用
4.成员内部类---访问---->外部类成员(比如:属，性) 访问方式:直接访问
class Outer08 { //外部类
private int n1 = 10;
public String name = "张三";
private void hi() {
System.out.println("hi()方法...");
}
public class Inner08 {//成员内部类
public void say() {
//可以直接访问外部类的所有成员，包含私有的
System.out.println("n1 = " + n1 + " name = " + name);
hi();
}
}
5.外部类---访问----->内部类(说明) 访问方式:创建对象，再访问
class Outer08 { //外部类
private int n1 = 10;
public String name = "张三";
private void hi() {
System.out.println("hi()方法...");
}
public class Inner08 {//成员内部类
public void say() {
//可以直接访问外部类的所有成员，包含私有的
//如果成员内部类的成员和外部类的成员重名，会遵守就近原则.
private double sal = 99.8;
System.out.println("n1 = " + n1 + " name = " + name);
hi();
}
}
public void t1() {
//使用成员内部类
//创建成员内部类的对象，然后使用相关的方法
Inner08 inner08 = new Inner08();
inner08.say();
System.out.println(inner08.sal);
}
6.外部其他类---访问---->成员内部类
public class MemberInnerClass01 {
public static void main(String[] args) {
Outer08 outer08 = new Outer08();
outer08.t1();
//外部其他类，使用成员内部类的三种方式
// 第一种方式
// outer08.new Inner08(); 相当于把 new Inner08()当做是outer08成员，类似一个方法
// 这就是一个语法，不要特别的纠结.
Outer08.Inner08 inner08 = outer08.new Inner08();
inner08.say();
// 第二方式 在外部类中，编写一个方法，可以返回 Inner08对象
Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
inner08Instance.say();
}
}
class Outer08 { //外部类
private int n1 = 10;
public String name = "张三";
private void hi() {
System.out.println("hi()方法...");
}
public class Inner08 {//成员内部类
private double sal = 99.8;
private int n1 = 66;
public void say() {
//如果成员内部类的成员和外部类的成员重名，会遵守就近原则。
//，可以通过 外部类名.this.属性 来访问外部类的成员
System.out.println("n1 = " + n1 + " name = " + name + " 外部类的n1=" + Outer08.this.n1);
hi();
}
}
//方法，返回一个Inner08实例
public Inner08 getInner08Instance(){
return new Inner08();
}
}
静态内部类
静态内部类是定义在外部类的成员位置，并且有static修饰
class Outer10 { //外部类
private int n1 = 10;
private static String name = "张三";
static class Inner10 {
}
}
}
特点
1.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
2.可以添加任意访问修饰符(public. protected、默认、private),因为它的地位就是一个成员。
3.作用域:同其他的成员，为整个类体
...具体看代码吧
public class StaticInnerClass01 {
public static void main(String[] args) {
Outer10 outer10 = new Outer10();
outer10.m1();
//外部其他类 使用静态内部类
//方式1
//因为静态内部类，是可以通过类名直接访问(前提是满足访问权限)
Outer10.Inner10 inner10 = new Outer10.Inner10();
inner10.say();
//方式2
//编写一个方法，可以返回静态内部类的对象实例.
Outer10.Inner10 inner101 = outer10.getInner10();
System.out.println("============");
inner101.say();
Outer10.Inner10 inner10_ = Outer10.getInner10_();
System.out.println("************");
inner10_.say();
}
}
class Outer10 { //外部类
private int n1 = 10;
private static String name = "张三";
private static void cry() {}
//Inner10就是静态内部类
//1. 放在外部类的成员位置
//2. 使用static 修饰
//3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
//4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
//5. 作用域 ：同其他的成员，为整个类体
static class Inner10 {
private static String name = "jk";
public void say() {
//如果外部类和静态内部类的成员重名时，静态内部类访问的时，
//默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）
System.out.println(name + " 外部类name= " + Outer10.name);
cry();
}
}
public void m1() { //外部类---访问------>静态内部类 访问方式：创建对象，再访问
Inner10 inner10 = new Inner10();
inner10.say();
}
public Inner10 getInner10() {
return new Inner10();
}
public static Inner10 getInner10_() {
return new Inner10();
}
}
内部类练习
public class InnerClassExercise {
public static void main(String[] args) {
}
}
class Test {//外部类
public Test() {//构造器
Inner s1 = new Inner();//new一个新空间，其中a=5（默认）
s1.a = 10;//将a改为10
Inner s2 = new Inner();//new一个新空间，其中a=5（默认）
System.out.println(s2.a);//直接输出5
}
class Inner { //内部类，成员内部类
public int a = 5;
}
public static void main(String[] args) {
Test t = new Test();
Inner r = t.new Inner();//new一个新空间，其中a=5（默认）
System.out.println(r.a);//直接输出5
}
}
至此，OOP理论部分【初级-中级-高级】告一段落~~
【Java复健指南13】OOP高级04【告一段落】-四大内部类的更多相关文章
- 【Java复健指南09】项目练习全解--房屋出租系统
一个基于文本界面的综合练习,主要用于串联和回忆知识点,比较简单 各个界面的设计样式 主菜单 =============房屋出租系统菜单============ 1 新 增 房 源 2 查 找 房 屋 ...
- 【Java复健指南15】链表LinkedList及其说明
链表LinkedList by Java 之前有写过一些记录(引用),但是忘了乱了,现在重新梳理一遍 链表是Java中List接口的一种实现 定义(引用) 链表(linked list)是一种物理存储 ...
- Java工程师学习指南 初级篇
Java工程师学习指南 初级篇 最近有很多小伙伴来问我,Java小白如何入门,如何安排学习路线,每一步应该怎么走比较好.原本我以为之前的几篇文章已经可以解决大家的问题了,其实不然,因为我之前写的文章都 ...
- Java工程师学习指南 入门篇
Java工程师学习指南 入门篇 最近有很多小伙伴来问我,Java小白如何入门,如何安排学习路线,每一步应该怎么走比较好.原本我以为之前的几篇文章已经可以解决大家的问题了,其实不然,因为我之前写的文章都 ...
- Java工程师学习指南（初级篇）
Java工程师学习指南 初级篇 最近有很多小伙伴来问我,Java小白如何入门,如何安排学习路线,每一步应该怎么走比较好.原本我以为之前的几篇文章已经可以解决大家的问题了,其实不然,因为我之前写的文章都 ...
- 201521123082 《Java程序设计》第13周学习总结
201521123082 <Java程序设计>第13周学习总结 标签(空格分隔): java 1. 本周学习总结 以你喜欢的方式(思维导图.OneNote或其他)归纳总结多网络相关内容. ...
- Java工程师学习指南 完结篇
Java工程师学习指南 完结篇 先声明一点,文章里面不会详细到每一步怎么操作,只会提供大致的思路和方向,给大家以启发,如果真的要一步一步指导操作的话,那至少需要一本书的厚度啦. 因为笔者还只是一名在校 ...
- Java工程师学习指南 中级篇
Java工程师学习指南 中级篇 最近有很多小伙伴来问我,Java小白如何入门,如何安排学习路线,每一步应该怎么走比较好.原本我以为之前的几篇文章已经可以解决大家的问题了,其实不然,因为我写的文章都是站 ...
- Java基础重点指南
Java基础重点指南 每个人都有自己的学习方法,下面是我学完Java后总结的一些要点: 一:(了解)Java诞生于1995年,由Sun公司开发.它把源代码编译成“中间码”,然后通过“Java虚拟机”把 ...
- Java工程师学习指南（入门篇）
Java工程师学习指南 入门篇 最近有很多小伙伴来问我,Java小白如何入门,如何安排学习路线,每一步应该怎么走比较好.原本我以为之前的几篇文章已经可以解决大家的问题了,其实不然,因为我之前写的文章都 ...
随机推荐
- [转帖]logback：logback和slf4j中的：appender、logger、encoder、layout
(1)appender 1.appender标签是logback配置文件中重要的组件之一.在logback配置文件中使用appender标签进行定义.可 以包含0个或多个appender标签. 2.a ...
- [转帖]手把手教你在QEMU上运行RISC-V Linux
https://kernel.0voice.com/forum.php?mod=viewthread&tid=3080 嵌入式Linux内核 发布于 2023-3-15 14:44:37 ...
- Oracle Linux7 与Oracle Linux8 下载rpm包的位置
Oracle Linux 7 http://yum.oracle.com/repo/OracleLinux/OL7/latest/x86_64/index.html 索引页 http://yum.or ...
- 我在京东做研发 | 揭秘支撑京东万人规模技术人员协作的行云DevOps平台
随着业务变化的速度越来越快各类IT系统的建设也越来越复杂大规模研发团队的管理问题日益突出如何提升研发效能成为时下各类技术团队面临的重要挑战 京东云DevOps专家将带您深入研发一线揭秘支撑京东集团万人 ...
- js赋值的两种方式
第一种 let obj=[ { value:undefined } ] obj[0].value.value='zahngsan' obj[0].value.label='张三' 机智的小伙伴,可能已 ...
- es6数组方法find()、findIndex() filter()的总结
find()查找符合条件数组的元素(只能够找出第一个符合条件的) // 查找出大33的元素. // find查找第一个符合条件的数组元素(只查找出第一个 找不到返回undefined) // 它的参数 ...
- flask session 伪造
flask session 伪造 一.session的作用 由于http协议是一个无状态的协议,也就是说同一个用户第一次请求和第二次请求是完全没有关系的,但是现在的网站基本上有登录使用的功能,这就要求 ...
- 知识图谱项目实战(一)：瑞金医院MMC人工智能辅助构建知识图谱--初赛实体识别【1】
1.技术背景&赛题介绍: A Labeled Chinese Dataset for Diabetes中文糖尿病标注数据集详情请见. 数据集链接:瑞金医院MMC人工智能辅助构建知识数据源:知识 ...
- 2.1 CE修改器：精确数值扫描
本关是CE修改器的第一关,用户需要通过 Cheat Engine 工具完成精确扫描值.在这个练习中,需要将一个特定的数值(健康值)改变为 1000.首先,要确保数值类型设置正确,默认的是2字节或4字节 ...
- Libevent [补档-2023-08-29]
libevent的使用 8-1 安装 自己百度一下,安装它不是特别难,加油!!! 8-2 libevent介绍 它是一个开源库,用于处理网络和定时器等等事件.它提供了跨平台的API,能够在不同 ...