Java的抽象类和内部类

抽象类

关键字为abstract

例如：

abstract class Fruit{
    public String color;
    public Fruit() {
        color = "red";
    }
    public abstract void harvest();//抽象方法，没有定义方法的实现
}

抽象方法不能使用private或static关键字进行修饰

内部类定义：在一个类中再定义一个类，可分为成员内部类、局部内部类、匿名内部类。

成员内部类

    在一个类中使用内部类可以在内部类中直接存取其所在类的私有成员变量和成员方法，尽管这些类成员被private修饰。

    内部类的对象实例化操作必须在外部类或外部类中的非静态方法中实现。

例如：

public class OuterClass { //外部类
    InnerClass in = new InnerClass();
    private int i = 0;
    private void Get() {
    }

    class InnerClass { //内部类
        InnerClass() {
        }
        void fun() {
            Get(); //调用外部类的成员方法
            i++; //调用外部类的成员变量
        }
        int y = 0;
    }

    public InnerClass doit() {
        //y = 4; //外部类不可以直接访问内部类成员变量
        in.y = 4;
        return new InnerClass();
    }
    public static void main(String args[]) {
        OuterClass out = new OuterClass();
        OuterClass.InnerClass in = out.doit(); //也可用 OuterClass.InnerClass in = out.new InnerClass();
    }
}

外部类和内部类有同名成员变量时，可以用this区分。

局部内部类

    在类的方法中定义的内部类，作用范围也是在这个方法体内。但该内部类可以访问当前代码块的常量以及此外部类的所有成员。

例如：

public class SellOutClass {
    private String name;
    public SellOutClass() {
        name = "apple";
    }
    public void sell(int price) {

        //在sell()方法的外部不能访问Apple内部类
        class Apple {  //局部内部类
            int innerPrice = 0;
            public Apple(int price) {
                innerPrice = price;
            }
            public void price() {
                //函数体
            }
        }

        Apple apple = new Apple(price);
        apple.price();
    }
    public static void main(String[] args) {
        SellOutClass sample = new SellOutClass();
        sample.sell(100);
    }
}

匿名内部类

return new A() {  ----A表示对象名

    //内部类体

};  ----需要加分号

例如：

public class OutString {
    public static void main(String[] args) {
        final String sourceStr = "jilinsheng";

        IStringDeal s = new IStringDeal() { //定义匿名内部类，并实例化对象
            public String Blankchar() {
                String converStr = sourceStr;
                return converStr;
            }
        };

        system.out.println("char: " + s.Blankchar());
    }
}
    

静态内部类

    用static修饰的内部类。一个静态内部类中可以声明static成员。但是在非静态内部类中不可以声明静态成员。静态内部类不可以使用外部类的非静态成员。

内部类的继承

public class OutputClass extends ClassA.ClassB {
    public OutputClass (ClassA a) {
        a.super();
    }
}

class ClassA {
    class ClassB {
    }
}

Java反射机制

功能：

1、在运行时判断任意一个对象所属的类

2、在运行时构造任意一个类的对象

3、在运行时判断任意一个类所具有的成员变量和方法

4、在运行时调用任意一个对象的方法

5、生成动态代理