JAVA抽象类、接口及内部类

抽象类

1、抽象类定义

  • 在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
  • 抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。
  • （1）abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。
    （2）在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法。
    （3）实现抽象类必须实现其中的所有抽象方法（非抽象方法）。抽象类中可以有非抽象方法。
    （4）抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。

2、抽象类实现

public abstract class person {

    String property = "属性";

    public abstract void run_01();

    void run_02(){
        System.out.println("程序运行");
    }

}
class Myperson extends person{

    @Override
    public void run_01() {

    }
}

接口

1、接口定义

  • 接口是一种约束形式，其中只包括成员定义，不包含成员实现的内容。
  • Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现。
  • 接口声明的方式与声明类的方式相似，但使用的关键字是interface，而不是 class。
  • 接口只包含方法、属性、索引器和事件的签名。方法的实现是在实现接口的类中完成。

2、接口成员定义

  • 与类成员的定义相似。
  • 不允许使用访问修饰符（private，protected 或 internal），所有的接口成员都必须是公共（public）的。
  • 接口方法不能包含代码实体。
  • 接口成员不能定义变量；但可以通过public static final关键字（可以省略关键字）来定义常量。
  • 接口成员不能用关键字virtual，abstrac t或 sealed 来定义。

3、接口实现

public interface InterFace {

    public static final String PROPERTY_01 = "属性";
    String PROPERTY_02 = "属性"; //省略关键字。

    public abstract void run_01();
    void run_02(); //默认接口成员都是public，且public abstract可以省略。
}


class MyInterFace implements InterFace{

    @Override
    public void run_01() {
        
    }

    @Override
    public void run_02() {

    }
}

抽象类和接口联系及区别

  • abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。
  • 在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是public static final的，不过在 interface中一般不定义数据成员），所有的成员方法默认都是public abstract的。
  • abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。
  • 实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。
  • 接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。
  • 抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。

内部类

1.内部类定义

  • 内部类（Inner Class），是 Java 中对类的一种定义方式，是嵌套类的一个分类，即非静态嵌套类（Non-Static Nested Class）。内部类（非静态嵌套类）分为成员内部类、局部内部类和匿名内部类三种。
  • Java 编程语言允许一个类被定义在另一个类中，这样的类就称为嵌套类。嵌套类分为两种：静态的和非静态的。没有用 static 关键字来声明的嵌套类，就称为非静态嵌套类。非静态嵌套类，又称为（成员）内部类。内部类还有两个特殊的类型：局部(内部)类（Local Class）和匿名（内部）类（Anonymous Class）。
  • 包含嵌套类的类，可称为外围类（Enclosing Class）或外部类（Outer Class）。非静态嵌套类（内部类）可访问其外围类的其他成员，即使这些成员被声明为私有的。若内部类作为其外部类的成员，则它可声明为 private、public、protected 或包私有的。
  • 提示：外部类只能声明为 public 或包私有的。

2、内部类实现

（1）成员内部类（内部类）
  • 通过外部类实例化对象调用并创建内部类实例对象
//外部类
public class Outer {
    private String property ="属性";

    public String getProperty() {
        return property;
    }

    public void setProperty(String property) {
        this.property = property;
    }

    public void out(){
        System.out.println("这是外部类");
    }
    //内部类，相当于类中属性
    public class Inner{
        public void in(){
            System.out.println("这是内部类");
        }
        //内部类获取外部类私有属性
        public void getProperty(){
            System.out.println("获得外部类属性"+property);
        }
    }

    public static void main(String[] args) {
        //外部类实例化对象
        Outer out = new Outer();
        //通过外部类对象调用并创建内部类对象
        Outer.Inner in = out.new Inner();
        in.getProperty();
    }

}
（2）局部内部类（局部类）
  • 在方法中实例化对象，仅在本方法有效
//外部类
public class Outer {
    private String property ="属性";

    public void out(){
        System.out.println("这是外部类");
    }

    public void Inner(){
        //局部内部类，相当于方法中属性
       class Inner{
           public void out(){
               System.out.println("这是内部类");
           }
           public void getPorperty(){
               System.out.println("获取外部类私有变量"+property);
           }
       }
       //在方法中实例化对象，仅在本方法有效
       Inner in = new Inner();
       in.getPorperty();
    }

    public static void main(String[] args) {
        //外部类实例化对象
        Outer out = new Outer();
        out.Inner();
    }

}
（3）匿名内部类（匿名类）
  • 外部类实例化对象,并创建匿名内部类,匿名内部类继承外部类,用于重写外部类（父类）方法，常见于抽象类和接口。
//外部类
public class Outer {
    private String property ="属性";

    public void out(){
        System.out.println("这是外部类");
    }

    public static void main(String[] args) {
        //外部类实例化对象,并创建匿名内部类,匿名内部类继承外部类,用于重写外部类（父类）方法，常见于抽象类和接口
        Outer out = new Outer(){
            @Override
            public void out() {
                System.out.println("这里是匿名内部类");
            }
        };
        out.out();
    }

}
（4）lmabda表达式（内部类特殊简化）
  • 只能用于函数式接口
public class Outer {
    public static void main(String[] args) {
        //lmabda表达式
        InterFace_01 interface_01 =()->System.out.println("这里是lmabda表达式");
        interface_01.run();
        InterFace_02 interface_02 =(str)->System.out.println("这里是lmabda表达式:"+str);
        interface_02.run("你好");
    }
}
//函数式接口，只含有一个抽象方法
interface  InterFace_01{
    public abstract void run();
}
interface InterFace_02{
    public abstract void run(String str);
}