一、抽象类
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.变量，指定类的一个引用。
1 /***
2 * @author: liu_y
3 * @Date: 2016年7月24日
4 * @Title:抽象类 、成员内部类、使用this关键字获取内部类与外部类的引用
5 */
6 /******************
7 * 抽象类
8 */
9 abstract class Fruit {
10 public String color;
11
12 // 定义构造方法
13 public Fruit() {
14 color = "green";
15 }
16
17 // 定义抽象方法
18 public abstract void harvest();
19 }
20 // 继承抽象类Fruit
21 class Apple extends Fruit {
22 @Override
23 public void harvest() {
24 System.out.println("苹果已经收获！");
25 }
26 }
27 // 继承抽象类Fruit
28 class Orange extends Fruit {
29 @Override
30 public void harvest() {
31 System.out.println("橘子已经收获！");
32 }
33 }
34 /******************
35 * 成员内部类学习
36 */
37 class OuterClass {
38 private String season = "Summer";
39
40 class InnerClass {
41 InnerClass() { // 内部类构造方法
42 }
43 public void inf() { // 内部类成员方法
44 System.out.println("这是内部类成员方法！");
45 }
46
47 public int y;
48 }
49
50 InnerClass in = new InnerClass(); // 外部类实例化内部类对象
51
52 public void ouf() { // 在外部类中调用内部类方法
53 in.inf();
54 System.out.println("外部类中调用内部类方法！");
55 }
56
57 public InnerClass doit() {
58 // y=5; //外部类不可以直接访问内部类成员变量
59 in.y = 7;
60 season = "Autumn"; // 内部类可以直接访问其所在类的私有成员变量
61 System.out.println(season);
62 return new InnerClass();
63 }
64 }
65
66 /***
67 * 使用this关键字获取内部类与外部类的引用
68 */
69 class China {
70 private int age = 2016; // 外部类变量
71 // 内部类
72
73 class Beijing {
74 private int age = 1988; // 内部类变量
75
76 public void doit(int age) {
77 age++;
78 System.out.println("这是内部类方法中变量" + age);
79 System.out.println("这是内部类变量" + this.age);
80 System.out.println("这是外部类变量" + China.this.age);
81 }
82 }
83 }
84
85 public class Hello5Abstract {
86
87 public static void main(String[] args) {
88 // TODO Auto-generated method stub
89 /**
90 * 抽象类使用
91 */
92 System.out.println("抽象类：");
93 System.out.println("调用 Apple类的harvest()方法的结果：");
94 Apple apple = new Apple();
95 apple.harvest();
96 System.out.println("调用 Orange类的harvest()方法的结果：");
97 Orange orange = new Orange();
98 orange.harvest();
99
100 /****
101 * 内部类----成员内部类
102 */
103 System.out.println("\n内部类：");
104 // 实例化内部类
105 OuterClass out = new OuterClass();
106 out.ouf();
107
108 System.out.println("\n调用外部类方法时返回一个内部类实例：");
109 OuterClass.InnerClass in1 = out.doit(); // 直接new一个内部类实例
110 in1.inf();
111
112 System.out.println("\n直接new一个内部类实例：");
113 // OuterClass.InnerClass in2=new OuterClass.InnerClass(); //额不可以这样用。。
114 // 应该使用外部类的对象来创建内部对象，内部类对象会依赖于外部类对象
115 OuterClass.InnerClass in2 = out.new InnerClass();
116 in2.inf();
117
118 /***
119 * 使用this关键字获取内部类与外部类的引用
120 */
121 System.out.println("\n使用this关键字获取内部类与外部类的引用：");
122 China china = new China();
123 China.Beijing bj = china.new Beijing();
124 bj.doit(26);
125 }
126
127 }
输出结果:
1 抽象类： 2 调用 Apple类的harvest()方法的结果： 3 苹果已经收获！ 4 调用 Orange类的harvest()方法的结果： 5 橘子已经收获！ 6 7 内部类： 8 这是内部类成员方法！ 9 外部类中调用内部类方法！ 10 11 调用外部类方法时返回一个内部类实例： 12 Autumn 13 这是内部类成员方法！ 14 15 直接new一个内部类实例： 16 这是内部类成员方法！ 17 18 使用this关键字获取内部类与外部类的引用： 19 这是内部类方法中变量27 20 这是内部类变量1988 21 这是外部类变量2016
时间： 2024-10-18 16:15:39