黑马程序员__内部类__修饰符

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一内部类

将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。

(1)：内部类

    内部类分别有:1,非静态成员内部类2,静态成员内部类3,局部内部类4,匿名内部类

    (1)成员内部类

       A：定义,:在一个外部类中有成员变量和成员方法,那么成员内部类就是把整个一个类当成了外部类的成员对待了

       B: 访问方式:内部类访问外部类,内部类可以直接访问外部类,包括私有成员,因为内部类拥有外部类的引用是类名.this

               外部类访问内部类,外部类访问外部类的成员,必须要建立内部类的对象

               格式:外部类名.内部类名 = 外部类对象.内部类对象;

               Outer.Inner oi =new Outer().new Inner();//outer代表外部类,Inner代表内部类

       C:存放位置:在外部类里,在外部类的成员方法外.

       D:修饰符:final、abstract、public、private、protected和static等,那么被static修饰的就是下面所说的

静态内部类.

*

    内部类：

 

    1.在一个类的内部，还可以定义类，这个定义在一个类内的类叫：内部类

    2.实例化一个内部类，一定要先实例化外部类

    3.内部类可以访问外部类的成员

    4.外部类中可以实例化内部类对象；

*/

[java]   view plain copy

1. class Outside{  
2.     private int num = 10;  
3.       
4.     class Inside{  
5.         void show(){  
6.             System.out.println("Inside show() num = "  + num);  
7.         }  
8.     }  
9.   
10.     public void show(){  
11.         Inside inner = new Inside();  
12.         inner.show();  
13.     }  
14. }  
15. class Demo   
16. {  
17.     public static void main(String[] args)   
18.     {  
19.         //实例化一个内部类对象前，先要实例化外部类对象  
20.         //方式一：  
21.         Outside outter = new Outside();  
22.         Outside.Inside inner = outter.new Inside();  
23.       
24.         //方式二：  
25.     //  Outside.Inside inner = new Outside().new Inside();  
26.         inner.show();  
27.         outter.show();  
28.     }  
29. }  

(2)静态内部类

       A：定义,就是在成员内部类的基础上加上static

       B：格式:外部类名.内部类名 = 外部类名.内部类对象;

               Outer.Inner oi =new Outer.Inner();

        C:存放位置:和成员内部类一样,就是多了个static

/*

静态内部类

1.内部类可以被修饰为static；

2.实例化静态内部类时，不需要外部类对象；

3.静态内部类如果需要访问外部类成员，那么外部类成员也必须是静态的；

4.一个内部类中如果包含静态成员，那么这个内部类也必须是静态的；

*/

[java]   view plain copy

1. class Outside  
2. {  
3.     static int num = 10;  
4.     static class Inside{  
5.         static void show(){  
6.             System.out.println("Inside show() num = " + num);  
7.         }  
8.     }  
9. }  
10. class Demo   
11. {  
12.     public static void main(String[] args)   
13.     {  
14.         Outside.Inside inner =new  Outside.Inside();  
15.         inner.show();  
16.         Outside.Inside.show();  
17.     }  
18. }  

(3)局部内部类

       A：定义,在外部类成员方法中定义的内部类,他更像局部变量

       B: 注意:

          第一:方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。

          第二:方法内部类对象不能使用该内部类所在方法的非final局部变量。因为方法的局部变量位于栈上，

               只存在于该方法的生命期内。当一个方法结束，其栈结构被删除，局部变量成为历史。

               但是该方法结束之后，在方法内创建的内部类对象可能仍然存在于堆中！

               例如，如果对它的引用被传递到其他某些代码，并存储在一个成员变量内。

               正因为不能保证局部变量的存活期和方法内部类对象的一样长，所以内部类对象不能使用它们。

          第三:方法内部类的修饰符。与成员内部类不同，方法内部类更像一个局部变量。可以用于修饰方法内部类

               的只有final和abstract。

           第四:静态方法内的方法内部类。静态方法是没有this引用的，因此在静态方法内的内部类遭受同样的待遇，

               即：只能访问外部类的静态成员。

/*

    局部内部类

 

    1.一个类可以定义在方法体中，称为：局部内部类

    2.一般情况下，需要局部内部类实现一个接口，我们在外部可以获取

      这个局部内部类的对象；将此方法的返回值定义为接口类型；

    3.局部内部类访问局部变量，要求局部变量必须被声明为：final,否则编译错误！

*/

[java]   view plain copy

1. IA getInstance(){  
2.   
3.             final  int num2 = 20;  
4.               
5.             class Inside implements IA{  
6.                 public void show(){  
7.                     System.out.println("Inside show() num2 = " + num2);  
8.                 }  
9.             }  
10.   
11.             Inside inner = new Inside();  
12.             return inner;  
13.         }  
14.     }  
15.     class Demo  
16.     {  
17.         public static void main(String[] args)   
18.         {  
19.             Outside out = new Outside();  
20.             IA aObj = out.getInstance();  
21.             aObj.show();  
22.         }  
23.     }  

(4)匿名内部类：没有名字的内部类。它是内部类的简化写法。

       A：前提：内部类可以继承或实现一个外部类或者接口。

       B：格式为：new 外部类名或者接口名(){覆盖类或者接口中的抽象的方法，(也可以自定义内容。)}

       C：简单理解：就是建立一个带内容的外部类或者接口的子类的匿名对象。

       D: a,继承式的匿名内部类

          b,接口式(也可以叫实现式的,名字无所谓)的匿名内部类

          c,参数式的匿名内部类

       多加一句:我的理解,其实与其说是匿名内部类,我个人认为说是匿名对象更确切一点(个人理解,仅供参考);

//有名字的内部类

[java]   view plain copy

1. class Outer {  
2.             public void method(){  
3.                 class Inner implements Inter {  
4.                     public void show1(){  
5.                         System.out.println("show1");  
6.                     }  
7.   
8.                     public void show2(){  
9.                         System.out.println("show1");  
10.                     }  
11.                 }  
12.             }  
13.             public void show() {  
14.                 Inter in = new Inner();//父类引用指向子类对象  
15.                 in.show1();  
16.                 in.show2();  
17.   
18.             }  
19.         }  

//匿名内部类(重点,android里面用的多,awt的监听器用的多)

[java]   view plain copy

1. class Outer {  
2.             public void method() {  
3.                 //匿名内部类对象调用方法  
4.                 new Inter() {  
5.                     public void show1() {  
6.                         System.out.println("show1");  
7.                     }  
8.   
9.                     public void show2() {  
10.                         System.out.println("show1");  
11.                     }  
12.                 }.show1();  
13.   
14.                 new Inter() {  
15.                     public void show1() {  
16.                         System.out.println("show1");  
17.                     }  
18.   
19.                     public void show2(){  
20.                         System.out.println("show1");  
21.                     }  
22.                 }.show2();  
23.                 //匿名内部类对象的另一种调用方式,父类引用指向子类对象  
24.                 Inter in = new Inter() {  
25.                     public void show1() {  
26.                         System.out.println("show1");  
27.                     }  
28.   
29.                     public void show2() {  
30.                         System.out.println("show1");  
31.                     }  
32.                 };  
33.                 in.show1();  
34.                 in.show2();  
35.             }  
36.         }  

(5)什么时候使用匿名内部类呢？

       A：通常在使用方法是接口类型参数，并该接口中的方法不超过三个时，

          可以将匿名内部类作为参数传递。

四种权限：public、protected、（默认）、private

修饰类只能是：public、或（默认）；

public：包内、包外都可以访问此类；

（）默认：只能在包内；

修饰成员变量、成员方法

示例图：

公

公有成员变量和私有变量：

[java]   view plain copy

1. class Demo   
2.         {  
3.             public static void main(String[] args)   
4.             {  
5.                 Student stu = new Student();  
6.                   
7.                 /* 
8.                 stu.name = "张三"; 
9.                 stu.getName(); 
10.                 */  
11.                 stu.publicVal = "aa";  
12.                 stu.setName("张三");  
13.             }     
14.         }  
15.         public class Student   
16.         {  
17.             //对于私有成员，只能在此类中访问。(此类的其它方法可以访问这个私有成员)  
18.             private String name;  
19.               
20.             //私有方法同私有成员变量一样，只能在类内部被访问  
21.             private String getName(){  
22.                 return name;  
23.             }  
24.   
25.             //公有成员变量  
26.             public String publicVal;  
27.             //对于公有的成员(成员变量和成员方法)在其它包中的类，都可以访问  
28.             public void setName(String name){  
29.                 this.name = name;  
30.             }  
31.         }  

默认：

[java]   view plain copy

1. class Demo   
2.         {  
3.             public static void main(String[] args)   
4.             {  
5.                 Student stu = new Student();  
6.                 stu.show();  
7.             }  
8.         }  
9.         public class Student   
10.         {  
11.             void show(){  
12.                 System.out.println("Student show()");  
13.             }  
14.         }  

受保护：

[java]   view plain copy

1. import com.itcast.father.Father;  
2.                 import com.itcast.child.Child;  
3.                 class Demo   
4.                 {  
5.                     public static void main(String[] args) {  
6.                         Child c = new Child();  
7.                         c.say();//试图访问受保护的方法，不能访问。在包外，只有子类可以访问父类中受保护的方法；  
8.                     }  
9.                 }  

[java]   view plain copy

1. package com.itcast.child;  
2.   
3.             import com.itcast.father.Father;  
4.   
5.             public class Child extends Father   
6.             {  
7.                 public void say(){  
8.                     //在其它包中的子类，可以访问父类的受保护的方法  
9.                     fun();  
10.                 }  
11.             }  

[java]   view plain copy

1. package com.itcast.father;  
2.   
3.             public class Father   
4.             {  
5.                 void fun(){  
6.                     System.out.println("Father fun()");  
7.                 }  
8.                 protected void show(){  
9.                     System.out.println("is Father show()");  
10.                 }  
11.             }