Javase之内部类概述

￡神魔★判官ぃ 2022-03-14 10:00 173阅读 0赞

### 内部类概述 ###

*  把类定义在其他类的内部就称为内部类

class A{ 
    
    	class B{ 
    
    	}
    
    }

> B就称为内部类，A称为外部类。

*  内部类的访问特点
    
    1.  内部类直接访问外部类成员，包括私有。
    2.  外部类要访问内部类要创建对象。
    3.  内部类可用static修饰，它可以看作外部类的成员。
 *  内部类的位置
    
    1.  成员位置：在成员位置定义的类，称为成员内部类。
    2.  局部位置：在局部位置定义的类，称为局部内部类。
        
            class Outer{ 
            
            	private int num = 10;
            
            	//成员内部类
            
            	class Inner1{ 
            
            	}
            
            	public void method(){ 
            
            		//局部内部类
            
            		class Inner2{ 
            
            		}
            
            	}
            
            }
        
        
    
     *  成员内部类
        
         *  访问方式：**外部类名.内部类名 对象名 = 外部类对象.内部类对象** （因为一般非静态成员可只能通过对象访问）
            
            > Outer.Inner obj = new Outer().new Inner();
         *  修饰符
            
            private ：保证数据的安全行。
            
            static ：为了方便访问数据。
            
            > 注意：静态内部类访问外部成员时，只能访问外部的静态成员。
            > 
            > **此时访问内部类的方式为：外部类名.内部类名 对象名 = new 外部类名.内部类名（）;** （因为静态成员可直接通过类名访问）
            > 
            > eg: Outer.Inner obj = new Outer.Inner();
         *  注意：
            
            1.内部类与外部类没有继承关系。
            
            2.内部类若要访问外部类的非静态成员，要**通过外部类名限定this对象**。(**Outer.this**)
            
            >     class Outer{ 
            >     
            >     	public int num = 10;
            >     
            >     	class Inner1{ 
            >     
            >     		public int num = 20;
            >     
            >     		public void show(){ 
            >     
            >     			int num = 30;
            >     
            >     			System.out println(num);
            >     
            >     			System.out println(this.num);
            >     
            >     			System.out println(outer.this.num);
            >     
            >     		}
            >     
            >     	}
            >     
            >     }
            > 
            > out:
            > 
            > 30
            > 
            > 20
            > 
            > 10
     *  局部内部类
        
        > 1.可直接访问外部类的成员。
        > 
        > 2.在局部位置，可创建内部类对象，通过对象调用内部类的方法，来使用局部内部类的功能。
        
         *  局部内部类访问局部变量的注意事项：
            
            > 1.局部内部类访问的局部变量必须要被final修饰。
            > 
            > 2.原因：局部变量随着方法的调用而调用，方法调用完毕就消失。而堆内存的内容不会立即消失，所以，要用final修饰局部变量。加入final修饰后，所有调用这个变量的地方就变成常量数据，常量在内存中存在是固定的，故即使局部变量随着方法调用而消失，数据依旧存在。
            > 
            >     class Outer{ 
            >     
            >     	private int num1 = 10;
            >     
            >     	public void method(){ 
            >     
            >     		//局部内部类
            >     
            >     		final int num2 = 20;
            >     
            >     		class Inner{ 
            >     
            >     			public void show(){ 
            >     
            >     				System.out.println(num1);
            >     
            >     				//从内部类访问本地变量num2；num2需要被申明为最终类型。
            >     
            >     				System.out.println(num2);
            >     
            >     			}
            >     
            >     		}
            >     
            >     	}
            >     
            >     }
 *  匿名内部类
    
    > 内部类的简化写法
    > 
    > 前提：存在一个类（抽象类）或接口。
    > 
    > 格式：
    > 
    >  new 类名（抽象类名）或接口名（）\{
    > 
    >  重写方法；
    > 
    >  \}
    > 
    > 本质：是一个继承该类或实现改接口的子类的匿名对象。
    
        interface Inter { 
            public abstract void show();
            public abstract void show2();
        }
        
        class Outer { 
            public void method() { 
                new Inter(){ 
                    public void show() { 
                        System.out.println("show");
                    }
                    //只调用一个匿名内部类的方法时直接在new出的对象后面加要调用的方法名。
                }.show();
                //若要调用匿名内部类的多个方法则把匿名内部类变成有名的。(通过多态)
                Inter i = new Inter(){ 
                    public void show() { 
                        System.out.println("show");
                    }
                     public void show2() { 
                        System.out.println("show2");
                    }            
                }
                i.show();
                i.show2();
            }
        }
        class Main { 
            public static void main(String[] args) { 
                Outer o = new Outer();
                o.method();
            }
        }
    
     *  匿名内部类的应用
    
        interface Inter { 
            public abstract void show();
        }
        
        class InterTest { 
            //接口作为形参，要的不是接口而是接口的实现类
            public void method(Inter p) { 
                p.show();
            }
        }
        
        class InterImp implement Inter { 
            public void show() { 
                System.out.println("show");
            }
        }
        
        class Outer { 
            public static void main(String[] args) { 
                InterTest it = new InterTest();
                Inter i = new InterImp();
                it.show();
                
                //匿名内部类在开发中的使用
                //匿名内部类的本质是继承该类或实现改接口的子类的匿名对象。
                //作用：方法结束匿名内部类就被回收节省资源。
                it.show(new Inter() { 
                    public void show() { 
               	 		System.out.println("show");
            		}
                });
            }
        }
    
     *  匿名内部类的案例
    
    > 补齐代码：  
    > interface Inter \{ void show();\}
    > 
    > class Outer \{  
    > //补齐代码  
    > \}
    > 
    > class Main \{  
    > public static void main(String\[\] args)\{  
    > Outer.method().show();  
    > \}  
    > \}
    > 
    > //要求输出“hello world”

interface Inter {  void show();}
    
     class Outer { 
         //补齐代码
         public static Inter method(){ 
             return new Inter(){ 
                 public static void show(){ 
                     System.out.println("hello world");
                 }  
             };
         }
     }
    
     class Main { 
         public static void main(String[] args){ 
             Outer.method().show();
             //由Outer.method()可以看出method()为静态方法，而Outer.method().show();
             //则说明method()方法的返回值类型为Inter所以
         }
     }