接口与内部类

1.什么是接口(B)

接口是一种引用数据类型，用interface声明；当出现interface便可判断为接口。

形式：【修饰符】 interface 接口名称(public interface Pepar{ })

接口可声明属性，且属性都默认为static final

public interface Paper{
     public static final String value = "0";

}

接口也可声明方法，方法都为公共的抽象方法（以下说的接口方法都为抽象方法）；接口只定义方法不实现方法所以不存在方法体。

public interface Color{
  public void red();
}

接口不能构造方法，也不能创建对象。

一个接口可以继承多个接口，并且继承各个接口的定义的方法

public interface CInterface extends AInterface, BInterface {
      //CInterface接口拥有AIterface、BInerface接口定义的方法
}

一个类可以实现多个接口，该类称为实现类；实现一定要实现接口定义的方法。

形式：

public class ImplClassA implements AInterface,BInterface{

    @Override
    public void showInfoA() {
        System.out.println("实现接口中的showInfoA");
    }

    @Override
    public void showInfoB() {
        System.out.println("实现接口中的showInfoB");
    }
}

一个类继承父类的同时，也实现多个接口；形式：先继承，后实现。

形式：

public class ImplClass3 extends AbsClass implements AInterface,BInterface{

    @Override
    public void showInfoA() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void showInfoB() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void showInfoC() {
        // TODO Auto-generated method stub
        
    }

}

特殊情况:

如果一个抽象父类定义了和接口同名的抽象方法，实现类实现的是抽象父类的抽象方法。

package cn.interface02;

public class ImplClass4 extends AbsClass implements CInterface{

    @Override
    public void showInfoA() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void showInfoB() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void showInfoC() {
        // TODO Auto-generated method stub
        
    }

}

总结：

其实不难发现接口定义的方法与实现类实现接口定义的方法 ，与父类定义的抽象方法和子类重写父类抽象方法类似。

2.接口的应用(B)

 接口表示一种功能

接口中定义的一些系列方法表示的是一种种的能力。接口让实现类实现这些能力，实现类的能力得到拓展和升级。

实现类根据自身特性实现接口中定义的方法。

package cn.sxt.interface03;

/**
 * 驾驶接口
 */
public interface DriveInterface {
    /**
     * 驾驶的方法
     */
    public void drive();
}

package cn.sxt.interface03;

public class Student implements DriveInterface{
    ////…
    public void learn(String cName) {
        System.out.println(this.name+"正在学习"+cName);
    }

    @Override
    public void drive() {
        System.out.println(this.name+"正在驾驶...");
    }

}

package cn.sxt.interface03;

public class Teacher implements DriveInterface{
    /// …

    @Override
    public void drive() {
        System.out.println(this.name+"正在学习驾驶技术...");
        System.out.println(this.name+"很快学会了飙车...");
    }
    
}

接口的多态

一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为(方法)（功能）。

package cn.sxt.interface4;

public class Test01 {
    public static void main(String[] args) {
        
        // 同一引用类型
        USBInterface usbInterface = null;
        
        // 实例不同
        usbInterface = new USBFan();
        // 对同一方法的执行结果不同
        usbInterface.connect();

        usbInterface = new USBMouse();
        usbInterface.connect();
        
        usbInterface = new USBDisk();
        usbInterface.connect();
    }
}

总结：

接口实现多态：接口类型   引用   实现类对象

继承实现多态: 父类类型   引用  子类对象

接口定义的方法被实现类实现时，是通过引用实现类方法，调用接口方法时，执行的是实现类的方法。

接口：has is

继承: is a

3.面向接口编程(A)

接口是一种约定(协议),约定实现类具备什么功能。

接口规范了实现类具备的行为

程序中：面向接口只定义方法没有方法体，不关心实现类如何实现方法，只关心实现类具不具备接口所定义方法的能力。

package cn.sxt.interface06;

public class Writer {

    // 预留墨盒接口
    private InkBoxInterface inkBoxInterface;

    // 预留纸张接口
    private PaperInterface paperInterface;

    public InkBoxInterface getInkBoxInterface() {
        return inkBoxInterface;
    }

    public void setInkBoxInterface(InkBoxInterface inkBoxInterface) {
        this.inkBoxInterface = inkBoxInterface;
    }

    public PaperInterface getPaperInterface() {
        return paperInterface;
    }

    public void setPaperInterface(PaperInterface paperInterface) {
        this.paperInterface = paperInterface;
    }

    public Writer(InkBoxInterface inkBoxInterface, PaperInterface paperInterface) {
        super();
        this.inkBoxInterface = inkBoxInterface;
        this.paperInterface = paperInterface;
    }

    public Writer() {
        super();
    }

    public void print(String content) {
        System.out.println("打印机正在使用"+this.inkBoxInterface.getColor()+"颜色打印"+this.paperInterface.getSize()+"打印"+content);
    }
}

 抽象类和接口的异同比较 (面试常来题)

• 抽象类和接口都是引用数据类型，他们都不能创建对象。
• 他们都可以定义抽象方法，都可以实现多态。但是抽象类可以定义非抽象方法，而接口中定义的都是抽象方法。
• 抽象类和接口都具有传递性。抽象类是单根性（单继承），而接口是多继承。
• 在概念上，都可以重写抽象方法。子类重写抽象类，实现类实现接口
• 抽象类和子类解决的是模块内的问题（代码重用,重写,多态）而接口解决的是模块间的问题 => 高内聚，低耦合。接口可以用解耦模块。

4.object(B)

Object 类是所有类的根类。

如果一个类没有显示继承另外一个类，那么该类一定继承于Object。

toString() 返回对象的字符串表示形式

public class Test01 {
    public static void main(String[] args) {
        Object obj = new Object();
        // 输出对象时，默认调用toString方法
        System.out.println(obj);
        // 类型@内存地址
        System.out.println(obj.toString());
        
        
        Student s1 = new Student("二狗",20);
        System.out.println(s1);
    }
}

可以通过代码生成器快速生成toString方法。Alt+shift+s->Genrerate toString

equals(Object obj) 用于判断两个对象是否相等。

== 比较两个对象的内存地址或基本数据类型的比较，object默认equals实现比较内存地址。

equals:用于比较两个对象的内容(属性)是否相等。

当自定义对象时，要比较自定义对象是否相等，就必须通过equals方法比较两个对象属性值是否相等，那就必须重写Object的equals方法。

@Override
    public boolean equals(Object obj) {
        if(this == obj) {
            return true;
        }
        
        Student s = (Student) obj;
        if(this.sid.equals(s.sid) && this.name.equals(s.name) && this.age == s.age) {
            return true;
        }else {
            return false;
        }
    }

5.内部类(B)

在java中，一个文件可以定义多个类，文件名必须和public 类型的类的类名保持一致。这两个类是平行关系。

在java中，一个类也可以定义在一个类的内部，定义在内部的类称为内部类(inner class)，定义在外部的类称为外部类(out class).

public class Outer {
    [修饰符] class Inner{    
    }
}

编译后会出现$符outer$inner.class

成员内部

一个内部类作为一个外部类的成员而存在，此时该内部类称为外部类的成员内部类。

内部类都用默认修饰符

public class Outer {
    class Inner{    
    }
}

【1】内部创建对象

public class Test01 {
    public static void main(String[] args) {
        
        // 【1】创建外部类对象
        Outer outer = new Outer();
        // 【2】创建内部类对象
        Inner inner = outer.new Inner();
        inner.showInfo();
    }
}

【2】内部可以访问外部私有变量

public class Outer {
    
    private String name = "Outer";
    
    class Inner{
        
        public void showInfo() {
            System.out.println(name);
        }
        
    }
}

特殊情况:外部类和内部类的变量同名

public class Outer {
    
    private String name = "Outer";
    
    class Inner{
        
        private String name = "Inner";
        
        public void showInfo() {
            // String name = "show info";
            
            // 访问外部类的私有成员
            System.out.println(this.name);
            
            // 访问外部类的私有成员
            System.out.println(Outer.this.name);
            
        }
    }
}