一、内部类
1.1.1、成员内部类
一个类定义在另一个类的内部,那么该类就叫作成员内部类
1.1.2、成员内部类访问方式
方式一：在外部类中提供一个方法创建内部类的对象进行访问
方式二：在其他类中创建内部类的对象: 格式:外部类.内部类 变量名=new 外部类().new 内部类();
注意：如果是一个静态的内部类,那么其他内的创建的格式
外部类.内部类 变量名 = new 外部类.内部类();
方式一：
1 /* 方式一 */ 2 3 //外部类 4 class Outer{
5 int 1 = 100; 6 //成员外部类 7 class Inner{
8 int i = 10; 9 public void print(){ 10 System.out.println("这是内部类的的print方法!..."+i); 11 } 12 } 13 //在外部的方法中创建内部类的对象,然后调用内部方法 14 public void instance(){ 15 Inner inner=new Inner(); 16 inner.print(); 17 } 18 } 19 class Demo3 { 20 public static void main(String[] args) { 21 Outer o=new Outer(); 22 o.instance(); 23 } 24 }
方式二：
1 /* 方式二 */ 2 3 //外部类 4 class Outer{
5 int i = 100; 6 //成员外部类 7 class Inner{
8 int i = 10; 9 public void print(){ 10 System.out.println("这是内部类的的print方法!..."+i); 11 } 12 } 13 } 14 class Demo3 { 15 public static void main(String[] args) { 16 Outer.Inner inner = new Outer().new Inner(); 17 inner.print(); 18 } 19 }
注意：静态内部类的调用方法
1 //外部类 2 class Outer{ 3 int i = 100; 4 //成员内部类 5 static class Inner{ 6 static int i = 10; 7 public void print(){ 8 System.out.println("这是内部类的的print方法!..."+t); 9 } 10 11 } 12 } 13 class Demo3 { 14 public static void main(String[] args) { 15 Outer.Inner inner=new Outer.Inner();//静态的内部类 16 inner.print(); 17 } 18 }
1.1.3、内部类应用的场景
我们描述A事物的时候,发现描述A事物还存在另外一个比较复杂事物B的时候,而且这个比较复杂的事物B还需要访问A事物的属性等数据,那么这个时候我们就可以使用内部类描述B事物
比如: 人-------->心脏 等等。
class 人{ //外部类 血液 氧气 等.... class 心脏{ //内部类 .... } }
1.1.4、内部类的好处
内部类可以直接访问外部类的所有成员
1.1.5、内部内需要注意的细节:
1.如果内部类和外部类存在同名的成员时,在内部类中默认访问的是内部类的成员变量,可以通过"外部类.this.成员变量名"指定访问外部类的成员
2.私有的成员内部类只能在外部类中类中提供一个方法创建内部类对象进行访问,不能在其他类中创建对象了.
3.成员内部类一旦出现静态成员,那么该类必须用static修饰
//外部类 class Outer{ int i=100;//outer.class文件被加载到内存时存在内中.静态的成员数据是不需要对象存在才能访问的 public int test(){ System.out.println("hello,你好"); return 1; } //成员内部类 class Inner{ int t=i; public void print(){ System.out.println("这是内部类的的print方法!..."+t); } int c=test(); } //在外部的方法中创建内部类的对象,然后调用内部方法 public void instance(){ Inner inner=new Inner(); inner.print(); } } class Demo3 { public static void main(String[] args) { Outer.Inner inner=new Outer().new Inner(); //Outer.Inner inner=new Outer.Inner();//静态的内部类 inner.print(); //System.out.println(Outer.Inner.i); Outer o=new Outer(); o.instance(); } }
1.2.1、局部内部类
在一个类的方法内定义另一个类,那么另一个类就称作为局部内部类.
1.2.2、局部内部类需要注意的细节
1.如果局部内部类访问一个局部变量,那么该局部变量必须使用final修饰
1 //外部类
2 class Outer{ 3 private String name="外部类的name"; 4 public void eat(){ //外部类的方法 5 final int i=10; 6 //局部内部类 7 class Inner{ 8 //int i; 9 public void print(){ 10 System.out.println("这是局部内部类的方法......"+i); 11 } 12 } 13 //实例化局部内部类 14 Inner inner=new Inner(); 15 inner.print(); 16 } 17 } 18 class Demo4 { 19 public static void main(String[] args) { 20 Outer o=new Outer(); 21 o.eat(); 22 } 23 }
二、匿名内部类
2.1、匿名内部类
没有名字的类名称作为匿名内部类
2.2、匿名内部类的好处
简化书写
2.3、匿名内部类的使用前提
必须存在继承或者实现关系才能使用
继承关系下的匿名内部类
1 //继承关系下的匿名内部类 2 abstract class Animal{ 3 public abstract Animal run(); 4 public abstract void sleep(); 5 } 6 7 class Outher{ 8 public void print(){ 9 //匿名内部类:只是没有类名,其他的一概成员都具备的 10 //匿名内部类与Animal是继承关系,目前是Animal子类的对象 11 Animal a = new Animal(){ //多态 new Animal()：是一个子类对象 12 //匿名内部的成员 13 public Animal run(){ 14 System.out.println("狗在跑....."); 15 return this; 16 } 17 public void sleep(){ 18 System.out.println("狗趴着睁着眼睛睡......"); 19 } 20 }; 21 a.run(); 22 a.sleep(); 23 24 } 25 } 26 class Demo6 { 27 public static void main(String[] args) { 28 Outher o=new Outher(); 29 o.print(); 30 } 31 }
或者
1 //继承关系下的匿名内部类 2 abstract class Animal{ 3 public abstract Animal run(); 4 public abstract void sleep(); 5 } 6 7 class Outher{ 8 public void print(){ 9 //匿名内部类:只是没有类名,其他的一概成员都具备的 10 //匿名内部类与Animal是继承关系,目前是Animal子类的对象 11 new Animal(){ //多态 new Animal()：是一个子类对象 12 //匿名内部的成员 13 public Animal run(){ 14 System.out.println("狗在跑....."); 15 return this; 16 } 17 public void sleep(){ 18 System.out.println("狗趴着睁着眼睛睡......"); 19 } 20 }.run().sleep(); 21 } 22 } 23 class Demo6 { 24 public static void main(String[] args) { 25 Outher o=new Outher(); 26 o.print(); 27 } 28 }
实现关系下的匿名内部类
1 //实现关系下的匿名内部类 2 interface Dao{ //接口 3 public void add(); 4 } 5 //接口的实现 6 class t implements Dao{ 7 public void add(){ 8 9 } 10 } 11 //外部类 12 class Outer{ 13 public void print(){ //外部类的方法 14 //创建一个匿名的内部类的对象 15 new Dao(){//不是说好的接口不能实例话吗?现在咋又实例化了啊! 其实：(匿名内部类实现了Dao)，实现关系 16 public void add(){ 17 System.out.println("添加成功"); 18 } 19 }.add(); 20 } 21 } 22 23 class Demo7{ 24 public static void main(String[] args) { 25 Outer o = new Outer(); 26 o.print(); 27 } 28 }
或者
//实现关系下的匿名内部类 interface Dao{ public void add(); } class t implements Dao{ public void add(){ } } /* class Outer{ public void print(){ //创建一个匿名的内部类的对象 new Dao(){//不是说好的接口不能实例话吗?现在咋又实例化了啊! (匿名内部类实现了Dao)实现关系 public void add(){ System.out.println("添加成功"); } }.add(); } } */ class Demo7{ public static void main(String[] args) { test(new Dao(){//Dao的一个匿名实现类 public void add(){ System.out.println("添加成功"); } }); } //调用这个方法 public static void test(Dao d){//形参类型是一个接口引用.....(多态) d.add(); } }
| 原创作者：DSHORE 出自：http://www.cnblogs.com/dshore123/ 欢迎转载，转载务必说明出处。（如果本文对你有用，可以点击一下右下角的 推荐，谢谢！） |