黑马程序员---接口内部类匿名内部类总结

---------------------- Java开发、

1 接口

在Java语言中，接口有两种意思：

一是指概念性的接口，即指系统对外提供的所有服务。类的所有能被外部使用者访问的方法构成了类的接口。

二是指用interface关键字定义的实实在在的接口，也称为接口类型。它用于明确的描述系统对外提供的所有服务，它能够更加清晰的把系统的实现细节与接口分离。

接口与抽象类在表面上有点相似，接口类型与抽象类型都不能被实例化。在接口类型中声明了系统对外所能提供的服务，但是不包括具体的实现。

 

package code.javaoop; public interface Photographable {     public abstract void takePhoto(); }

 

package code.javaoop;   import static net.mindview.util.Print.print;  *   */ public class Camera implements Photographable {     public void takePhoto() {         print("Camera is taking photograph!");     }       public static void main(String[] args) {         Camera camera = new Camera();         camera.takePhoto();     } }

接口对其成员变量和方法做了许多限制，接口特征归纳如下：

(1)接口中的成员变量默认都是public、static、final类型的，必须被显示初始化。

 

(2)接口中的方法默认都是public、abstract类型的。

(3)接口中只能包含public、static、final类型的成员变量和public、abstract类型的成员方法。

(4)接口中没有构造方法，不能被实例化。在接口中定义构造方法时非法的。

(5)一个接口不能实现另一个接口，但它可以继承多个接口。

(6)接口必须通过类来实现它的抽象方法。与子类继承父类很相似，当类实现了某个接口时，他必须实现接口中所有的抽象方法，否则这个类必须被定义为抽象类。

(7)一个类只能继承一个直接的父类，但能实现多个接口。

package code.javaoop;   public interface InterfaceBaseOne {     public abstract void methodOne(); }   package code.javaoop;   public interface InterfaceBaseTwo {     public abstract void methodTwo(); }   package code.javaoop;   public interface InterfaceSub extends InterfaceBaseOne, InterfaceBaseTwo {     public abstract void methodThree(); }

 

package code.javaoop;   import static net.mindview.util.Print.print; public class ClassSub implements InterfaceSub {     public void methodThree() {         print("This is the methodThree");     }       public void methodOne() {         print("This is the methodOne");     }       public void methodTwo() {       } }

 

package code.javaoop;   import static net.mindview.util.Print.print; public abstract class ClassSub implements InterfaceSub {     public void methodThree() {         print("This is the methodThree");     }       public void methodOne() {         print("This is the methodOne");     } }

 

2 内部类

在一个类的内部定义的类称为内部类。内部类允许把一些逻辑相关的类组织在一起。学会使用内部类是掌握Java高级编程的一部分。

成员内部类可以处于public、protected、private和默认这4种访问级别。内部类分为:实例内部类，静态内部类，局部内部类。

class  Outer { public class InnerTool { public int add(int a, int b) { return a + b; } } private InnerTool tool = ew InnerTool(); public void add(int a, int b, int c) { tool.add(tool.add(a, b), c); } }   public class Test { public static void main(String[] args) { Outer o = new Outer(); o.add(1, 2, 3,); Outer.InnerTool tool = new Outer().new InnerTool(); } }

 

 

2.1 实例内部类

(1) 在创建实例内部类的实例时，外部类的实例必须已经存在。

(2) 实例内部类会自动持有外部类的实例的引用。在内部类中，可以直接访问外部类的所有成员，包括成员变量和成员方法。

package code.javaoop;   import static net.mindview.util.Print.print; public class OuterOne {     private int a1; public int a2; static int a3;       public OuterOne(int a1, int a2) { this.a1 = a1; this.a2 = a2; }   protected int methodA() { return a1*a2; }   class Inner {                       //定义内部类 int b1 = a1;                    //直接访问private修饰的a1 int b2 = a2;                    //直接访问public修饰的a2 int b3 = a3;                    //直接访问一个static修饰的a3 int b4 = new OuterOne(3,4).a1;  //访问一个新建的外部类的实例的a1 int b5 = methodA();              //直接访问methodA()方法 }   public static void main(String[] args) { OuterOne.Inner b = new OuterOne(1, 2).new Inner();           /*OuterOne  outerOne = new OuterOne(1, 2);         OuterOne.Inner b = outerOne.new Inner();*/           print("b.b1=" + b.b1);         print("b.b2=" + b.b2);         print("b.b3=" + b.b3);         print("b.b4=" + b.b4);         print("b.b5=" + b.b5);   } }

(3)外部类实例与内部类实例之间是一对多的关系，一个内部类实例只会引用一个外部类实例，而一个外部类实例对应零个或多个内部类实例。在外部类中不能之间访问内部类的成员。

package code.javaoop; public class OuterTwo {     class InnerTwo { private int b1 = 1; public int b2 = 2;          class C{} }   public void test() { /*int v1 = b1; int v2 = b2; InnerTwo.C c1 = new C();*/   InnerTwo b = new InnerTwo(); int v3 = b.b1; int v4 = b.b2; InnerTwo.C c2 = b.new C(); InnerTwo.C c3 = new InnerTwo().new C(); } }

(4)在实例内部类中不能定义静态成员，而只能定义实例成员。

public class OuterTwo {          class InnerTwo { static private int b1 = 1;   //非法！ public int b2 = 2;   class C{} }   public void test() { /*int v1 = b1; int v2 = b2; InnerTwo.C c1 = new C();*/   InnerTwo b = new InnerTwo(); int v3 = b.b1; int v4 = b.b2; InnerTwo.C c2 = b.new C(); InnerTwo.C c3 = new InnerTwo().new C(); } }

 

(5)如果实例内部类B与外部类A包含同名的成员(比如成员变量v)，那么在类B中，this.v表示类B的成员，A.this.v表示类A的成员。

package code.javaoop; import static net.mindview.util.Print.print; public class OuterThree {     int v = 1;       class InnerThree {         int v = 2;           public void test() {             print("v = " + v);             print("this.v = " + this.v);             print("OuterThree.this.v = " + OuterThree.this.v);         }     }       public static void main(String[] args) {         new OuterThree().new InnerThree().test();     } }

 

2.2 静态内部类

(1)静态内部类的实例不会自动持有外部类的特定实例的引用，在创建内部类的实例时，不必创建外部类的实例。

class A { public static class B { int v } }   class Tester { public void test() { A.B b = new A.B(); b.v = 1; } }

(2)静态内部类可以直接访问外部类的静态成员，如果访问外部类的实例成员，就必须通过外部类的实例去访问。

class A { private int a1; private static int a2; public static class B { int b1 = a1; //编译错误 int b2 = a2; int b3 = new A().a1; } }

(3)在静态内部类中可以定义静态成员和实例成员。

(4)客户类可以通过完整的类名直接访问静态内部类的静态成员。

3.4.3 局部内部类

局部内部类是在一个方法中定义的内部类，它的可见范围是当前方法。和局部变量一样，局部内部类不能用访问控制符(public private protected)及static修饰。

3 枚举类

在某些情况下，一个类的对象是有限而且固定的，例如季节类，它只有四个对象。

这种实例有限而且固定的类，在Java中被称为枚举类。

3.1 手动实现枚举类

l 通过private将构造器隐藏起来。

l 把这个类的所有可能实例都使用public static final属性来保存。

l 如果有必要，可以提供一些静态方法，允许其他程序根据特定参数来获取与之匹配的实例。

package code.crazylesson; public class Season {     private final String name;     private final String desc;       private static final Season SPRING = new Season("Spring", "The season is spring.");     private static final Season SUMMER = new Season("Summer", "The season is summer.");     private static final Season AUTUMN = new Season("Autumn", "The season is autumn.");     private static final Season WINTER = new Season("Winter", "The season is winter.");       public static Season getSeason(int seasonNum) {         switch(seasonNum) {             case 1: return SPRING;             case 2: return SUMMER;             case 3: return AUTUMN;             case 4: return WINTER;             default: return null;         }     }       private Season(String name, String desc) {         this.name = name;         this.desc = desc;     }       public String getName() {         return name;     }       public String getDesc() {         return desc;     } }

 

3.2 枚举类必知

J2SE1.5引入了一个enum关键字，用以定义枚举类。枚举类是一种特殊的类型，它一样可以有自己的方法和属性，可以实现一个或多个接口，也可以定义自己的构造器。一个Java源文件只能定义一个public的枚举类，且该Java源文件也必须和该枚举类的类名同名。

枚举类可以实现一个或多个接口，使用enum定义的枚举类默认继承了java.lang.Enum类，而不是Object类。其中java.lang.Enum实现了java.lang.Serializable和java.lang.Comparable两个接口。

枚举类的构造器只能使用private，如果省略，则默认的使用private修饰，如果要指定则只能指定private。

枚举类的所有实例必须在枚举类中显示列出，否则这个枚举类永远不会产生实例。列出  实例时，系统会自动添加public static final修饰，无需程序员显示添加。

所有枚举类都提供了一个values方法，该方法可以很方便地遍历的、所有的枚举值。

---------------------- Java开发、Android培训、期待与您交流！ ----------------------详细请查看：www.itheima.com