c++接口调用外部类_第十四天（接口和内部类）

接口(interface)：

接口里不能写构造方法(接口不是类，没有无参的构造方法)。

接口不是一种特殊的抽象类。

接口中所有属性和方法都是public的。

接口定义的属性(默认三顶帽子)：

1. public：共有的

2. static：静态的放在方法区的静态数据区

3. final：意味着只能显示的初始化

例：

//public final static int MIN_BRIGHTNESS = 10;

int MIN_BRIGHTNESS=0;//显示初始化

接口定义的方法(默认两顶帽子)：

1. public：共有的

2. abstract：抽象的

例

//public abstract void turnOn();

//public abstract void turnOff();

   void turnOn();

   void turnOff();

接口的继承问题：

分析接口继承问题的时候，考虑思想和类一样的。  

• 一个子接口可以继承多个接口；

• 若一个子接口实现的两个接口中有相同的属性和方法，则使用第一个接口的属性和方法。

• 若一个类实现的两个接口中有相同的属性和方法，该类使用内部类分别实现。

代码：

interface if1{   public int i = 10;   void fun1();}class TestIf1 implements if1{    public void fun1(){        System.out.println("TestIf1");//实现：类对其实现接口的重写叫实现    }    public void fun2(){        System.out.println("fun2");//父类接口引用变量不能访问实现其类新增加的方法    }}public class TestT{         public static void main(String[] args){      System.out.println("if1.i = " + if1.i);//10        System.out.println("TestIf1.i = " + TestIf1.i);//10     if1 t = new TestIf1();//接口的回调：接口引用变量指向实现其类的对象         t.fun1();         //t.fun2();                  if(t instanceof TestIf1){//造型            TestIf1 tt = (TestIf1)t;             tt.fun2();             System.out.println("t instanceof TestIf1");         }                      }}

内存图：

接口的语义：

一个类实现了一个接口，就是按照接口的功能规范实现类里面的代码。

优点：便于管理，降低耦合

java面向接口编程思想：

   不同的数据库在业务层对于同一个业务的操作，代码是不一样的，这就导致了用起来的时候非常的麻烦，这个时候java的面向接口编程的思想就出现了。提供一个通用接口，每一个不同的数据库都继承这个接口，然后实现它的方法。所以，对于同一个业务的操作，对于不同的数据库，就不用去每次都写代码实现之。只需要实现这个通用接口提供的方法即可。

JDK1.8中接口用static以及default修饰的方法有默认实现。

接口的实现：

• 多个无关的类可以实现同一个接口；

• 一个类可以实现多个接口；

• 类中对接口方法的重写叫实现。

抽象类和接口的区别：

 不同点：

• 抽象类有构造方法，接口没有；

• 抽象类可以有具体的方法 和属性, 接口只能有抽象方法和不可变常量，;

• 接口可以多继承，类只可以单继承；

• 接口的成员中有默认修饰符，接口中的属性默认public static final，方法默认public abstract，类中没有；

• 接口中只能有抽象方法，抽象类中可以有普通方法；

相同点：

• 都不能创建对象；

• 都可以定义抽象方法；

• 一个实现类实现接口时需要重写接口中的所有抽象方法，一个类继承抽象类时也需要重写抽象类中的所有抽象方法；

内部类：

实例内部类(重)：

n允许一个类的定义出现在另一个类中，将处于另一个类中的“寄生类”称为“内部类”(inner class)，也称为“类属类”

n这样的一组类在逻辑上是一个整体，内部类和外层封装它的类之间存在逻辑上的从属关系

n内部类对其封装类的内部成员有访问权限(包括private)

内部类对象自动拥有对外部类对象的引用。

有内部类之前先要有外部类。

• 类的名字只能在定义的范围内使用，除非使用有效的全名

• Inner类也可以定义在方法的内部。方法中final类型的局部变量，都可以被Inner类的方法访问。

内部类特性：

• Inner class可以声明为抽象类 ，因此可以被其它的内部类继承。也可以声明为final的。

• 和外层类不同，Inner class可以声明为private或protected；

• Inner class 可以声明为static的，但此时就不能再使用外层封装类的非static的成员变量；

• 非static的内部类中的成员不能声明为static的，只有在顶层类或static的内部类中才可声明static成员

class Outer1 {  private int size=3;  /* 定义一个内部类，名为 "Inner" */  public class Inner {         int size=10;    public void doStuff() {      // 内部类可以访问外部类的私有属性       size++;    }    public int getOuterSize()    {   return  size;      //return  Outer1.this.size;          //返回外部类对象的size。    }  }  public void testTheInner() {//容易产生内存泄漏    Inner i = this.new Inner();//这个非常重要，外部类对象.new 内部类()；    i.doStuff();  }}public class TestInner{    public static void main(String[] args)    {   Outer1 a1 = new Outer1();        Outer1.Inner oi =a1.new Inner();        //创建内部类对象，自动拥有对外部类对象 的引用。        oi.doStuff();        System.out.println(oi.getOuterSize());        a1.testTheInner();    System.out.println(oi.getOuterSize());  }    }

内存图：

方法内部类(不怎么重要，面试)：

局部内部类创建对象的时候也是自动拥有外部类对象的引用。

public class Outer{   private int a1=0;    public void test(final int i)    {       final int a=3;        /******************************/        class LocalClass        {    int a=5;            public void localTest()            {                System.out.println("局部内部类的方法被调用");                System.out.println("i="+i);//1                System.out.println("a="+a);//5                System.out.println("a1="+a1);//0                System.out.println("Outer.this.a1="+Outer.this.a1);//0      }        }        /******************************/        LocalClass lc = new LocalClass();        lc.localTest();    }        public static void main(String[] args)    {        Outer o = new Outer();        o.test(1);    }    }//考虑这种问题的方式还是和之前是一样的，如果内部类本身有这个属性//首先访问的就是这个属性，没有的或者找不到的时候访问的才是父类的属性。

定义的类本身就是一个外部类的一个成员变量。

加油，年轻人！！！