抽象、接口和内部类



抽象类

说明

一般来说，抽象类会被继承，有其子类来实现，

所谓抽象方法就是没有实现的方法，所谓实现就是指，没有方法体

使用细节

1.用abstract关键字来修饰一个类时，这个类就叫抽象类

访问修饰符  abstract  类名{}

2.用abstract关键字来修饰一个方法时，这个方法就是抽象方法

访问修饰符 abstract 返回类型 方法名 (参数列表);

3.抽象类的价值更多作用是在于设计，是设计者设计好，让子类继承并实现抽象类()

4.抽象类在框架和设计模式使用较多

注意事项

1.抽象不能被实例化

2.抽象类不一定要包含abstract方法。

3.一旦类包含了abstract方法，则这个类必须声明为abstract。

4.abstract只能修饰类和方法，不能修饰属性和其他的。

5.抽象类可以有任意成员(抽象类还是类)，比如：非抽象方法、构造器、静态属性等等。

6.抽象方法不能有主体，既不能实现

7.如果一个类继承了抽象类，则他必须实现抽象类的所有抽象方法，除非他自己也声明

为abstract类

8.抽象方法不能使用private、final和static来修饰，因为这些关键字

和重写相违背的。

接口

基本介绍

接口就是给出一些没有实现的方法，封装到一起，到某个类使用的时候，再根据具体情况

把这些写出来

1.在jdk7.0前 接口里的所有方法都没有方法体，即都是抽象方法

2.jdk8.0后接口可以有静态方法，默认方法(需要加默认修饰符default)，也就是接口中可以有方法的具体实现

语法
interface 接口名{
    //属性
    //方法
} 
class 类名 implements 接口{
    //自己属性
    //自己方法
    //必须实现的接口的抽象方法
}
//implements 实现的意思
public class interface01 {
    public static void main(String[] args) {

    }
}
class A implements Ainterfance{
    /**如果类要实现implements实现 接口
     * 需要将该接口的所有抽象方法都实现*/
    @Override
    public void hi() {

    }
}
public interface Ainterfance {
    //属性
    public int n1 = 10;
    //在接口中抽象方法可以省略关键字
    public void hi();
    //在jdk8后，可以有默认实现方法
    default public  void ok(){
        System.out.println("okkvdn");
    }
    //在jdk8后，可以有静态方法
    public static void hello(){
        System.out.println("你好");
    }
}
注意事项

1.接口不能被实例化

2.接口中 所有方法是public方法，接口中抽象方法，可以不用abstract修饰

3.一个普通类实现接口，就必须将该接口的所有方法都实现，可以使用alt+Enter快速添加

4.抽象类实现接口，可以不用实现接口的方法。

5.一个类同时可以实现多个接口

6.接口中的属性，只能是final的，而且是 public static final修饰符

例如：int a=1；实际上是public static  final   int  a=1；(必须初始化)

7.接口中属性的访问形式：接口名.属性名

8.一个接口不能继承其他的类，但是可以继承多个别的接口

interface A extends B,C{}

9.接口的修饰符只能是public和默认，这和类的修饰符是一样的。

public class Aniter01 {
    public static void main(String[] args) {
        B b = new B();
        System.out.println(b.a);
        System.out.println(A.a);
        System.out.println(B.a);
    }
}
interface A{
    public static final int a = 23;
}
class B implements A{}
接口和继承
接口和继承解决的问题不同

继承的主要价值：解决代码的复用性和可维护性

接口的价值：设计好各种规范(方法)，让其他类去实现这些方法。更加的灵活

继承是满足is——a的关系，而接口只需满足like——a的关系

接口多态

1.多态参数

例如：USB即可以接收手机对象，又可以接收相机对象，这就体现了接口的多态

（接口引用可以指向实现了接口的类的对象）

2.接口存在多态传递现象

（如果IG继承了IH接口，而Teacher类实现了IG接口，那么，实际上就相当于Teacher类也实现IH 接口，这就是接口多态传递现象）

内部类

基本介绍

一个类的内部又完整的嵌套了另一个类结构。

被嵌套的的类称为内部类；嵌套其他类的类称为外部类；

类的五大成员：属性、构造方法、一般方法、块、内部类

优点

可以直接访问私有属性，并可以体现类与类之间的包含关系

基本语法
class Outer{//外部类
  class Inner{//内部类
  
  }
}
class Other{//外部其他类
}
局部内部类

说明：局部内部类是定义在外部类的局部位置，比如方法中，并且有类名

1.可以直接访问外部类的所有成员，包含私有的

2.不能添加访问修饰符，因为他的地位就是一个局部变量。局部变量是不能使用

修饰符的。但是可以使用final修饰，因为局部变量也可以使用final

3.作用域：仅仅在定义他的方法或代码块中。

4.局部内部类----访问----->外部类的成员【直接访问】

5.外部类------访问-------->局部内部类的成员

【创建对象，在访问(注意：必须在作用域内)】

6.外部类在方法中，可以创建内部类对象，然后调用方法即可

7.外部其他类-----不能访问------>局部内部类（因为局部内部类地位是一个局部变量）

8.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类

的成员，则可以使用（外部类名.this.成员)去访问

匿名内部类

他的本质还是类、内部类，该类没有名字，同时还是一个对象

说明：匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名

基本语法
new 类或接口(参数列表){

  //类体

}
/**
 * 操作匿名类*/
public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer01 outer01 = new Outer01();
        outer01.method();
    }
}
class Outer01{
    private int n1 = 10;
    public void method(){
        //基于接口的匿名内部类
        //tiger的编译类型 M
        //tiger
         M tiger = new M(){
           @Override
           public void cry() {
               System.out.println("老虎叫唤");
           }
       };
         tiger.cry();
         //1.father编译类型 Father
        //2.father 运行类型Outer01$2
        //3.底层会创建匿名内部类
        //4.同时也直接返回了匿名内部类Outer01$2的对象
        //内部类不能使用构造器
        Father father = new Father(10210){
            @Override
            public void test() {
                System.out.println("重写方法");
            }
        };
        MengJiXiang jiji = new MengJiXiang() {
            @Override
            void eat() {
                System.out.println("饿了，想吃饭");
            }
        };
        jiji.eat();
        father.test();
        System.out.println(father.getClass());
    }
}
interface M{
    public void cry();
}
class Tiger implements M{
    @Override
    public void cry() {
        System.out.println("老虎嘶吼着");
    }
}
class Father{
    int ID;

    public Father(int ID) {
        this.ID = ID;
    }
    public void test(){
        System.out.println("hello");
    }
}
abstract class MengJiXiang{
    abstract void eat();
}

2.匿名内部类的语法比较奇特，因为匿名内部类是一个类的定义，同时本身也是对象的特征

同时也是对象，因此从语法看上看，它既有定义类的特征，也有创建对象的特征，因此可以调用

匿名内部类方法

3.可以直接访问外部类的所有成员，包含私有的

4.不能添加访问修饰符，因为他的地位就是一个局部变量。

5.作用域：仅仅在定义它的方法或代码块中

6.匿名内部类 -----访问 ------外部类成员【访问方式：直接访问】

7.外部其他类 ---- 不能访问 ----匿名内部类（因为匿名内部类的地位是一个局部变量）

8.如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循

就近原则，如果想放外部类成员，使用（外部类名.this.成员）去访问

成员内部类

说明成员内部类是定义在外部类的成员位置，并且没有static修饰

1.可以直接访问外部类的所有成员，包含私有的

2.可以添加任意访问修饰符，因为他的地位就是一个成员

3.作用域和外部类的其他成员一样，为整个类体。

比如在外部类的成员方法中创建成员内部类对象，再调用方法

4.成员内部类-----访问-------->外部类（属性）访问方式：直接访问

5.外部类-----------访问-------------内部类（说明） 访问方式：创建对象，在访问

6.外部其他类------访问-------->成员内部类

静态内部类

说明：静态内部类是定义在外部类的成员位置，并且有static修饰

1.可以直接访问外部类的所有静态属性，包含私有的，但不能直接访问非静态属性

2.可以添加任意访问修饰符，因为他的地位就是一个成员。

3.作用域：同其他的成员，为整个类体

4.静态内部类—访问----->外部类（静态属性）访问方式：直接访问所有静态属性

5.外部类-----访问----->静态内部类 访问方式：创建对象，再访问

6.外部其他类------访问----->静态内部类

7.如果外部类和静态内部类的成员重名时，静态内部类访问时，默认遵循就近原则，

如果想访问外部类的成员，则可以使用（外部类名。成员）去访问