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("\n内部类：");
         // 实例化内部类
         OuterClass out = new OuterClass();
         out.ouf();

         System.out.println("\n调用外部类方法时返回一个内部类实例：");
         OuterClass.InnerClass in1 = out.doit(); // 直接new一个内部类实例
         in1.inf();

         System.out.println("\n直接new一个内部类实例：");
         // OuterClass.InnerClass in2=new OuterClass.InnerClass(); //额不可以这样用。。
         // 应该使用外部类的对象来创建内部对象，内部类对象会依赖于外部类对象
         OuterClass.InnerClass in2 = out.new InnerClass();
         in2.inf();

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

 }

输出结果:

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

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

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

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

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