抽象类、内部类

抽象类

当一个类被abstract修饰的时候称为抽象类。将共性的方法抽取到父类之后，由于每个子类执行的内容不一样，所以，在父类中不能确定具体的方法体，该方法可以定义为抽象方法。如果一个类中存在抽象方法，那么这个类必须声明为抽象类

抽象类的声明

abstract class<类名>{
	修饰符 数据类型 变量名;
	修饰符 abstract 返回值类型 方法名称(参数列表);
	修饰符 返回值类型 方法名称(参数列表){
	}
}

示例：

public abstract class Abstract {
    private String name = "无民";
    private int love = 10;
    public Abstract(String name){
        this.name = name;
    }

    public abstract void work();

}
  class Pet extends Abstract{
      public Pet(String name) {
          super(name);
      }
      @Override
      public void work() {
          System.out.println("吃");
      }
  }

  class Test {
      public static void main(String[] args) {
          Pet pet = new Pet("狗狗");
          pet.work();
      }
  }

• 抽象类不能实例化，不能创建对象，可以有构造方法
• 抽象类中不一定要有抽象方法，有抽象方法一定是抽象类
• 如果子类不是抽象类，子类必须重写抽象类中全部的抽象方法
• abstract修饰符和final不能一起使用

具体类抽象类的区别

1. 抽象类不能被实例化，只能作为其他类的基类。具体类可以被实例化
2. 抽象类包含抽象方法和非抽象方法，子类必须实现抽象方法。具体类必须实现它的所有方法
3. 抽象类用来定义一些基础的、通用的行为和属性。具体类用来实现具体的业务逻辑行为。

内部类

将一个类定义在另一个类的内部，称为内部类。

1.类的五大成员

属性、方法、构造器 、代码块、内部类/接口

2.内部类访问特点

1. 内部类可以直接访问外部类成员，包括私有
2. 外部类要访问内部类的成员，必须创建对象
3. 内部类, 当 main 方法调用结束，就销毁
4. 局部类, 当 main 方法调用结束，就销毁

3.内部类的分类

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

成员内部类

写在成员内部类

成员内部类可以被修饰符所修饰

获取成员内部类对象

1. 被private修饰时，在外部类中编写方法，对外提供内部类的对象
2. 直接创建格式：外部类名.内部类名 对象名 = 外部对象.内部对象

示例：

public class InnerClass {
    String name = "张三";
    class Inner{
        public void show(){
            System.out.println(name);
        }
    }
    //私有内部类
    private  class  Inner1{
    }
    public  Inner1 getInstance(){
        return new Inner1();

    }
}

public class InnerTest {
    public static void main(String[] args) {
        //直接调用
        InnerClass.Inner i = new InnerClass().new Inner();
        System.out.println(i.show());
        //私有
        InnerClass i1 = new InnerClass();
        System.out.println(i1.getInstance());
    }
}

外部类成员变量和内部类成员变量重名时，在内部类如何访问

示例：

public class Outer {
    private int a = 10;

    class Inner{
        private int a = 20;
        public void show(){
            int a= 30;
            System.out.println(a);//30
            System.out.println(this.a);//20
            //Outer.this获取了内部类对象的地址值
            System.out.println(Outer.this.a);//10
        }
    }
}

public class OuterTest {
    public static void main(String[] args) {
        Outer.Inner i = new Outer().new Inner();
        i.show();
    }
}

静态内部类

静态内部类只能访问外部类的静态变量和静态方法，如果想要访问非静态的需要创建对象

静态内部类属于成员内部类的一种

创建静态内部类对象的格式：

外部类.内部类 对象名 = new  外部类名.内部类名();

调用非静态方法的格式：对象.

调用静态方法的格式：外部类名.内部类名.方法名();

示例：

public class OuterStatic {
    int a = 10;
    static  int b = 20;
    static class Inner{
        OuterStatic O = new OuterStatic();
        public void show(){
            System.out.println("非静态方法");
        }
        public static void show1(){
            System.out.println("静态方法");
        }
    }
}

public class OuterStaticTest {
    public static void main(String[] args) {
        //创建静态内部类对象
        OuterStatic.Inner i = new OuterStatic.Inner();
        //非静态方法
        i.show();
        System.out.println(i.O.a);
        //静态方法
        OuterStatic.Inner.show1();
        System.out.println(OuterStatic.b);
    }
}

局部内部类

将内部类定义在方法里面叫做局部内部类，类似于局部变量

• 外界是无法直接使用，需要在方法内部创建对象并使用
• 该类可以直接访问外部的成员，也可以访问方法内的局部变量

示例：

public class OuterInclude {
    int b = 20;
    public void show(){
        int a = 10;
        class Inner{
            String name;
            static  int age;
            public void set(){
                System.out.println("局部内部类中的set方法");
            }
            public static void set1(){
                System.out.println("局部内部类中的set静态方法");
            }

        }
        Inner i = new Inner();
        //非静态
        i.set();//局部内部类中的set方法
        System.out.println(i.name);//null
        //静态
        Inner.set1();//局部内部类中的set静态方法
        System.out.println(Inner.age);//0

    }
}

匿名内部类

匿名类本质是隐藏了名字的内部类,可以写在成员位置，也可以写在局部位置

格式：

new 类名或者接口名(){
	重写方法;
}

示例：

public static void main(String[] args) {
    Pet pet = new Dog();
    pet.cry();
    //匿名类
    Pet p = new Pet() {
        @Override
        public void cry() {
        System.out.println("喵 喵 喵");
        }
    };
    p.cry();
}

• 匿名类不能使用修饰符，在方法的内部，对外隐藏。不能是 static ，隐式 final 类。匿名类没有类名，没有构造方法。
• 匿名类可以访问类中的成员，不能访问方法中的变量，除非是 final 的。
• 匿名类一般是实现接口、继承抽象类。相当于实现、继承了这个接口/类。

public abstract class Pet {
        public abstract void cry();
}
//匿名类
Pet p = new Pet() {
    @Override
    public void cry() {
    System.out.println("喵 喵 喵");
    }
};
//等同于
public class 类名 extends Pet{
    @Override
    public void cry() {
    System.out.println("喵 喵 喵");
    }
}