疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java基础之内部类


 

 
1、java中的内部类都有什么?!
 
    成员内部类
 
    局部内部类
 
    匿名内部类
 
    静态内部类
 
2、内部类详解
 
    •成员内部类
 
      在一个类的内部再创建一个类,成为内部类
 
      1)在一个类中使用内部类,可以在内部类中直接存取所在类的私有属性或方法
 
复制代码
 1 class Outer{
 2     //外部类Outer
 3     private int i = 111 ;//外部类私有变量
 4     class Inner{
 5         //内部类Inner
 6         private int j = 222 ;//内部类私有变量
 7         public void print(){
 8             System.out.println("外部类的私有属性"+ i);
 9             System.out.println("内部类的私有属性"+ j);
10         }
11     }
12 }
13 public class ClassDemo5 {
14     public static void main(String[] args) {
15         Outer o = new Outer() ;
16         Outer.Inner i = o.new Inner() ; 
17         i.print() ;
18     }    
19 }
复制代码
       2)内部类的实例化方法
 
import 面向对象基础.Outer.Inner;  
//第一种方式:导入import 面向对象基础.Outer.Inner;包
Outer.Inner i = o.new Inner() ;
 //第二种方式:外部类.内部类 对象名 = 外部类对象.new 内部类
         3)外部类访问内部类
 
复制代码
 1 class Fatch{
 2     //外部类Fatch
 3     public class Student{
 4         //内部类Student
 5         public void show(){
 6             //内部类show()方法
 7             System.out.println("内部类Student的show()方法");
 8         }
 9     }
10     public void print(){
11         /**
12          * 外部类不可以直接访问内部类的属性或方法,
13          * 必须创建内部类对象才可以访问
14          */
15         new Student().show() ;    //使用匿名对象实例化调用内部类的类成员
16         System.out.println("外部类Fatch的print()方法");
17     }
18 }
19 public class ClassDemo4 {
20     public static void main(String[] args) {
21         Fatch f = new Fatch() ;    //实例化外部类对象
22         f.print() ;    //调用外部类的print()方法
23     }
24 }
复制代码
      4)如果外部类和内部类具有相同的成员变量或方法,内部类默认访问自己的成员变量或方法,如果要访问外部类的成员变量,可以使用 this 关键字。
 
复制代码
 1 class Outer1 {
 2     //外部类
 3     private int i = 10 ;//外部类私有变量
 4     class Inner1{
 5         //内部类
 6         private int i = 20 ;//内部类私有变量
 7         public void show(){
 8             //内部类方法
 9             System.out.println("内部类的变量"+ this.i );//使用this关键字访问内部类成员
10             System.out.println("外部类的变量"+ Outer1.this.i);//使用外部类名.this.变量名 来访问外部类成员
11         }
12     }
13     public void print(){
14         new Inner1().show() ;    //调用内部类方法
15     }
16 }
17 public class ClassDemo6 {
18     public static void main(String[] args) {
19         new Outer1().print() ;  
20     }
21 
22 }
复制代码
   
 
        •注意点:
 
          »实例化内部类之前必须实例化外部类
 
          »内部类可以随意访问他的外部类成员,但外部类不可以直接访问内部类的类成员
 
          »内部类可以被声明为private 或 protected 权限的访问
 
          »内部类对象会依赖于外部类对象,除非已经存在一个外部类对象,否则类中不会出现内部类对象
 
 
 
    •局部内部类(方法内部类)
 
      内部类不仅可以在类中进行定义,也可以在类的局部位置进行定义,例如在类的方法或者任意的作用域中都可以定义内部类
 
         1)在外部类的方法中定义一个方法内部类
 
复制代码
 1 class Demo1{
 2     //外部类Demo
 3      final int I = 10 ;//外部类定义的常量
 4      public void show(){    //外部类的show()方法
 5          class Inne{        //方法内部类
 6              int j = 20 ;    //方法内部类变量
 7              private void inshow() {    //方法内部类中的inshow()方法
 8                  System.out.println("外部类常量"+ I );
 9                  System.out.println("方法内部类变量"+ j );
10             }
11          }
12          Inne in = new Inne()  ;    //实例化内部类对象
13          in.inshow() ;    //调用内部类方法
14      }
15 }
16 public class ClassDemo7 {
17     public static void main(String[] args) {
18         Demo1 d = new Demo1() ;
19         d.show() ;
20     }
21 }
复制代码
    注意:如果方法中的参数需要被传递进去,就必须把参数声明成final类型
 
 
 
      •静态内部类
 
      如果一个内部类被声明为static,此内部类就称为外部类 
 
       1)静态内部类可以通过(new 外部类名.内部类.内部类方法名) ,来调用静态内部类方法
 
复制代码
 1 class Outer2{
 2     //外部类
 3     private static String str = "张博杰" ;//外部类的静态变量
 4     static class Inner2{
 5         //使用static声明 的静态内部类
 6         public void fun() {
 7             //静态内部类方法
 8             System.out.println("外部类的静态变量"+" "+ str);
 9         }
10     }
11 }
12 public class ClassDemo8 {
13     public static void main(String[] args) {
14         new Outer2.Inner2().fun() ;
15         //静态内部类可以使用new 外部类名.内部类.内部类方法名 ,来调用静态内部类方法
16     }
17 }
复制代码
 
 
       
 
        •匿名内部类
 
          匿名内部类也就是没有名字的内部类,正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写.使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口
 
          1)匿名内部类的实现
 
复制代码
 1 abstract class A2 {    //抽象类A2
 2     public abstract void eat() ;
 3 }
 4 public class ClassDemo9 {
 5     public static void main(String[] args) {
 6         /**
 7          * 如果A2这个抽象类只用一次,那么就可一使用匿名内部类来实现
 8          */
 9         A2 a = new A2(){
10             public void eat(){
11                 System.out.println("我要吃饭");
12             }
13         } ;
14         a.eat() ;
15     }
16 }