《JAVA编程思想》之《内部类》笔记

最新推荐文章于 2024-09-20 15:32:13 发布
最新推荐文章于 2024-09-20 15:32:13 发布
阅读量359 收藏
点赞数 1
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013290250/article/details/77161758
版权

甩手一张思维导图

这里写图片描述

1.内部类的概述

可以将一个类的定义放在另一个类的定义内部，这就是内部类。

10.1创建内部类

  • 代码实例：
public class Outer {

   public Outer() {
        System.out.println("实例化Outer.Outer");
    }

    class Inner {
        public Inner() {
            System.out.println("实例化我的时候，同时也实例化了外围类（Outer），Inner.Inner");
        }
    }

    static class InnerStatic {

        public InnerStatic() {
            System.out.println("实例化我时，并没有实例化外围类InnerStatic.InnerStatic");
        }
    }


    public Inner inners() {
        return new Inner();
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inners = outer.inners();
        Outer.InnerStatic innerStatic = new InnerStatic();
    }
}
//打印的log日志
实例化Outer.Outer
实例化我的时候，同时也实例化了外围类（Outer），Inner.Inner
实例化我时，并没有实例化外围类InnerStatic.InnerStatic

Process finished with exit code 0

从main()方法中可以看到，从外部类（Outer）调用非静态的内部类时，必须通过外部类的引用来实例出Inner对象来。反之，静态内部类就不需要通过外部类的引用，直接就可以实例InnerStatic对象。 可以看出，静态内部类是相对于独立，非静态内部类依赖于外部类的引用。

从打印Log日志
非静态内部类，实例被创建的时候，它和外围实例之前的关联也随之被简历起来，而且，这种关联关系以后不能被修改。这种关联需要消耗非静态成员类实例的控件，并且增加了构造的时间开销。
静态成员类，它可以访问外围类的任何静态成员，包括哪些声明为私有的成员。静态成员类时外围类的一个静态成员，与其他的静态成员一样，也遵守同样的可访问性的规则。

10.2链接到外部类

interface Selector {

    boolean end();

    Object current();

    void next();

}


public class Sequence {

    private Object[] items;

    private int next = 0;

    public Sequence(int size) {
        items = new Object[size];
    }

    public void add(Object x) {
        if (next < items.length) {
            items[next++] = x;
        }
    }
//创建私有的非静态内部类，并且实现 Selector 接口
    private class SequenceSelcetor implements Selector {

        private int i = 0;

        @Override
        public boolean end() {
            return i == items.length;//这句话表达内部类可以使用外围类的所有成员
        }

        @Override
        public Object current() {
            return items[i];
        }

        @Override
        public void next() {
            if (i < items.length)
                i++;
        }
    }


    public Selector selector() {
        return new SequenceSelcetor();
    }


    public static void main(String[] args) {
    //实例创建Sequence对象
        Sequence sequence = new Sequence(10);
        for (int i = 0; i < sequence.items.length; i++) {
            sequence.add(Integer.toString(i));
        }
//通过外围类的引用，实例创建成员类Selector对象
        Selector selector = sequence.selector();
        while (!selector.end()) {
            System.out.print(selector.current() + " ");
            selector.next();
        }
    }
}

其实看上面代码，主要讲：当生成一个内部了的对象时，此对象与制造它的外围类之间就有了一种联系，所以它能访问其外围对象的所有成员，而不需要任何特殊条件。此外内部类还拥有其外围类的所有元素的访问权。

10.3 使用.this与.new

package ten;

/**
 * Created by Administrator on 2017/8/11.
 */
public class DotThis {
    void f() {
        System.out.println("f()");
    }

    public class Inner {
        public DotThis dotThis() {
            return DotThis.this;
        }

        public DotThis newDotThis() {
            return new DotThis();
        }
    }

    public Inner inner() {
        return new Inner();
    }

    public static void main(String[] args) {

        DotThis dotThis = new DotThis();
//        DotThis.Inner dot = dotThis.new Inner();
        System.out.println("dotThis = " + dotThis.toString());
        DotThis.Inner dot = dotThis.inner();
        System.out.println("dot = " + dot.toString());
        DotThis dotThis1 = dot.dotThis();
        System.out.println("dotThis1 = " + dotThis1.toString());
        DotThis newDotThis = dot.newDotThis();
        System.out.println("newDotThis = " + newDotThis.toString());

    }
}
//Log日志：
dotThis = ten.DotThis@1540e19d
dot = ten.DotThis$Inner@677327b6
dotThis1 = ten.DotThis@1540e19d
newDotThis = ten.DotThis@14ae5a5

Process finished with exit code 0

从日志可以看出，首先27行实例创建DotThis()对象，30行通过外围类DotThis() 的引用，实例成员类Inner()的对象，32行通过成员类的引用来调用内部的doThis()方法，实例外围类DotThis()对象，34行同样是，通过成员类的引用调用内部的newDoThis()方法，实例一个新的外围DotThis()对象。
1.有时候可能想要告知某些其他对像，去创建其某个内部类的对象。要实现此目的，必须在new表达式中提供对其他外部类对象的引用，就像28行那样。
2.要想创建内部类的对象，必须通过外部类的对象来创建内部类对象，同时也解决了内部类名字作用域的问题。
3.在拥有外部类对象之前是不可能创建内部类对象的，这是因为内部类对象会暗暗地连接到创建它的外部类对象上。但是，如果创建的是嵌套类（静态内部类），那么就不需要对外部类对象的引用。

10.4内部类与向上转型

  1. 介绍：当内部了向上转型为其基类，尤其是转型为一个接口的时候，内部类就有了用武之地。（从实现了某个接口的独享，得到对此接口的引用，与向上转型为这个对象的基类，实质上效果是一样的。）这好似因为此内部类——某个接口的实现——能够完全不可见，并且不肯用。所得到的只是指向基类或几口的引用。
/**
 * Created by Administrator on 2017/8/14.
 */
interface Contents {

    int value();

}

/**
 * Created by Administrator on 2017/8/14.
 */
interface Destination {

    String readLabel();

}


/**
 * Created by Administrator on 2017/8/14.
 * Parce4.class
 */
public class Parce4 {

    //定义私有的Pcontents，并实现Contents接口，只有 Parce4能够访问该类
    private class PContents implements Contents {

        private int i = 11;

        @Override
        public int value() {
            return i;
        }
    }

    //定义受保护的PDestination，并实现Destination接口，只有在同一个包类可能访问，不局限于Parce4
    protected class PDestination implements Destination {

        private String label;

        public PDestination(String label) {
            this.label = label;
        }

        @Override
        public String readLabel() {
            return label;
        }

    }

//该方法可以返回 Destination对象，或者 Destination 子类
    public Destination destination(String s) {
        return new PDestination(s);
    }

    //该方法可以返回 Contents对象，或者 Contents 子类
    public Contents contents() {
        return new PContents();
    }

}


/**
 * Created by Administrator on 2017/8/14.
 * TestParcel.class
 */
public class TestParcel {


    public static void main(String[] args) {

        Parce4 parce4 = new Parce4();

        Contents contents = parce4.contents();

        //向上转型，destination方法返回的是PDestination对象
        Destination destination = parce4.destination("testLable");

    }
}

10.5在方法和作用域内的内部类

  1. 一个定义在方法中的类
  2. 一个定义在作用域内的类，此作用域在方法的内部。
  3. 一个实现了将诶口的匿名类。
  4. 一个匿名类，它扩展了有非默认构造器的类。
  5. 一个匿名类，它执行字段初始化
  6. 一个匿名类，它通过实例初始化实现构造（匿名类不可能有构造器）

展示代码局部内部类实例：

/**
 * Created by Administrator on 2017/8/14.
 */
public class Parcel5 {

    public Destination destination(String s) {

        int i = 0;//局部变量

        //局部内部类
        class PDestination implements Destination {

            private String label;

            public PDestination(String label) {
                this.label = label;
            }

            @Override
            public String readLabel() {
                return label;
            }
        }
        return new PDestination(s);
    }


    public static void main(String[] args) {
        Parcel5 parce5 = new Parcel5();
        Destination destination = parce5.destination("testmain");
    }
}

展示作用域内嵌入类

public class Parcel5 {

    private void internalTracking(boolean b) {
        if (b) {
        //该类嵌入在if语句的作用域内， 给我的感觉，很少用
            class TrackingSlip {
                private String id;

                public TrackingSlip(String id) {
                    this.id = id;
                }

                String getSlip() {
                    return id;
                }
            }
        }
    }
}

10.6匿名内部类

匿名内部类


/**
 * Created by Administrator on 2017/8/14.
 */
public class Parcel6 {

    //1.第一种 匿名内部类
    public Contents contents() {

        return new Contents() {
            private int i = 11;

            @Override
            public Object value() {
                return i;
            }

        };

    }


    //2.第二种 创建一个实现Contents的匿名类的对象，通过new表达式返回的引用被自动想和桑转型为Contents的阴雨哦给你。
    class MyContents implements Contents {

        private int i = 12;

        @Override
        public Object value() {
            return i;
        }
    }

    public Contents contents1() {
        return new MyContents();
    }

    public static void main(String[] args) {

        Parcel6 parcel6 = new Parcel6();
        Contents contents = parcel6.contents();
        Object value = contents.value();
        System.out.println("value = " + value);
        Contents contents1 = parcel6.contents1();
    }

}
10.6.1再访工厂方法
interface Service {
    void method1();

    void method2();
}

interface ServiceFactroy {

    Service getService();
}

class Implementation1 implements Service {

    public Implementation1() {

    }

    @Override
    public void method1() {
        System.out.println("Implementation1.method1");
    }

    @Override
    public void method2() {
        System.out.println("Implementation1.method2");

    }

    public static ServiceFactroy serviceFactroy = new ServiceFactroy() {
        @Override
        public Service getService() {
            return new Implementation1();
        }
    };

}

class Implementation2 implements Service {

    public Implementation2() {
    }

    @Override
    public void method1() {
        System.out.println("Implementation2.method1");
    }

    @Override
    public void method2() {
        System.out.println("Implementation2.method2");
    }

    public static ServiceFactroy serviceFactroy = new ServiceFactroy() {
        @Override
        public Service getService() {
            return new Implementation2();
        }
    };

}


public class Factories {

    public static void serviceConsumer(ServiceFactroy factroy) {
        Service s = factroy.getService();
        s.method1();
        s.method2();
    }


    public static void main(String[] args) {
        serviceConsumer(Implementation1.serviceFactroy);
        serviceConsumer(Implementation2.serviceFactroy);
    }


}

10.7嵌套类

  • 所谓嵌套类，就是与外部类之间没有联系，并且嵌套类的声明是static。普通的内部类对象隐式地保存了一个引用，指向创建它的外围类对象。然而，当内部类是static就不是这样了。
    1. 要创建嵌套类的对象，并不需要其外围类的对象。
    2. 不能从嵌套类的对象中访问非静态的外围类对象。

嵌套类与普通的内部类还有一个区别。
- 普遍内部类的字段与方法，只能在类的外部层次上，所以普通的内部类不能有static数据和static字段，也不能包含嵌套类。
- 嵌套类可以包含所有这些东西：




/**
 * Created by Administrator on 2017/8/14.
 */
public class Parcel11 {

    //私有的ParcelContents嵌套类
    private static class ParcelContents implements Contents {

        private int i = 10;

        @Override
        public Object value() {
            return i;
        }
    }

    //私有的ParcelDestination嵌套类
    protected static class ParcelDestination implements Destination {

        private String label;

        public ParcelDestination(String label) {
            this.label = label;
        }

        @Override
        public String readLabel() {
            return label;
        }


        public static void f() {

        }

        static int x = 10;

        static class AnotherLevel {
            public static void f() {

            }

            static int x = 10;
        }
    }


    public static Destination destination(String s) {
        return new ParcelDestination(s);
    }

    public static Contents contents() {
        return new ParcelContents();
    }

    public static void main(String[] args) {

        //可以看到并没有通过外围类的引用来实例嵌套类，嵌套类是独立的。
        Contents contents = contents();

        Destination d = destination("tasmania");

    }

}
10.7.1接口内部的类

/**
 * Created by Administrator on 2017/8/9.
 */
public interface ClassInInterface {

    void howdy();

    //内部类实现外部接口，放到接口类中的任何类都自动地是public和static的
    class TestClase implements ClassInInterface {

        @Override
        public void howdy() {
            System.out.println("TestClase.howdy");
        }

        public static void testStatic(ClassInInterface classInInterface) {
            System.out.println("TestClase.testStatic");
            classInInterface.howdy();

        }

        public static void main(String[] args) {

            new TestClase().howdy();
            testStatic(new TestClase());
        }
    }
}

10.7.2从多层嵌套类中访问外部类的成员

一个内部类被嵌套多少层并不重要——它能透明地访问所有他所嵌入的外围类的所有成员

/**
 * Created by Administrator on 2017/8/14.
 */

class MNA {
    private void f() {
    }

    class A {
        private void g() {
        }

        public class B {
            void h() {
                f();
                g();
            }
        }
    }
}

public class MultiNestingAccess {

    public static void main(String[] args) {
        MNA mna = new MNA();
        MNA.A mnaa = mna.new A();
        MNA.A.B mnaab = mnaa.new B();
        mnaab.h();
    }
}

10.8为什么需要内部类

一般说来，内部类继承自某个类或实现某个接口，内部类的代码操作创建爱你它的外围类的对象。所以可以认为内部类提供了某种进入其外围类的窗口。
每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。

/**
 * Created by Administrator on 2017/8/14.
 */


public class MultiInterfaces {
    interface A {
    }

    interface B {
    }

    static class X implements A, B {
    }

    static class Y implements A {

        B makeB() {
            return new B() {
            };
        }
    }

    static void takesA(A a) {
    }

    static void takesB(B b) {
    }

    public static void main(String[] args) {
        X x = new X();
        Y y = new Y();

        takesA(x);
        takesA(y);
        takesB(x);
        takesB(y.makeB());
    }
}
怀君
关注
专栏目录
Java编程思想笔记目录
小名同学
10-24 7万+
祝各位 程序???? 节日快乐???? ![在这里插入图片描述](https://img-blog.csdnimg.cn/2020102311591445.gif#pic_center) 写在前面：   前阵子，小名“偷偷地”发了一批文章，是小名的一些读书笔记✍，那么为什么要把笔记发出来呢，嘻嘻，当然是小名的????不太灵光啦????但是吧，小名坐地铁或者走在大街上的时候，脑袋里总是会想一些有的没的，不排除会想一些Java基础的知识，时常联系不起来，就有可能别扭一整天。所以呢，把它发出来一方面是为了和大
Java 内部类学习笔记
程序员cxuan的个人主页
12-22 1336
Java 编程思想学习笔记 第十章 内部类 定义：见代码10.1-1 优点：1、封装部分代码，当你创建一个内部类的时候，该内部类默认持有外部类的引用；2、内部类具有一定的灵活性，无论外围类是否继承某个接口的实现，对于内部类都没有影响；3、内部类能够有效的解决多重继承的问题。 内部类的分类：成员内部类，局部内部类，匿名内部类，嵌套类(静态内部类) 文章标题: 10.1 如何定义内部类 如代码10....
Java编程思想笔记(七) —— 内部类
iaiti的专栏
12-14 3573
Java编程思想(七) —— 内部类
Java编程思想读书笔记（一）
doleria的专栏
01-04 1507
第1章 对象导论 1. 将类的一个对象置于某个新的类中，称为“创建一个成员对象”。 2. 使用现有的类合成新的类，称为“组合”（composition），如果组合是动态发生的，通常被称为“聚合”（aggregation）。组合经常被视为“has-a”（拥有）关系，如“汽车拥有引擎”。 3. 在Java中，动态绑定是默认行为，不需要添加额外的关键字来实现多态。 4. 在Java中，所有的类最
java编程思想读书笔记汇总
outer199
12-05 901
第七章：复用类 http://blog.csdn.net/u014115673/article/details/53350009 第八章：多态（上） http://blog.csdn.net/u014115673/article/details/53424669 第八章：多态（下） http://blog.csdn.net/u014115673/article/details/53454206 未完
Java编程思想读书笔记
瘦子没有夏天
07-19 723
一、对象导论 1.并发编程：某项任务锁定某项资源，完成其任务，然偶释放资源锁，使其他任务可以使用这项资源。 2.Java与Internet:web、web服务器、客户端编程、服务器端编程 二、一切都是对象 1.用引用操作对象 存储到什么地方： 寄存器；堆栈；堆；常量存储；非RAM存储。 2.必须有你创建所有的对象 特例：基本类型。 byte、sho...
《java编程思想》读书笔记-1
baiyen的博客
02-29 823
1. 程序可以通过添加新类型的对象使自身适用于某个特定问题。2. 万物皆可对象：对象可存储数据、可在自身执行操作； 程序是对象的集合，他们通过发送消息（方法调用请求）来告知彼此所要做的； 每个对象都有自己的由其他对象所构成的存储，即 可以通过创建包含现有对象的包的方式来创 建新类型的对象； 每个对象都拥有其类型； 某一特定类型的所有对象都可以接收同样的消息（有同样的方法）3. 对象具有状态（由对象内部数据反映）、行为（方法）、标识（每一个对象在内存中都有唯一的地址）。1.
《java编程思想》学习笔记+知识点 目录
皮皮偷偷看了你一眼, 跑了.....
07-05 244
参考：机械工业出版社《java编程思想》第四版。第18章 Java I/O 系统。第22章 图形化用户界面（略）第12章 通过异常处理错误。第17章 容器深入研究。第2章 一切都是对象。第4章 控制执行流程。第5章 初始化与清理。第6章 访问控制权限。
Java编程思想笔记
编程旅者
09-13 1351
静态（static）是指位于固定位置，也在RAM里。程序运行期间，静态存储的数据将随时等候调用。但，Java对象本身永远不会被置入静态存储空间。不允许。int x = 1;int x = 2;指一系列类，它们专门设计用来解决特定类型的问题。我们可从一个或多个类继承，并覆盖其中的部分方法。我们在覆盖方法中编写的代码用于定制由那些应用程序框架提供的常规方案，以便解决自己的实际问题。
On Java8 (java 编程思想) 笔记
sgx555的博客
07-26 759
Java 编程思想第五版（On Java 8） 前言+第一章（对象的概念） Java最核心的变化就是引入了“虚拟机”和“垃圾回收机制” Java最主要的概念之一“对象”来自smalltalk语言 组合：生命周期同步（整件删除时，部件一定会删除 ） 聚合：生命周期不同步（整件删除时，部件不一定会删除） 继承并不具有组合的特性，因为编译器对通过继承创建的类进行了限制 非OOP(Object Oriented Programming)产生的函数调用会引起所谓的早期绑定；OOP面向对象语言使
Java编程思想-笔记.docx
06-21
本笔记涵盖了Java编程思想的多个方面，包括访问权限控制、封装、继承、多态、接口、内部类、持有对象等。 访问权限控制 访问权限控制是为了把变动的事物与保持不变的事物区分开来。Java中有四种访问权限修饰词：...
Java编程思想笔记(全)
06-14
### Java编程思想笔记知识点概述 #### 第 1 章 对象导论 在这一章节中，主要介绍了Java中的基本概念——对象。对象是面向对象编程的核心，它封装了数据和行为。本章首先解释了对象的概念，接着讨论了如何创建对象...
【java编程思想第五版笔记】第八章复用（更新中）
12-21
【Java编程思想第五版笔记】第八章主要探讨的是面向对象编程中的一个重要概念——代码复用。在编程领域，代码复用是提高效率和减少错误的关键因素。本章着重比较了面向过程和面向对象两种编程范式的复用差异，并介绍...
Java-网络
2301_81543552的博客
09-14 796
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Java企业面试题3
m0_74972727的博客
09-15 836
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 812
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
JDK17新增语法特性
最新发布
2201_76124988的博客
09-20 339
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 133
faiss版本 faiss-v1.7.4。
Java编程思想：访问控制与类复用
"这是一份关于Java编程思想的学习笔记，涵盖了访问权限控制、包、接口、类的访问权限、复用类、组合与继承、protected关键字、向上转型、final关键字、类的加载、多态、接口以及内部类等多个核心概念。笔记详细阐述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

怀君

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值