abstract、接口、接口匿名实现类、内部类

abstract

• 抽象类可以有构造器，便于子类调用
• 抽象类：不能实例化。例如

//按照原始的写法，定义一个类
public class Person{
      String name;
      int age;
      public Person(){ //构造方法
      }
}
//对该类实例化操作
Person person = new Person(); //该实例化可以操作
//下面定义一个 抽象类：含有abstract的关键字
public abstract class Person{
      String name;
      int age;
      public Person(){ //构造方法
      }
}
//对该抽象类进行实例化
Person person = new Person(); //error.即不允许实例化

• 抽象方法：
  ①包含抽象方法的类一定是个抽象类。
  ②抽象类不一定含有抽象方法。如上一个例子就没有抽象方法

//抽象类
abstract class Person{
    String name;
    int age;
    public Person(){

    }
    abstract void eat(); //抽象方法，只有方法名，没有方法体
}
//现在编写一个子类让他继承Person类。
//对于子类有两种处理方式：
//    ①让子类继承超类所有抽象方法
//    ②子类也是个抽象类
//     例子如下：
//①子类继承超类所有抽象方法
class Student extends Person {

    @Override
    void eat() {
        
    }
}
//②子类也是个抽象类
abstract class Student extends Person {
    
}

//abstract 不能修饰私有、静态、final方法、final的类

abstract不能被static,final,private修饰
非抽象子类继承抽象类，要重写所有的抽象方法
①被final修饰的方法不能被重写
②被private修饰的方法只能本类使用
③被static修饰的方法并不能被重写
Java是单继承，不能多继承，所以引出接口的概念

接口

• 接口所有方法必须是public abstract，可省略。但是在实现接口时，方法的修饰符必须是public的，不能省略。

//定义一个接口
interface Fly{
    public abstract void eat(); //标准写法
    void work(); //省略了public abstract
}

• 接口不能含有构造器，接口不能含有实例域，接口也不能实例化
• 接口中可以含有常量，格式是public static final int x;其中public static final可以省略

//定义一个接口
interface Fly{
      //接口中 常量必须 初始化，且初始化后不可修改
    //int NUM_A = 3;   //可以省略public static final
    public static final int NUM_A = 3; //标准写法
}

• 接口与接口之间可以多继承

interface A{
    
}
interface B{
    
}
interface C extends A,B{
    
}

• 接口的匿名实现类

  //定义USB接口
 interface USB{
      void inputInofo();
      void outputInfo();
  }
  //USB接口的实现类
  class Computer implements USB{
  
      public void inputInofo() {
         System.out.println("MyComputer输入信息[^L^]。。。。。。");
     }
 
     public void outputInfo() {
         System.out.println("MyComputer输出信息[^_^]。。。。。。");
     }
 }
 
 public class mainTest {

     public void streamData(USB usbImpl){
         usbImpl.inputInofo();
         usbImpl.outputInfo();
     }

    @Test
     public void test1(){
         //1.非匿名实现类的非匿名对象
         Computer computer = new Computer(); // ==> USB usbImpl = new Computer();
         streamData(computer);
    }

    @Test
     public void test2(){
         //2.非匿名实现类的匿名对象      
         streamData(new Computer());
    }

    @Test
     public void test3(){
         //3.匿名实现类的非匿名对象       
         USB usbImpl = new USB() {
             public void inputInofo() {
                 System.out.println("[匿名实现类，非匿名对象]输入。。。。");
             }
 
            public void outputInfo() {
                 System.out.println("[匿名实现类，非匿名对象]输出。。。。");
             }
         };
         streamData(usbImpl);
    }

    @Test
     public void test4(){
         //4.匿名实现类的匿名对象       
         new USB() {
             public void inputInofo() {
                 System.out.println("[匿名实现类，匿名对象]输入。。。。");
             }
 
            public void outputInfo() {
                 System.out.println("[匿名实现类，匿名对象]输出。。。。");
             }
         };        
    }
 }

• jdk8之后在接口里可以定义静态方法和默认方法。
  ①接口中的静态方法只能自己调用。即接口.静态方法。
  ②可以重写接口的方法。
  定义一个接口Named,里面有静态方法和默认方法

public interface Named {
    public static void mehtod1(){
        System.out.println("接口方法1");
    }
    public default void mehtod2(){
        System.out.println("接口方法2");
    }
}

定义一个LiMing类实现Named接口,同时测试一下

public class Student {
    public static void main(String[] args) {
        LiMing liMing = new LiMing();
        liMing.mehtod2();
        Named.mehtod1();
    }
}
class LiMing implements Named{

}

结果如下：

接口方法2
接口方法1

可以重写接口的默认方法，如下：

public class Student {
    public static void main(String[] args) {
        LiMing liMing = new LiMing();
        liMing.mehtod2();
        Named.mehtod1();
    }
}
class LiMing implements Named{
    public  void mehtod2(){
        System.out.println("接口方法2被重写");
    }
}

结果如下：

接口方法2被重写
接口方法1

默认方法的冲突

• 超类优先：如果超类提供了一个具体方法， 同名而且有相同参数类型的默认方法会
  被忽略。

定义接口A

public interface A {
    public default void xx(){
        System.out.println("接口A 中 xx方法");
    }
}

编写父类B

public class B {
    public  void xx(){
        System.out.println("类B 中 xx方法");
    }
}

编写子类C让其继承B实现A接口

public class C extends B implements A{
}

编写测试类：

public class TestABC {
    public static void main(String[] args) {
        C c = new C();
        c.xx();
    }
}

结果如下：

类B 中 xx方法

• 接口冲突： 如果一个超接口提供了一个默认方法， 另一个接口提供了一个同名而且
  参数类型 （不论是否是默认参数）相同的方法， 必须覆盖这个方法来解决冲突。

编写接口D

public interface D {
    public default void xx(){
        System.out.println("接口D 中 xx方法");
    }
}

编写类C，让他实现接口A和D，则必须重写方法XX()

public class C implements A,D{
    @Override
    public void xx() {
        System.out.println("实现方法");
    }
}

编写测试类：

public class TestABCD {
    public static void main(String[] args) {
        C c = new C();
        c.xx();
    }
}

结果：

实现方法

2.内部类

• 成员内部类(定义在一个类中，方法外）
  ① 作为一个类：可以定义方法，属性，构造器等。可以用final修饰。可以用abstract修饰。
  ② 作为一个外部成员：可以被static修饰（普通类是不能被static修饰的），可以被四种修饰符修饰，可以调用外部类的结构

//定义一个Animal类：理解成员内部类
class Animal{
    String name;
    int age;

    public void name(){
        System.out.println("孟子");
    }

    //静态成员内部类
    static class Bird{
        String name;
        int age;

        public Bird(){

        }
        public void eat(){
            System.out.println("鸟吃饭");
        }
    }

    //非静态成员内部类
    class Cat{
        String name;
        int age;

        public void eat(){
            System.out.println("猫吃饭");
        }
    }
}
//成员内部类的实例化问题
public static void main(String[] args) {
      //1. 非静态 实例化
        Animal animal = new Animal();
        Animal.Cat cat = animal.new Cat();
        cat.eat(）
      //2. 静态 实例化
        Animal.Bird bird = new Animal.Bird();
        bird.eat();
    }
/**
输出结果：
   猫吃饭
   鸟吃饭
*/

//非静态 成员内部类调用方法
//在Cat类中添加show方法
public void show(){
       name(); 
       Animal.this.name(); //和name()效果一样
 }
//测试
Animal animal = new Animal();
        Animal.Cat cat = animal.new Cat();
        cat.show();
//结果：
//孟子
//孟子

• 局部内部类（定义在代码块内，方法内，构造器内等）
  局部类不能用 public 或 private 访问说明符进行声明。它的作用域被限定在声明这个局部类的块中。局部类有一个优势， 即对外部世界可以完全地隐藏起来。