内部类


可以将一个类的定义放在另一个类的定义内部，这就是内部类。
内部类是一种非常有用的特性，因为它允许你把一些逻辑相关的类组织在一起，并控制位于内部的类的可视性。




创建内部类

创建内部类：把类的定义置于外围类的里面；

package com2001;

/**
 * Created by Panda on 2018/6/8.
 */
public class Parcel1 {
    class Contents{
        private int i=11;
        public int value(){return i;}
    }

    class Destination{
        private String label;
        public Destination(String label) {
            this.label = label;
        }
        String readLabel(){return label;}
    }

    public void ship(String dest){
        Contents contents = new Contents();
        Destination destination = new Destination(dest);
        System.out.println(destination.readLabel());
    }

    public static void main(String[] args) {
        Parcel1 parcel1=new Parcel1();
        parcel1.ship("milk");
    }
}




package com2001;

/**
 * Created by Panda on 2018/6/8.
 */
public class Parcel2 {
    class Contents{
        private int i=11;
        public int value(){return i;}
    }

    class Destination{
        private String label;
        public Destination(String label) {
            this.label = label;
        }
        String readLabel(){return label;}
    }

    public Destination to(String s){
        return new Destination(s);
    }
    public Contents contents(){
        return new Contents();
    }

    public void ship(String dest){
        Contents contents = contents();
        Destination destination =to(dest);
        System.out.println(destination.readLabel());
    }

    public static void main(String[] args) {
        Parcel2 parcel2=new Parcel2();
        parcel2.ship("milk");

        //内部类
        Parcel2 parcel21=new Parcel2();
        Parcel2.Contents contents = parcel21.contents();
        Parcel2.Destination destination = parcel21.to("milk1");
    }
}

如果想从外部类的非静态方法之外的任意位置创建某个内部类的对象，那么必须像在main（）方法中那样，具体地指明这个对象的类型：OuterClassName.InnerClassName 





链接到内部类


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




/**
 * Created by Panda on 2018/6/8.
 */
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;
    }
    public class SequenceSelector 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 SequenceSelector();
    }

    public static void main(String[] args) {
        Sequence sequence = new Sequence(10);
        for (int i = 0; i < 10; i++) {
            sequence.add(Integer.toString(i));
        }
        Selector selector = sequence.selector();
        while (!selector.end()){
            System.out.println(selector.current());
            selector.next();
        }
    }
}



内部类自动拥有对其外围类所有成员的访问权。当某个外围类的对象创建了一个内部类对象时，此内部类对象必定会秘密地捕获一个指向那个外围类对象的引用。然后，在你访问此外围类的成员时，就是用那个引用来选择外围类的成员。
内部类的对象只能与其外围类的对象相关联的情况下才能被创建。（内部类是非static类时）。构建内部类对象时，需要一个指向其外围类对象的引用。

[导读]本快速入门介绍了如何使用 Azure 门户创建并连接 MySQL 数据库。
本快速入门介绍了如何使用 Azure 门户创建并连接 MySQL 数据库。在本教程中完成的所有操作均符合 1 元试用条件。
开始之前
如果您还没有 Azure 账户，可以申请 1 元试用账户
步骤1：创建 MySQL Database on Azure
1. 登录到 Azure 门户，点击“+新建”->“Databases”->“Azure 上的 MySQL 数据库”。
2. 输入必须的参数，点击“设置第一个数据库”在将要新建的数据库服务器上新建一个数据库。
3. 点击“配置性能”，选择“MS1”性能层。
4. 等待几分钟后，数据库创建完毕，然后点击“连接安全”->“+ 添加客户端 IP”->“保存”，把当前客户端添加到白名单。
5. 打开你的 MySQL 服务器，点击“数据库”->“你的数据库”。
6. 点击“连接字符串”，查看并复制需要的连接字符串，后续步骤会用到。
步骤2：下载并安装 MySQL 客户端
1. 到下载 MySQL Workbench 页，下载安装最新版的 MySQL Workbench。
2. 安装时选择“Complete”完整安装。
步骤3：连接到 MySQL 数据库
1. 打开 MySQL Workbrench，点击“Database”->“Manage Connections…”。
2. 点击“New”，输入一个可识别的名字，以及在步骤 1 里得到的连接信息。
3. 点击“Store in Vault…”输入数据库用户对应的密码。
4. 点击“Test Connection”测试你的连接信息是否可用，如果连接成功，会出现下面的会话框。
5. 点击“Database”->“Connect to Database…”，选择刚刚保存的连接，然后点击“OK”。
6. 等待几秒钟，便可以通过 MySQL Workbench 管理数据库中的数据。

前言

内部类这个概念对新手来说应该是一个很不了解的点，有点晦涩的语法，懂了语法，又不知道在哪里用到内部类，因为不经常用，所以慢慢的就会遗忘掉。(说的就是我呀）

我最初接触内部类的概念是从某堂的培训机构的视频，然后就是几本经典的java书籍，还有Java集合库中List 和 Map实现类对内部类的使用，才感觉对内部类是有点感觉了。

我这个人记性不好，不喜欢死记硬背。但是有些知识点不背不行呀，那我就根据我自己的自身情况总结出了适何我自己的学习方法。

每隔一段时间，回头看看已经掌握的知识点，看看还不能不挖掘出新的知识来，慢慢的一系列的知识就印在脑海里了。毕竟是要敲一辈子代码的人，这就是所谓的渐进式学习吧。

看来看去，总觉得《java编程思想》对这一块讲的较深入和完整



内部类的介绍

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

内部类是一种非常有用的特性，因为它允许你把一些逻辑相关的类组织在一起，并控制位于内部的类的可视性。然而必须要了解，内部类与组合是完全不同的概念，这一点很重要。

在最初，内部类看起来就像是一种代码隐藏机制：将类置于其他类的内部。但是，你将会了解到，内部类远不止如此，它了解外围类(外部类)，并能与这通信；而且你用内部类写出的代码更加优雅而清晰，尽管并不总是这样。

最初，内部类可能看起来有些奇怪，而且要花些时间才能在设计中轻松地使用它们，对内部类的需求并非总是很明显的，但是在描述完内部类的基本语法与语义之后，使用内部类的益处显而易见了。



创建内部类

创建内部类的方式就如同你想的一样–把类的定义置于外围类的里面：



public class Parcel1 {
    class Contents{
        private int i = 11;
        public int value(){
            return i;
        }
    }

    class Destination{
        private String label;

        Destination(String whereTo) {
            label = whereTo;
        }

        String readLabel(){
            return label;
        }
    }

    public void ship(String dest) {
        Contents c = new Contents();
        Destination d = new Destination("destination");
        System.out.println(d.readLabel());
    }

    public static void main(String[] args) {
        Parcel1 p = new Parcel1();
        p.ship("Tasmania");
    }
}

当我们在ship()方法里面使用内部类的时候，与使用普通类没什么不同。在这里，实际的区别只是内部类的名字是嵌套在Parcel1里面的。不过你将会看到，这并不是唯一的区别。

更典型的情况是，外部类将有一个方法，该方法返回一个指向内部类的引用，就像在下面to()和contents()方法中看到的那样：



public class Parcel2 {
    class Contents{
        private int i = 11;
        public int value(){
            return i;
        }
    }

    class Destination {
        private String label;

        Destination(String whereTo) {
            label = whereTo;
        }

        String readLabel(){
            return label;
        }
    }

    public Destination to(String s) {
        return new Destination(s);
    }

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

    public void ship(String dest) {
        Contents c = contents();
        Destination d = to(dest);
        System.out.println(d.readLabel());
    }

    public static void main(String[] args) {
        Parcel2 p = new Parcel2();
        p.ship("Tasmania");

        Parcel2 q = new Parcel2();
        Parcel2.Contents c = q.contents();
        Parcel2.Destination d = q.to("Borneo");
    }

}

如果想从外部类的非静态方法之外的任意位置创建某个内部类的对象，那么必须像main()方法中那样，具休地指明这个对象的类型：OuterClassName.InnerClassName。

练习1:编写一个名为Outer的类，它包含一个名为Inner的类。在Outer中添加一个方法，它返回一个Inner类型的对象。在main()中，创建并初始一个指向某个Inner对象的引用。



public class Outer {
    class Inner{
    }

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

    public static void main(String[] args) {
        Outer.Inner oi = new Outer().getInner();
    }
}



链接到外部类

到目前为止，内部类似乎还只是一种名字隐藏和组织代码的模式。这些是很有用，但还不是最引人注目，它还有其的用途。当生成一个内部类的对象时，此对象与制造它的外围对象(enclosing object)之间就有了一种联系，所以它能访问其外围对象的所有成员，而不需要任何特殊的条件。此外，内部类还拥有其外围类的所有元素的访问权。下面的例子说明了这点：



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;
        }
    }

    private class SequenceSelector 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 SequenceSelector();
    }

    public static void main(String[] args) {
        Sequence sequence = new Sequence(10);
        for(int i = 0; i < 10; i++) {
            sequence.add(Integer.toString(i));
        }

        Selector selector = sequence.selector();
        while (!selector.end()) {
            System.out.print(selector.current() + " ");
            selector.next();
        }
    }

}
//输出
0 1 2 3 4 5 6 7 8 9 

Sequence类只是一个固定大小的Object的数组，以类的形式包装了起来。可以调用add()在序列末增加新的Object（只要还有空间)。要获取Sequence中的每一个对象，可以使用Selector接口。这就是“迭代器”设计模式的一个例子。Selector允许你检查序列是否到末尾了(end())，访问当前对象(current())，以及移到序列中的下一个对象(next())。因为Selector是一个接口，所以别的类可以按它们自己的方式来实现这个接口，并且另的方法能以此接口为参数，来生成更加能用的代码。

这里，SequenceSelector是提供Selector功能的private类。可以看到，在main()中创建了一个Sequence，并向其中添加了一些String对象。然后通过调用selector()获取一个Selector，并且它在Sequence 

中移动和选择每一个元素。

最初看到SequenceSelector，可能会觉得它只不过是另一个内部类罢了。但请仔细观察它，注意方法end()，current()和next()都用到了objects,这是一个引用，它并不是SequenceSelector的一部分，而是外围类中的一个private字段。然而内部类可以访问其外围类的方法和字段，就像自己拥有它们似的，这带来了很大的方便，就如前面的例子所示。

所以内部类自动拥有对其外围类所有成员的访问权。这是如何做到的呢？当某个外围类的对象创建了一个内部对象时，此内部类对象必定会秘密地捕获一个指向那个外围类对象的引用。 然后，在你访问此外围类的成员时，就是用那个引用来选择外围类的成员。幸运的是，编译器会帮助你处理所有的细节，但你现在可以看到：内部类的对象只能在与其外围类的相关联的情况下才会被创建(就像你应该看到的，在内部类是非static类时）。构建内部类对象时，需要一个指向其外围类对象的引用，如果编译器访问不到这个引用就会报错。不过绝大多数时候这都无需程序员操心



参考文献

《Java编程思想》10.1创建内部类 

《Java编程思想》10.2链接到外部类

Link to External Pages with Anchor Elements
a元素，也叫anchor（锚点）元素，既可以用来链接到外部地址实现页面跳转功能，也可以链接到当前页面的某部分实现内部导航功能。
下面是一张a元素的图示。a元素位于段落元素的中间，这意味着链接会出现在段落的中间。
这有一个例子：
<p>Here's a <a href="http://freecodecamp.cn"> link to FreeCodeCamp中文社区 </a> for you to follow.</p>
任务：创建一个链接到http://freecatphotoapp.com的a元素，并用cat photos作为其anchor text（锚点文本）。