抽象类和内部类

抽象类

abstract修饰的类为抽象类，其也可以修饰方法，对应的方法就是抽象方法

抽象方法：没有函数体的方法，抽象方法不能再父类（本类）中实现，必须由子类（非抽象类）重写并实现

只有抽象类才有抽象方法（抽象方法必须要在抽象类），非抽象类中不能有抽象方法，抽象类中可以没有抽象方法

抽象类中不一定全是抽象方法，也可以有普通方法。普通方法，子类可以不用重写

抽象类不能实例化，但是可以使用多态（可以父类指向子类引用，A a =new B()）

final和abstract修饰方法是冲突的，final修饰的方法禁止重写，abstract修饰的方法必须重写

private和abstract修饰方法是冲突的，private修饰的方法子类不可见，不能重写

static和abstract修饰方法是冲突的，static修饰方法属于类，abstract修饰方法属于对象的

抽象类有构造方法，子类继承父类，子类的构造方法会调用父类的构造方法。

子类继承抽象类，如果不想实现抽象类中的抽象方法，该类必须是抽象类

public abstract class A {
    public abstract void run();
}

内部类

内部类是定义再另一个类中的类（在类的内部，即括号内）

内部类中的方法可以访问内部类所在（外部）类中的数据包括私有数据

内部类可以对统一的数据隐藏起来，增强面向对象的封装性

当想定义一个函数且不想编写大量代码 时，使用匿名内部类更便捷

内部类可以间接实现多继承（注意是间接，java不支持多继承）

public class XiaoHua extends Painter{
    class PainterA extends Painter{

    }
    class WriterA extends Writer{

    }
    public void paint(){
        PainterA PainterA = new PainterA();
        PainterA.paint();
    }
    public void write(){
        WriterA writerA = new WriterA();
        writerA.write();
    }

    public static void main(String[] args) {
        XiaoHua xiaoHua = new XiaoHua();
        xiaoHua.paint();
        xiaoHua.write();
    }
}
class Painter{
    public void paint(){
        System.out.println("画画");
    }
}
class Writer{
    public void write(){
        System.out.println("写作");
    }
}

通过两个内部类分别继承与其他两个类，外部类在写这两个方法（实例化内部类，获取内部类的数据和方法），就可以间接实现多继承。

内部类的类型

非静态内部类

非静态内部类：非静态内部类如同外部类的一个对象方法 {持有隐式的外部类引用}，故可以访问外部类任意访问权限的变量和方法

非静态内部类不能使用static（相当于对象方法）

外部类.内部类 变量名 = new 外部类().new内部类()

public class Person {
    private String[] sex ={"男性","女性"};
    class XiaoMing{
        private String xiaoming_sex;
        String showSex(){
            xiaoming_sex =sex[0];
            return xiaoming_sex;
        }
    }

    public void test() {
        XiaoMing xiaoMing =new XiaoMing();
        System.out.println(xiaoMing.showSex());
    }
    public static void main(){

    }
}

public class XiaoHua extends Painter{
    public static void main(String[] args) {
        Person.XiaoMing xiaoMing = new Person().new XiaoMing();
        xiaoMing.showSex();
    }
}

局部内部类

不常用，局部内部类定义在代码块，方法体内（{}内）的类

局部内部类不能使用public、private、protected、static这些修饰符

局部内部类只能在当前方法中使用

局部内部类和非静态内部类一样，不能拥有静态变量，但是可以访问外部类的所有变量

局部内部类访问的局部变量必须使用final修饰，java8以后会自动隐式假设final

package com.qcby.demo.innerclass;

public class Person {
    private String[] sex ={"男性","女性"};
    public void test() {
        class People{
            private String xiaoming_sex;
            String showSex(){
                xiaoming_sex =sex[0];
                return xiaoming_sex;
            }
        }
        People people =new People();
        System.out.println(people.showSex());
    }
    public static void main(String[] args){
        Person person =new Person();
        person.test();
    }
}

匿名内部类

匿名内部类是局部内部类的一种特殊形式，是一个没有名称的内部类

匿名内部类使用条件：继承一个父类或者实现一个接口

public class Person {
    private String[] sex ={"男性","女性"};
    public void sleep(){
 	 System.out.println("人睡觉");
   }
}

public class Test {
    public static void main(String[] args) {
        new Person(){//匿名内部类，相当于Person的子类，可以重写父类的方法
            @Override
            public void sleep() {
                System.out.println("学生睡觉");
            }
        }.sleep();
        new Person().sleep();//相当于调用父类的方法，子类转父类自动转换     
    }
}

静态内部类

静态内部类如同外部类的一个类方法

静态内部类不能访问外部类的对象（对象的成员对象和方法也都访问不到）

静态内部类在创建静态内部类实例时不必创建外部类实例

静态内部类可以直接访问外部内的静态变量

静态内部类中可以定义静态和非静态成员

外部类可以通过完整的类名直接访问静态内部类的静态成员

public class OuterClass {
    public static String name="外部类";
    static class InnterClass{//静态内部类
        public static int a;
        public int b;
        public void test(){
            System.out.println(name);
        }
    }

    public static void main(String[] args) { 
        OuterClass.InnterClass a =new OuterClass.InnterClass();//实例化静态内部类
        a.test();
    }
}