内部类概述和访问特点

 

 1 /** 2  * 1.内部类可以直接访问外部类的成员，包括私有 3  * 2.外部类要访问内部类的成员必须创建对象 4  * @author jjz 5  * 6  */ 7  class outer1 { 8     private int num = 10; 9     class inner{10         public void show(){11             System.out.println(num);12         }13     }14     15     public void show1(){16         //先创建内部类的对象17         inner i = new inner();18         i.show();19     }20 21 }22  23  public class outer {24     public static void main(String[] args) {25         outer1 o = new outer1();26         o.show1();27     }28 }

 1 /** 2  * 成员内部类 3  */ 4 class  Outer1 { 5     private static final int num =100; 6     class Inner{ 7         public void show(){ 8             System.out.println(num); 9         }10     }11 }12 13 public class outer {14     public static void main(String[] args) {15         //成员内部类的访问格式：外部类名.内部类名   对象名 = new 外部类名().new 内部类名()16         Outer1.Inner oi = new Outer1().new Inner();17         oi.show();18     }19 }

 

成员内部类的修饰符：
　　private 为了保证数据的安全性
　　static 为了方便访问数据
　　注意：静态内部类访问的外部类数据必须用静态修饰。

案例：我有一个人(人有身体，身体内有心脏。)

 1 class Body { 2     private class Heart { 3         public void operator() { 4             System.out.println("心脏搭桥"); 5         } 6     } 7  8     //加了private修饰之后就不能直接访问了，所以通过method访问         9     public void method() {10         if(如果你是外科医生) {11             Heart h = new Heart();12             h.operator();13         }14     }15 }16 17 class test{18     public static void main (String []args){19         Body.Heart bh = new Body().new Heart();20     bh.operator();//加了private修饰之后就不能直接访问了21 22         //调用method方法访问23         Body b =  new Body();24     b.method();25     }26 }

 

static修饰内部类：

 1 class Outer { 2     private int num = 10; 3     private static int num2 = 100; 4      5     //内部类用静态修饰是因为内部类可以看出是外部类的成员 6     public static class Inner { 7         public void show() { 8             //System.out.println(num); 9             System.out.println(num2);10         }11 12         public static void show2() {13             //System.out.println(num);14             System.out.println(num2);15         }        16     }17 }18 19 class InnerClassDemo4 {20     public static void main(String[] args) {21         //使用内部类22         // 限定的新静态类23         //Outer.Inner oi = new Outer().new Inner();24         //oi.show();25         //oi.show2();26         27         //成员内部类被静态修饰后的访问方式是:28         //格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();29         Outer.Inner oi = new Outer.Inner();30         oi.show();31         oi.show2();32         33         //show2()的另一种调用方式34         Outer.Inner.show2();35     }36 }

 

 

 1 /* 2     面试题： 3         要求请填空分别输出30，20，10。 4          5     注意： 6         1:内部类和外部类没有继承关系。 7         2:通过外部类名限定this对象 8             Outer.this 9 */10 class Outer {11     public int num = 10;12     class Inner {13         public int num = 20;14         public void show() {15             int num = 30;16             System.out.println();num17             System.out.println();this.num18             //System.out.println();new Outer().num19             System.out.println();Outer.this.num20         }21     }22 }23 class InnerClassTest {24     public static void main(String[] args) {25         Outer.Inner oi = new Outer().new Inner();26         oi.show();27     }    28 }

 

局部内部类
A:可以直接访问外部类的成员
B:在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

面试题：
局部内部类访问局部变量的注意事项?
A:局部内部类访问局部变量必须用final修饰
B:为什么呢?
局部变量是随着方法的调用而调用，随着调用完毕而消失。
而堆内存的内容并不会立即消失。所以，我们加final修饰。
加入final修饰后，这个变量就成了常量。既然是常量。你消失了。
我在内存中存储的是数据20，所以，我还是有数据在使用。

 1 class Outer { 2     private int num  = 10; 3      4     public void method() { 5         //int num2 = 20; 6         //final int num2 = 20; 7         class Inner { 8             public void show() { 9                 System.out.println(num);10                 //从内部类中访问本地变量num2; 需要被声明为最终类型11                 System.out.println(num2);//2012             }13         }14         15         //System.out.println(num2);16         17         Inner i = new Inner();18         i.show();19     }20 }21 22 class InnerClassDemo5 {23     public static void main(String[] args) {24         Outer o = new Outer();25         o.method();26     }27 }

 

匿名内部类

 1 /* 2     匿名内部类 3         就是内部类的简化写法。 4  5     前提：存在一个类或者接口 6         这里的类可以是具体类也可以是抽象类。 7      8     格式： 9         new 类名或者接口名(){10             重写方法;11         }12         13     本质是什么呢?14         是一个继承了该类或者实现了该接口的子类匿名对象。15 */16 interface Inter {17     public abstract void show();18     public abstract void show2();19 }20 21 class Outer {22     public void method() {23         //一个方法的时候24         /*25         new Inter() {26             public void show() {27                 System.out.println("show");28             }29         }.show();30         */31         32         //二个方法的时候33         /*34         new Inter() {35             public void show() {36                 System.out.println("show");37             }38             39             public void show2() {40                 System.out.println("show2");41             }42         }.show();43         44         new Inter() {45             public void show() {46                 System.out.println("show");47             }48             49             public void show2() {50                 System.out.println("show2");51             }52         }.show2();53         */54         55         //如果我是很多个方法，就很麻烦了56         //那么，我们有没有改进的方案呢?57         Inter i = new Inter() { //多态58             public void show() {59                 System.out.println("show");60             }61             62             public void show2() {63                 System.out.println("show2");64             }65         };66         67         i.show();68         i.show2();69     }70 }71 72 class InnerClassDemo6 {73     public static void main(String[] args) {74         Outer o = new Outer();75         o.method();76     }77 }

 1 interface Person1{ 2     public abstract void study(); 3 } 4  5 //class student implements Person1{ 6 // 7 //    @Override 8 //    public void study() { 9 //        System.out.println("好好学习 天天向上");10 //    }11 //    12 //}13 14 class personDemo{15     public void show(Person1 p){16         p.study();17     }18 }19 20 public class outer {21     public static void main(String[] args) {22         personDemo pd = new personDemo();23 //        Person1 p = new student();24 //        pd.show(p);25         //匿名内部类的本质是接口的实现类或者父类的子类的对象26         pd.show(new Person1(){27 28             @Override29             public void study() {30                 System.out.println("jjz 好好学习 天天向上");31                 32             }33             34         });35     }36 }

 1 /* 2     匿名内部类面试题： 3         按照要求，补齐代码 4             interface Inter { void show(); } 5             class Outer { //补齐代码 } 6             class OuterDemo { 7                 public static void main(String[] args) { 8                       Outer.method().show(); 9                   }10             }11             要求在控制台输出”HelloWorld”12 */13 interface Inter { 14     void show(); 15     //public abstract16 }17 18 class Outer { 19     //补齐代码20     public static Inter method() {21         //子类对象 -- 子类匿名对象22         return new Inter() {23             public void show() {24                 System.out.println("HelloWorld");25             }26         };27     }28 }29 30 class OuterDemo {31     public static void main(String[] args) {32         Outer.method().show();33         /*34             1:Outer.method()可以看出method()应该是Outer中的一个静态方法。35             2:Outer.method().show()可以看出method()方法的返回值是一个对象。36                 又由于接口Inter中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。37         */38     }39 }