No2_5.类的高级特性_Java学习笔记_抽象类和成员内部类

一、抽象类
1.所谓抽象类，只声明方法的存在而不去实现它的类；
2.抽象类不能被实例化，即不能实现其对象；
3.abstract class 类名{ 类体 }
4.包含一个或多个抽象方法的类必须声明成抽象类；
5.abstract <方法返回值类型> 方法名(参数列表)

二、内部类
1.如果在一个类中再定义一个类，就将在类中定义的那个类称为内部类；
2.内部类分为成员内部类，局部内部类以及匿名内部类；
3.成员内部类：
　　a.可以在内部类中直接存取其所在类的私有成员变量；
　　b.外部类不可以直接访问内部类成员变量；
　　c.public class OuterClass{
　　private class InnerClass{
　　}
　　}
　　d.内部类中可以随意使用外部类的成员方法及成员变量，尽管变量修饰为private。
　　e.内部类的实例一定要绑定在外部类的实例上，如果在外部类初始人一个内部类对象，那么内部类对象就会绑定在外部类对象上。
　　f.如果在外部类和非静态方法之外实例化内部类对象，需要使用“外部类.内部类”的形式指定该对象的类型；
　　g.在实例化内部类对象时，不能在new操作符之前使用外部类名称那种形式实例化内部类对象，而是应该使用外部类的对象来创建内部对象；
　　h.内部类对象会依赖于外部类对象，除非已经存在一个外部类对象，否则类中不会出现内部类对象；

4.使用this关键字获取内部类与外部类的引用
　　a.如果在外部类中定义的成员变量与内部类的成员变量名称相同，可以使用this关键字；
　　b.例如在内部类中使用this.变量，可以调用内部类的成员变量x;类名.this.变量，指定类的一个引用。

　　

/*** 
 * @author: liu_y
 * @Date: 2016年7月24日
 * @Title:抽象类 、成员内部类、使用this关键字获取内部类与外部类的引用
 */
/******************
 * 抽象类 
 */
abstract class Fruit {
    public String color;

    // 定义构造方法
    public Fruit() {
        color = "green";
    }

    // 定义抽象方法
    public abstract void harvest();
}
// 继承抽象类Fruit
class Apple extends Fruit {
    @Override
    public void harvest() {
        System.out.println("苹果已经收获！");
    }
}
// 继承抽象类Fruit
class Orange extends Fruit {
    @Override
    public void harvest() {
        System.out.println("橘子已经收获！");
    }
}
/******************
 * 成员内部类学习
 */
class OuterClass {
    private String season = "Summer";

    class InnerClass {
        InnerClass() { // 内部类构造方法
        }
        public void inf() { // 内部类成员方法
            System.out.println("这是内部类成员方法！");
        }

        public int y;
    }

    InnerClass in = new InnerClass(); // 外部类实例化内部类对象

    public void ouf() { // 在外部类中调用内部类方法
        in.inf();
        System.out.println("外部类中调用内部类方法！");
    }

    public InnerClass doit() {
        // y=5; //外部类不可以直接访问内部类成员变量
        in.y = 7;
        season = "Autumn"; // 内部类可以直接访问其所在类的私有成员变量
        System.out.println(season);
        return new InnerClass();
    }
}

/***
 * 使用this关键字获取内部类与外部类的引用
 */
class China {
    private int age = 2016; // 外部类变量
    // 内部类

    class Beijing {
        private int age = 1988; // 内部类变量

        public void doit(int age) {
            age++;
            System.out.println("这是内部类方法中变量" + age);
            System.out.println("这是内部类变量" + this.age);
            System.out.println("这是外部类变量" + China.this.age);
        }
    }
}

public class Hello5Abstract {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /**
         * 抽象类使用
         */
        System.out.println("抽象类：");
        System.out.println("调用 Apple类的harvest()方法的结果：");
        Apple apple = new Apple();
        apple.harvest();
        System.out.println("调用 Orange类的harvest()方法的结果：");
        Orange orange = new Orange();
        orange.harvest();

        /****
         * 内部类----成员内部类
         */
        System.out.println("
内部类：");
        // 实例化内部类
        OuterClass out = new OuterClass();
        out.ouf();
                
        System.out.println("
调用外部类方法时返回一个内部类实例：");
        OuterClass.InnerClass in1 = out.doit(); // 直接new一个内部类实例
        in1.inf();
        
        System.out.println("
直接new一个内部类实例：");
        // OuterClass.InnerClass in2=new OuterClass.InnerClass(); //额不可以这样用。。
        // 应该使用外部类的对象来创建内部对象，内部类对象会依赖于外部类对象
        OuterClass.InnerClass in2 = out.new InnerClass();
        in2.inf();

        /***
         * 使用this关键字获取内部类与外部类的引用
         */
        System.out.println("
使用this关键字获取内部类与外部类的引用：");
        China china = new China();
        China.Beijing bj = china.new Beijing();
        bj.doit(26);
    }

}

输出结果:

抽象类：
调用 Apple类的harvest()方法的结果：
苹果已经收获！
调用 Orange类的harvest()方法的结果：
橘子已经收获！

内部类：
这是内部类成员方法！
外部类中调用内部类方法！

调用外部类方法时返回一个内部类实例：
Autumn
这是内部类成员方法！

直接new一个内部类实例：
这是内部类成员方法！

使用this关键字获取内部类与外部类的引用：
这是内部类方法中变量27
这是内部类变量1988
这是外部类变量2016