Java基础之接口、内部类

最新推荐文章于 2018-08-22 17:36:59 发布

原创最新推荐文章于 2018-08-22 17:36:59 发布 · 350 阅读

0 ·

CC 4.0 BY-SA版权

Java基础知识专栏收录该内容

3 篇文章

订阅专栏

1.接口

必要性：如果一个类有多个直接父类，会使Java绑定规则更加复杂，所以Java禁止多继承，在继承一个类的情况下可以实现多个接口。
接口类型：描述系统对外提供的所有服务，不包括具体实现，不能被实例化。
特点：
1.接口成员变量默认都是public、static、final类型的，必须被显示初始化。
2.接口中的方法默认都是public、abstract类型的。
3.在接口中定义实例变量、非抽象的实例方法及静态方法都是非法。
4.接口中没有构造方法，不能被实例化。
5.一个接口不能实现另一个接口，但它可以继承多个接口。
比较抽象类与接口
- 相同点：
  1.代表系统的抽象层
  2.都不能被实例化
  3.都能包含抽象方法，这些抽象方法都能描述系统能够提供哪些服务，但不必提供具体的实现。
- 不同点：
  1.在抽象类中可以为部分方法提供默认的实现，而避免在子类中重复实现它们，提高代码的重用性。而接口中只能包含抽象方法。在抽象类中加入一个具体的方法，不会对它的子类造成影响，而在接口中添加抽象方法，影响所有的实现类，要么实现新增的抽象方法，要么声明为抽象类。
  2.一个类只能继承一个直接的父类，这个类有可能是抽象类；但一个类可以实现多个接口
  3.在继承树中，抽象出新的接口比抽象类容易。

2.内部类

2.1内部类的基本语法

含义：在一个类的内部定义的类，分类如下：
顶层类只能处于public和默认访问级别，而成员内部类可以处于public、protected、private和默认这4种访问级别。在另一个类访问一个类的内部类，必须使用它的完整类名。

            Outer.InnerTool tool1;
            Outer.InnerTool tool2;

内部类和外部类不重名。

2.2实例内部类

含义：内部类的一种，没有static修饰。
在创建实例内部类的实例时，外部类的实例必须已经存在。

Outer.InnerTool tool = new Outer().new InnerTool();

上面的代码等价于

Outer outer = new Outer();
Outer.InnerTool tool = outer.new InnerTool();

实例内部类的实例自动持有外部类的实例的引用。在内部类中，可以直接访问外部类的所有成员，包括成员变量和成员方法。在多重嵌套中，内部类可以访问所有外部类的成员，包括private。
一对多，一个内部类实例只会引用一个外部类的实例，而一个外部类实例对应零个或多个内部类实例。在外部类中不能直接访问内部类的成员，必须通过内部类的实例去访问。
在实例内部类中不能定义静态成员，而只能定义实例成员。
如果实例内部类和外部类包含同名成员，则表示方式如下：

public class A{
                int v = 1;
                class B{
                    int v = 2;
                    public void test(){
                       System.out.println("v="+v);
                       System.out.println("this.v="+this.v);
                   System.out.println("A.this.v="+A.this.v);
                    }
                }
            }
            public static void main(String args[]){
                new A().new B().test();
            }

2.2静态内部类

静态内部类的实例不会自动持有外部类的特定实例的引用，在创建内部类的实例时，不必创建外部类的实例。
静态内部类可以直接访问外部类的静态成员，如果访问外部类的实例成员，就必须通过外部类的实例去访问。
在静态内部类中可以定义静态成员和实例成员。
客户类可以通过完整的类名直接访问静态内部类的静态成员。

2.3局部内部类

含义：在一个方法中定义的内部类
和局部变量一样，不能用访问控制修饰符修饰。
局部内部类只能在当前方法中使用，不包含静态成员，可以访问外部类的所有成员和所在方法的final类型的参数和变量。

2.4匿名类

含义：没有名字的内部类
定义位置：外部类的方法、声明一个成员变量时

    abstract class A{
                A a = new A(){
                    void method(){
                        System.out.println("inner");
                    }
                };
                abstract void method();
            }

匿名类本身没有构造方法，但是会调用父类的构造方法，可以在匿名类中提供一段实例初始化代码。
在匿名类中使用的局部变量必须是final类型。
匿名类可以继承、实现接口

class Sample{
                public static void main(String args[]){
                    Thread t = new Thread(new Runnable(){
                        public void run(){
                            for(int i = 0;i<100;i++)
                                System.out.println(i);
                        }
                    });
                    t.start();
                }
            }

匿名类和局部类一样，可以访问外部类的所有成员。访问一个方法final类型的变量和参数。
局部类和匿名类的区别
- 匿名类的代码比较简短
- 一个局部内部类可以有多个重载构造方法，可以创建多次实例，而匿名类没有重载构造方法，只能创建一次实例。

2.5回调

含义：一个类尽管实现了某种功能，但是没有直接提供相应的接口，客户类可以通过这个类的内部类的接口来获得这种功能。内部类并没有真正的实现，仅仅调用外部类的实现。例如：

public class Sub extends Base{
                private int temperature;
                private void adjustTemperature(int temperature){
                    this.temperature = temperature;
                }
                private class Closure implements Adjustable{
                    public void adjust(int temperature){
                        adjustTemperature(temperature);
                    }
                }
                public Adjustable getCallBackReference(){
                    return new Closure();
                }
            }

Sub sub = new Sub();
Adjustable ad = sub.getCallBackReference();
ad.adjust(15);

2.6总结

这里写图片描述