学习 Java编程思想 Thinking in Java 第十章：内部类

最新推荐文章于 2020-06-08 16:17:26 发布
最新推荐文章于 2020-06-08 16:17:26 发布
阅读量241 收藏
点赞数
分类专栏： Java
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/qq_28082757/article/details/83986538
版权

前言

在读 《Java编程思想 Thinking in Java》 这本书的时候，会有很多示例代码。为了巩固和实践，所以将书上的代码都写上一遍

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

先写个接口Destination：

package com.innerClass;

public interface Destination {
    String readLabel();
}

接下来就写，在方法的作用域中创建一个完整的类。这被叫做局部内部类！！！

package com.innerClass;

public class Parcel5 {
    public Destination destination(String s){
        class PDestination implements  Destination{
            private String label;
            private PDestination(String whereTo){
                label = whereTo;
            }
            public String readLabel(){
                return label;
            }
        }
        return  new PDestination(s);
    }

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

下面展示，如何在任意作用域内嵌入一个内部类：

package com.innerClass;

public class Parcel6 {
    private void internalTracking(boolean b){
        if(b){
            class TrackingSlip{
                private String id;
                TrackingSlip(String s){
                    id = s;
                }
                String getSlip(){
                    return id;
                }
            }
            TrackingSlip ts = new TrackingSlip("slip");
            String s = ts.getSlip();
        }
        //试想一下上面这两句话，写到这里可不可以呢？
    }
    public void track(){
        internalTracking(true);
    }
    public static void main(String[] args) {
        Parcel6 p = new Parcel6();
        p.track();;
    }
}

回答代码中的问题，答案是不可以哦，因为那里是 if的作用域外，超出了TrackingSlip的作用域了！

10.6 匿名内部类

先写个接口，做铺垫啊

package com.innerClass;

public interface Contents {
    int value();
}

马上写一个匿名内部类啊

package com.innerClass;

public class Parcel7 {
    public Contents contents(){
        return new Contents() {
            private int i = 11;
            @Override
            public int value() {
                return i;
            }
        };
    }

    public static void main(String[] args) {
        Parcel7 p = new Parcel7();
        Contents c = p.contents();
    }
}

在contents方法中，return的那个类，没有名字，看吧，是不是很奇怪。
在return一个new的Contents的时候，仿佛听见一个声音，说：“等等，我想在这里插入一个内的定义”。结果就成这个样子了。
这就是匿名内部类啊！！！
对这个奇怪的语法正儿八经的总结一下就是：“创建一个继承自Contents的匿名内部类的对象。通过new表达式返回的引用被自动向上转型为对Contents的引用。”

上述匿名内部类的语法是下述形式的简化形式：

package com.innerClass;

public class Parcel7b {
    class MyContents implements Contents{
        private int i = 11;
        @Override
        public int value() {
            return i;
        }
    }
    public Contents contents(){
        return new MyContents();
    }
    public static void main(String[] args) {
        Parcel7b p = new Parcel7b();
        Contents c = p.contents();
    }
}

有没有觉得第一种书写方式更装逼一点呢！

咦？咦咦咦？
我发现上面那个匿名内部类使用了默认构造器来生成Contents，但是如果基类需要一个有参数的构造器，就像下面这样，改怎么办呢？

package com.innerClass;

public class Parcel8 {
    public Wrapping wrapping(int x){
        return new Wrapping(x){
            @Override
            public int value() {
                return super.value() * 47;
            }
        };
    }
    public static void main(String[] args) {
        Parcel8 p = new Parcel8();
        Wrapping w = p.wrapping(10);
    }
}

Wrapping这个类我该怎样写，才能正确的被Parcel8使用呢？
很简单！只需要传递合适的参数给基类的构造器即可，就像这样：

package com.innerClass;

public class Wrapping {
    private int i;
    public Wrapping(int x){
        i = x;
    }
    public int value(){
        return i;
    }
}

虽然Wrapping只是一个具有具体实现的普通类，但还是被其导出类当作公共“接口”来使用！

如果在匿名类中定义字段时，还要对其执行初始化操作，该咋写呢？就该像下面这样写呀：

package com.innerClass;

public class Parcel9 {
    public Destination destination(final String dest){
        return new Destination() {
            private String label = dest;
            @Override
            public String readLabel() {
                return label;
            }
        };
    }
    public static void main(String[] args) {
        Parcel9 p = new Parcel9();
        Destination d = p.destination("Tasmania");
    }
}

注意到了吗？用到了关键字final哦，如果定义一个匿名内部类，并且希望它使用一个在其外部定义的对象时，那么编译器就会要求其参数是final的。

实现一个为匿名内部类创建一个构造器的效果:

package com.innerClass;

public abstract class Base {
    public Base(int i){
        System.out.println("Base constructor, i = "+i);
    }
    public abstract void f();
}

package com.innerClass;

import com.sun.org.apache.xpath.internal.SourceTree;

public class AnonymousConstructor {
    public static Base getBase(int i){
        return new Base(i) {
            @Override
            public void f() {}
        };
    }
    public static void main(String[] args) {
        Base base = getBase(47);
        base.f();
    }
}

这个例子中呢，变量i，不要求是final的。因为 i 被传递给匿名类的基类的构造器，并没有在匿名类内部直接使用。

带实例初始化的“parcel”形式。

package com.innerClass;

public class Parcel10 {
    public Destination destination(final String dest, final float price){
        return new Destination() {
            private int cost;
            {
                cost = Math.round(price);
                if(cost > 100){
                    System.out.println("Over budget");
                }
            }
            private String label = dest;
            @Override
            public String readLabel() {
                return label;
            }
        };
    }
    public static void main(String[] args) {
        Parcel10 p = new Parcel10();
        Destination d = p.destination("Tasmania", 101.395F);
    }
}

10.6.1 再访工厂方法
使用匿名内部类改造 interfaces/Factories.java 示例：

package com.innerClass;

public interface Service {
    void method1();
    void method2();
}

package com.innerClass;

public interface ServiceFactory {
    Service getService();
}

package com.innerClass;

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

    @Override
    public void method2() {
        System.out.println("Implementation1 method2");
    }
    public static ServiceFactory factory = new ServiceFactory() {
        @Override
        public Service getService() {
            return new Implementation1();
        }
    };
}

package com.innerClass;


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

    @Override
    public void method2() {
        System.out.println("Implementation2 method2");
    }
    public static ServiceFactory factory = new ServiceFactory() {
        @Override
        public Service getService() {
            return new Implementation2();
        }
    };
}

package com.innerClass;

public class Factories {
    public static void serviceConsumer(ServiceFactory fact){
        Service s = fact.getService();
        s.method1();
        s.method2();
    }

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

改造 interfaces/Games.java 示例：

package com.innerClass.games;

public interface Game {
    boolean move();
}

package com.innerClass.games;

public interface GameFactory {
    Game getGame();
}

package com.innerClass.games;

public class Checkers implements Game{
    private Checkers(){}
    private int moves = 0;
    private static final int MOVES = 3;

    @Override
    public boolean move() {
        System.out.println("Checkers move " + moves);
        return ++moves != MOVES;
    }
    public static GameFactory factory = new GameFactory() {
        @Override
        public Game getGame() {
            return new Checkers();
        }
    };
}

package com.innerClass.games;

public class Chess implements Game{
    private Chess(){}
    private int moves = 0;
    private static final int MOVES = 4;
    @Override
    public boolean move() {
        System.out.println("Chess move "+ moves);
        return ++moves != MOVES;
    }
    public static GameFactory factory = new GameFactory() {
        @Override
        public Game getGame() {
            return new Chess();
        }
    };
}

package com.innerClass.games;

public class games {
    public static void playGame(GameFactory factory){
        Game s = factory.getGame();
        while (s.move()){
            ;
        }
    }

    public static void main(String[] args) {
        playGame(Checkers.factory);
        playGame(Chess.factory);
    }
}

10.7 嵌套类

如果不需要内部类对象与外围对象之间有联系，那么可以讲内部类声明成static。这就被称为：嵌套类。
要想理解static应用于内部内时的含义，就必须必须必须的记住一点：普通内部类对象其实隐式的保存了一个引用，这个引用只想它外围的对象。
上菜：

package com.innerClass;

public class Parcel11 {
    private static class ParcelContents implements  Contents{
        private int i = 1;
        @Override
        public int value() {
            return i;
        }
        protected static class ParcelDestination implements  Destination{
            private String label;
            private ParcelDestination(String whereTo){
                label = whereTo;
            }
            @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 c = contents();
            Destination d = destination("Tasmania");
        }
    }
}

在main()中，没有用到Parcel11对象就可以直接使用static修饰的内部类啦，也就是嵌套类。

10.7.1 接口内部的类
这就厉害了，就像下面这样：

package com.innerClass;

public interface ClassInInterface {
    void howdy();
    class Test implements ClassInInterface{
        @Override
        public void howdy() {
            System.out.println("Howdy");
        }
        public static void main(String[] args) {
            new Test().howdy();
        }
    }
}

————————————————————————————
技术无他，唯有熟尔。
知其然，也知其所以然。
踏实一些，不要着急，你想要的岁月都会给你。

江湖人称小程
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java编程思想 Thinking in Java 课后习题答案
05-21
Java编程思想 Thinking in Java 课后习题答案 很好 齐全
java 第10章_（Thinking in Java）第10章 内部类
weixin_35903223的博客
03-07 96
Thinking in Java捞干货，写笔记一、成员内部类1.最基本使用public class Demo {class Contents{private int i=11;public int value(){return i;}}class Destination{private String label;Destination(String whereTo){label=whereTo;}...
《 Thinking in Java 》第十章 内部类
努力奋斗
10-01 395
可以将一个类的定义放在另一个类的定义内部，这就是内部类 内部类与组合是完全不同的概念。 内部类看起来像是一种代码隐藏机制，但是它还了解外围类，并能与之通信； 更优雅！！！ 创建内部类 很简单——把类的定义置于外围类的里面： public class A { class InnerA { } public InnerA getInnerA() { return new InnerA()...
Thinking in Java：第十章-内部类
ivalue的博客
12-21 186
1：内部类是一种非常有用的特性，因为它允许你把一些逻辑相关的类组织在一起。并控制位于内部的类的可视性。 2：如果想从外部类的非静态方法之外的任意位置创建某个内部类的对象，那么必须具体的指明这个对象的类型：OutClass.InnerClass。当生成一个内部类对象时，此对象与制造它的外围对象之间就有了一种联系，所以它能访问其外围对象的所有成员。 3：每个内部类都可以独立的继承一个（接口的）实习
Thinking in java 第10章 内部类 笔记+习题
soyamilk233的博客
06-08 550
Thinking in java 第10章 内部类 学习目录 10.1 创建内部类 1. 外部类可以用一个方法返回一个指向内部类的引用。 2. 内部类对象的类型：OuterClassName.InnerClassName 10.2 链接到外部类 1. 当生成一个内部类的对象时，此对象与制造它的外围对象之间就有了一种联系，所以它能访问其外围成员，而不需要任何特殊条件。 2. 例P192。以迭代器设计模式为例。 3. 内部类自动拥有对其外围类所有成员的访问权。当某个外围类的对象创建了一个内.
thinking-in-java-zh:Java 编程思想
05-14
Thinking in Java (Java 编程思想) 原书： 作者： 原始中文版： 译者： 修订： 整理： 注 我们没有翻译第五版（On Java 8）的计划，请访问 。
thinking_in_java_answer.rar_Thinking in Java_java 编程思想_java编程思想
09-14
《java编程思想》里的练习答案，大家可以参考一下。
Thinking In Java 4th<Java编程思想4>
09-27
英文原版Java编程思想； 非中文版，英文好的朋友可以下载阅读；
Thinking.in.Java_java编程思想_taught3xd_
10-02
java编程思想，适合初级学习java的程序员
think in java 内部类读后感，加网上参考整理
awe5566的专栏
08-25 813
一直对java中内部类的概念，很模糊，不明白为什么java 要设计内部类这么一个概念，在看think in java的时候，才有了点豁然开朗的感觉。 个人理解的内部类： 1，内部类通过与private结合，可以很好的隐藏具体一个类内部的具体实现，完成封装。 2.外部类的方法可以返回一个内部类的引用，此内部类被定义为私有，即外部不可见，可以摆脱依赖类来编程，可以增加很多的控制。
Thinking in Java---内部类及一个迭代器实例
荒野孤鹰
06-01 1372
可以将一个类的定义放在另一个类的定义内部,这就是内部类. 内部类的定义是简单的,但是它的语法确实很是复杂,让人不是很好理解.下面就内部类做一个小结. 一.内部类的分类 总的来讲内部类分为普通内部类,匿名内部类,局部内部类,嵌套类(静态内部类)等.下面简要的介绍以下这些内部类定义的语法. (1).对于普通的内部类,就是在外围类中插入另一个类的定义.如下面的代码:package lk
THINKING IN JAVA 读书笔记——内部类
hanpannju的专栏
03-24 615
1 为什么要使用内部类？        每个内部类都能独立地继承自一个实现，无论外围类是否继承了某个实现，对于内部类都没有影响。内部类使得多重继承的解决方案变得完整，接口解决了部分问题，而内部类有效地实现了“多重继承”。 2.创建一个内部类      如果想从外部类的非静态方法之外的任意位置创建某个内部类对象，必须具体指明这个对象的类型：OuterClassName.Inn
（Thinking in Java）内部类的简单使用
dominic_z的博客
04-27 272
内部类的简单使用
第10章 内部类
shenxingbo的专栏
08-25 160
内部类感觉就像是一种代码的隐藏机制。内部类了解外部类，并且能与之通信。
[Thinking in JAVA] 接口和内部类
沈鸿斌的博客
03-17 858
1.接口是public的，即使不声明，也默认是public。接口中的方法也必须是public。 2.在无法修改想要使用的类时，可以使用适配器模式。适配器接受你所拥有的接口，并产生你所需要的接口。    Thinking in JAVA P177的例子。    有两个类，Processor和Apply， Apply中用到Processor对象。现在有一个类Filter,有跟Proces
Think in java: 什么是java内部类(1)
Einskai216的博客
05-27 150
内部类是什么 类中定义的类（隐藏名字） 仅对包含该内部类的’外部类’可见 静态方法必须通过外部类.内部类的方式来调用 （是因为没有this指针？） 外部类能够访问内部类的一切对象，包括private 链接到外部类 内部类能访问所有制造它的外围对象的成员 引出设计模式之一：迭代器模式，将某个数组以类的形式包装起来，并设计诸如add(). next(), end()等方法的形式对数组进行修改与访问的操作： interface Selector{ boolean end(); Object c
Thinking in Java 系列 ---（八）内部类
Charles Ren's Tech Blog
05-30 443
文章目录Inner class 内部类创建内部类对象使用.this 和 .new 关键字局部内部类匿名内部类实例1：不使用匿名内部类实例2：匿名内部类的基本实现实例3：匿名内部类用于接口上实例4：Thread类的匿名内部类实现实例5：Runnable接口的匿名内部类实现 Inner class 内部类 内部类可以有四种访问权限。 内部类可以使用它所在类内范围的所有变量，包括private。 可以在...
think in java第十章内部类 总结随笔
The_flying_pig的博客
08-15 423
1.内部类的基本介绍 可以将一个类的定义放在另一个类的定义内部，这就是内部类（引用书中的第一句的介绍）。 public class Test { String str; public Test() { str = "汪汪"; } class Bird{ public void Voice(){ System.out.println("吱吱"); } } } B
thinking in java 学习笔记
最新发布
01-08
《Thinking in Java》是一本经典的Java编程入门教材，通过阅读该书可以系统地学习Java编程的基础知识和高级概念。阅读过程中，我结合自己的学习体验和实践，进行了详细的学习笔记。 首先，该书从基础语法开始介绍，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值