精华内容
下载资源
问答
  • 特点 不能用public private static 修饰 ...外部必然无法实例局部类 使用 import lombok.extern.java.Log; import lombok.extern.slf4j.Slf4j; @Slf4j public class LocalInnerClassTest { private ...

    特点

    1. 不能用public private static 修饰类
    2. 访问方法内的变量必须是finnal类型
    3. 在方法体内返回实例
    4. 外部类必然无法实例局部类

    使用

    
    import lombok.extern.java.Log;
    import lombok.extern.slf4j.Slf4j;
    @Slf4j
    public class LocalInnerClassTest {
        private String outpara1="out param 1";
        private static String outpara2="out param 2";
        
        interface Inner{
            void print();
        }
    
        public Inner testLocalClass(){
            final String localInput="localInput";
           class LocalClass implements Inner{
                    private String innerpara1="out param 1";
                    
                    private final   String innerpara2="out param 2";
    
                @Override
                public void print() {
                  log.info("begin print"); 
                  log.info("print {}",localInput);
                  log.info("out param1 :{}",outpara1); 
                }
    
            }
            return new LocalClass();
        }
        public static Inner testLocalClass2(){
            class LocalClass implements Inner{
                     private  String innerpara1="iner param 1";
                     
                     private   String innerpara2="iner param 2";
     
                 @Override
                 public void print() {
                   log.info("begin print"); 
                   log.info("inner param1 :{}",innerpara1); 
                   log.info("inner param2  :{}",innerpara2); 
                 }
     
             }
             return new LocalClass();
         }
        public static void main(String[] args) {
            LocalInnerClassTest test=new LocalInnerClassTest();
            test.testLocalClass().print();
            testLocalClass2().print();
        }
    }

    转载于:https://www.cnblogs.com/JuncaiF/p/11153340.html

    展开全文
  • 内部类的概述和访问特点 /* 内部类的概述和访问特点 内部类的概述 把类定义在其他类的内部,这个类就被称为内部类 内部类的访问特点; A:内部类可以直接访问外部类的成员,包括私有 B:外部类要访问...

    内部类的概述和访问特点

    /*
        内部类的概述和访问特点
    	 
    	 内部类的概述
    	     把类定义在其他类的内部,这个类就被称为内部类
     	
    	内部类的访问特点;
    	   A:内部类可以直接访问外部类的成员,包括私有
    	   B:外部类要访问内部类的成员,必须创建对象
    */
    /*
      内部类的位置
            成员位置:在成员方法的位置定义的类被称为成员内部类
    		局部位置:在局部位置(成员方法中)定义的类被称为局部内部类
    */
    
    /*
         成员内部类
    	     如何访问成员内部类
    		 格式:
    		     外部类名.内部类名 对象名 = new 外部类对象().new内部对象(); 
    */
    class Out{
    	private int num =  10;
    	
    	class Inner{
    		public void show(){
    			System.out.println(num);
    		}
    	}
    }
    class Dome{
    	public static void main(String[] args){
    		//格式:
    		   // 外部类名.内部类名 对象名 = new 外部类对象().new内部对象();
    		   Outer.Inner oi = new Outer().new Inner();
    		   io.show();
    	} 
    }
    

    成员内部类

    //成员内部类的修饰符
    /*
      成员内部类的修饰符
        第一个 private:为了保证数据的安全性
    	  
      案例:我有一身体,身体内有心脏
    	    class Body{
    			   private class Heart{
    				   public void operator(){
    					    System.out.println("心脏搭桥");
    				   }
    			   }
    			public void method(){
    				if(如果你是医生){
    					Heart  h = new Heart();
    					h.operator();
    				}
    			}   
    		}  
    		
    		按照我们刚才的讲解,来使用一下
    		Boy.Heart bh = new Body().new Heart();
    		bh.operator();
    		加了private后,就不能被访问了
    		Body b = new Body();
    		b.method();
    */
    
    /*
         成员内部类的修饰符
                 static:为了数据访问更方便
    			    注意:静态内部类访问的外部数据必须用静态修饰
    */
    class Outer{
    	private int num = 10;
    	private static int num2=100;
    	//内部类用静态修饰是因为内部类可以看出是外部类的成员
    	public static class Inner{
    	       public void show(){
    		          // System.out.println(num);
    				  System.out.println(num2);
               }
    		   public static void show2(){
    			       //System.out.println(num);
    				   System.out.println(num2);
    		   }
    	}  
    }
    class Dome{
    	public static void mian(String[] args){
    	     //使用内部类
    		 //编译错误:限定新静态类
    		 //Outer.Inner oi = new Outer().new Inner();
    		 //oi.show();
    		 //oishow2();
    		 
    		 //成语内部类被静态修饰后的访问方式是:
    		 //格式:外部类名.内部类名  对象名 = 外部类名.内部类名();
    		 
    		 //静态可以通过类名调用
    		 //show2的另一种调用方式
    		 Outer.Inner.show2();
    	}
    }
    /*
      面试题:
          要求:分别输出30 20 10;
    	注意:
           1.内部类和外部类没有继承关系
           2.通过外部类名限定this对象	   
    */
    class Outer{
    	public int num = 10;
    	   class Inner{
    		   public int num = 20;
    		   public void show(){
    			   int num = 30;
    			   System.out.println(num);
    			   System.out.println(this.num);
    			   //System.out.println(new Outer().num);另一方式
    			   System.out.println(Outer.this.num);
    		   }
    	   }
    }
    class  Dome{
    	public static void mian(String[] args){
    		Outer.Inner oi = new Outer().new Inner();
    		oi.show();
    	}
    }
    

    局部内部类

    /*
          局部内部类
                  A:可以直接访问外部类的成员
    			  B:在局部位置,可以创建内部类对象,通过调用内部类方法,来使用内部类功能
    			  
    	面试题:
            局部内部类访问局部变量的注意事项?
               A:局部内部类访问局部变量,局部变量必须用final修饰		
    			B:为什么?
                    局部变量是随着方法的调用而调用,随着调用完毕而消失。
                    而对内存的内容并不会立即消失。所以我们加fianl修饰。
                    加入final修饰后,这个变量就变成了常量。既然是常量。你消失了
                    而我在内存中存储的是数据20,所以,我还是有数据在使用				
    			  
    */
    class Outer{
    	private int num = 10;
    	
    	public void methon(){
    		final int num2 = 20;
    		class Inner{
    			public void show(){
    				System.out.println(num);
    				//从内部类中访问本地变量num2;需要被声明为最终型
    				System.out.println(num2);
    			}
    		}
    		Inner i = new Inner();
    		i.show();
    	}
    }
    class  Dome{
    	public static void mian(String[] args){
    		Outer o = new Outer();
    		o.methon();
    	}
    }
    

    匿名内部类

    /*
         匿名内部类
    	       就是内部类的简化写法
    		   
    	前提:存在一个类或者接口	   
    	     这里的类可以是具体的类也可以是抽象类
    	 
    	 格式:
    	    new 类名或者接口名(){
    			重写方法;
    		}
    	 本质;
    	     是一个继承来该类或者实现了该接口的子类匿名对象。
    */
    interface Inter{
    	public static void show();
    	public static void show2();
    }
    class Outer{
    	//一个方法的时候
    	publc void method(){
    		new Inter(){
    			public static void show(){
    				System.out.println("show");
    			}
    		}.show();
    	}
    	//两个方法时候,就需要写两次匿名对象一次只可以调用一次
    	publc void method(){
    		new Inter(){
    			public static void show(){
    				System.out.println("show");
    			}
    			public static void show2(){
    				System.out.println("show2");
    			}
    		}.show();
    	}
    	publc void method(){
    		new Inter(){
    			public static void show(){
    				System.out.println("show");
    			}
    			public static void show2(){
    				System.out.println("show2");
    			}
    		}.show2();
    	}
    	//如果我是有很多个方法,就很麻烦了
    	//那么,我们有没有改进方法呢?
    	//多态
    	Inter i = new Inter(){
    		    public static void show(){
    				System.out.println("show");
    			}
    			public static void show2(){
    				System.out.println("show2");
    			}
    	};
    	i.show();
    	i.show2();
    }
    class Dome{
    	public static void main(String[] args){		
    	         Outer id = new Outer();
    			 id.method();
    	} 
    }
    /*
      匿名内部类在开发中的使用
    */
    interface Person{
          public  abstract void study();	
    }
    class PersonDome{
    	//接口名作为形式参数
    	//其实这里需要的不是接口,而是该接口的实现类的对象
    	public void method(Person p){
    		p.study();
    	}
    }
    //实现类
    class Studtent implements Person{
    	public void study{
    		System.out.println("好好学习,天天向上");
    	}
    }
    class Dome{
    	public static void main(String[] args){
    		PersonDome i = new PersonDome();
    		Person p = new Studtent();
    		i.method(p);
    		
    		//匿名内部类在开发中的使用 
    		//匿名内部类的本质继承类或者实现了接口的子类匿名对象
    		i.method(new Person(){
    			public void study(){
    				System.out.println("好好学习,天天向上");
    			}
    		});
    	}
    }
    /*
        面试题
    	按照要求,补齐代码
    	  interface Inter{void show();}
    	  class Outer{//补齐代码}
    	  class OutDome{
    		  public static void mian(string[] args){
    			  Outer.method.show();
    		  }
    	  }
    	  要求在控制台输出“Hello Word”
    */
     interface Inter{
    	 void show();
    }
    class Outer{
    		 public static inter method(){
    			return new Inter(){
    				 public void show(){
    					 System.out.println("Hello Word");
    				 }
    			 };
    		 }
    }
    class OutDome{
    	public static void mian(string[] args){
    		  Outer.method.show();
    		  /*
    		  1.Outer.method()可以看出method应该是Outer中的一个静态方法
    		  2.Outer.method.show();可以看出methon()方法的返回值是一给个对象
    		          又因为接口Inter中有一个show方法,所以我认为method()方法的返回值类型是一个接口
    		  */
        }
    }
    
    展开全文
  • 目录成员内部类定义成员内部类特点如何使用成员内部类静态内部类定义静态内部类的特点如何使用静态内部类局部内部类定义局部内部类的特点如何使用局部内部类匿名内部类定义前提格式:匿名内部类的特点如何使用匿名...

    成员内部类

    定义

    • 成员内部类 :定义在外部类中方法外的类

    定义格式:

    [修饰符] class 外部类名 [extends 外部类的父类] [implements 外部类的父接口们] {
        [修饰符] class 内部类名 [extends 非静态内部类自己的父类] [implements 非静态内部类的父接口们] {
            静态内部类的成员列表;
    	}
    	// 外部类的其他成员列表
    }
    

    外部类、内部类的父类、父接口没有关系,各是各的

    成员内部类特点

    • 成员内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件,但是前面冠以外部类的类名和Outer符号。例如:OuterInner.class

    • 成员内部类可以使用修饰符public,protected,缺省,private

    • 成员内部类还可以使用final或abstract修饰

    • 成员内部类中不可以声明静态成员

    • 成员内部类可以直接使用外部类的所有成员,包括私有的。如果成员内部类有与外部类的非静态属性重名时,可以通过“外部类名.this.属性”进行区别,如果与外部类的静态属性重名时,可以通过“外部类名.类变量”进行区别

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

    如何使用成员内部类

    • 在外部类中使用成员内部类:

      • 在外部类的静态成员中不能使用非静态的成员内部类
      • 在外部类的非静态成员中,直接创建内部类的对象来访问内部类的属性与方法。此时把它当做一个普通的类即可
    • 在外部类的外面使用成员内部类:

      • 要么通过外部类的对象,去创建内部类的对象

        外部类名 外部对象名 = new 外部类型();
        内部类名 对象名 = 外部对象名.new 外部类型();
        //可合并为:
        外部类名.内部类名 对象名 = new 外部类型().new 内部类型();
        
      • 要么通过外部类的对象,去获取内部类的对象

        Outer out = new Outer();
        Outer.Inner in  = out.getInner();
        

    代码演示:

    public class MemberClassTest {
    
        public static void main(String[] args) {
            Outer out = new Outer();
            out.outerMethod();
    		//通过外部类的对象,去创建内部类的对象
            Outer.Inner oi = out.new Inner();
            oi.innerMethod();
    		//通过外部类的对象,去获取内部类的对象
            Outer.Inner obj = out.getInner();
            obj.innerMethod();
        }
    
    }
    class Outer{
        private int a = 1;
        private static int b = 2;
        public static void outerStaticMethod(){
    		/*Inner in = new Inner();//错误,静态成员中不能使用非静态成员内部类
    		in.innerMethod();*/
        }
        public void outerMethod(){
            System.out.println("外部类的方法");
    		/*Inner in = new Inner();//可以
    		in.innerMethod();*/
        }
        class Inner{
            private int a = 3;
            private int b = 4;
            public void innerMethod(){
                System.out.println("内部类的方法");
                System.out.println("内部类的方法访问外部类的私有非静态属性:"+Outer.this.a);
                System.out.println("内部类的方法访问外部类的私有静态属性:"+Outer.b);
            }
        }
        //通过外部类的某个方法返回内部类的对象
        public Inner getInner(){
            return new Inner();
        }
    }
    
    外部类的方法
    内部类的方法
    内部类的方法访问外部类的私有非静态属性:1
    内部类的方法访问外部类的私有静态属性:2
    内部类的方法
    内部类的方法访问外部类的私有非静态属性:1
    内部类的方法访问外部类的私有静态属性:2
    

    静态内部类

    定义

    静态内部类:定义在外部类中方法外,使用 static 修饰的类

    定义格式:

    [修饰符] class 外部类名 [extends 外部类的父类] [implements 外部类的父接口们] {
    	[修饰符] static class 内部类名 [extends 静态内部类自己的父类] [implements 静态内部类的父接口们] {
            静态内部类的成员列表;
    	}   
    	// 外部类的其他成员列表
    }
    

    静态内部类的特点

    • 静态内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件,但是前面冠以外部类的类名和Outer符号。例如:OuterInner.class

    • 静态内部类可以使用修饰符public,protected,default,private

    • 静态内部类还可以使用final或abstract修饰

    • 静态内部类中可以声明静态成员

    • 静态内部类可以直接使用外部类的静态成员,包括私有的。但不能使用外部类的非静态成员

    • 静态内部类中有与外部类的静态属性重名时,如果要使用外部类的属性,那么用“外部类名.属性”

    如何使用静态内部类

    • 在外部类中使用静态内部类:就和使用其他普通类一样

    • 在外部类的外面使用成员内部类:

      • 使用静态内部类的静态成员:外部类名.静态内部类名.静态内部类的静态成员
      • 使用静态内部类的非静态成员:外部类名.静态内部类名 obj = new 外部类名.静态内部类名(); obj.静态内部类的非静态成员

    代码演示:

    public class StaticInnerClassTest {
    
        public static void main(String[] args) {
            Outer.StaticInnerClass.innerStaticMethod();
            Outer.StaticInnerClass os = new Outer.StaticInnerClass();
            os.innerMethod();
        }
    
    }
    class Outer{
        public static void outerStaticMethod(){
            StaticInnerClass.innerStaticMethod();
            StaticInnerClass si = new StaticInnerClass();
            si.innerMethod();
        }
        public static void outerMethod(){
            StaticInnerClass.innerStaticMethod();
            StaticInnerClass si = new StaticInnerClass();
            si.innerMethod();
        }
        static class StaticInnerClass{
            public static void innerStaticMethod(){
                System.out.println("内部类的静态方法");
            }
            public void innerMethod(){
                System.out.println("内部类的非静态方法");
            }
        }
    }
    

    局部内部类

    定义

    • 局部内部类:定义在方法内、代码块内、构造器内

    定义格式:

    [修饰符] class 外部类名 [extends 外部类的父类] [implements 外部类的父接口们] {
    	[修饰符] 返回值类型  方法名([形参列表]){
            [修饰符] class 内部类名 [extends 局部内部类自己的父类] [implements 局部内部类的父接口们] {
            	局部内部类的成员列表;
    		}
    	}	
    	// 外部类的其他成员列表
    }
    

    局部内部类的特点

    • 局部内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件:“外部类的类名$数字编号内部类名.class”。

    • 局部内部类和局部变量地位类似,不能使用 public,protected,private,static 这些成员修饰符,但是可以使用abstract或final

    • 局部内部类不能使用static修饰,因此也不能包含静态成员。

    • 只能在声明它的方法或代码块中使用,而且是先声明后使用。除此之外的任何地方都不能使用该类,因为作用域的问题。

    • 局部内部类可以使用外部类的成员,包括私有的。但是是否可以使用外部类的非静态成员要看所在方法是否是非静态的。

    • 局部内部类可以使用包含它的外部方法中的局部变量

    如何使用局部内部类

    只能在声明它的方法或代码块中使用,而且是先声明后使用。除此之外的任何地方都不能使用该类。

    但是它的对象可以通过包含此局部内部类的外部方法的返回值返回使用,返回值类型只能是局部内部类的父类或父接口类型。

    代码演示:

    public class LocalInnerClassTest {
    
        public static void main(String[] args) {
            Outer out = new Outer();
            Object obj = out.outerMethod();
            System.out.println(obj);
            System.out.println();
        }
    
    }
    class Outer{
        int value = 5;
        public Object outerMethod(){
            final int localValue = 10;
            class LocalInnerClass {
                public void innerMethod(){
                    System.out.println("局部内部类的方法");
                    System.out.println("局部内部类的方法可以使用外部类的成员变量:"+value);
                    System.out.println("局部内部类的方法可以使用外部类的局部变量:"+localValue);
                }
            }
            //先声明后使用
            LocalInnerClass li = new LocalInnerClass();
            li.innerMethod();
            return li;
        }
    }
    局部内部类的方法
    局部内部类的方法可以使用外部类的成员变量:5
    局部内部类的方法可以使用外部类的局部变量:10
    demo3.Outer$1LocalInnerClass@6b2fad11
    

    匿名内部类

    定义

    • 匿名内部类本质是一个带具体实现的 父类或者父接口的 匿名的 子类对象

    如果接口的实现类(或者是父类的子类)只需要使用唯一的一次,那么这种情况下就可以省略该类的定义,而改为使用【匿名内部类】。

    特征:声明匿名内部类的同时创建该类的对象

    前提

    存在一个或者接口,这里的类可以是抽象类也可以是普通类

    格式:

    继承父类:

    new 父类名称([实参列表]){
        // 类的成员列表
    };
    

    说明:如果子类调用的是父类的无参构造,那么()中实参列表不用写,如果子类调用的是父类的有参构造,那么就在()中传入实际参数

    实现接口:

    new 接口名称(){
        // 类的成员列表
    };
    

    接口不是不能实例化创建对象吗,new关键字的后面为什么跟着接口名?

    对格式“new 接口名称() {…}”进行解析:

    1. new代表创建对象的动作
    2. 接口名称表示匿名内部类需要实现哪个接口
    3. {…}是匿名内部类的内容

    匿名内部类的特点

    • 匿名内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件::外部类名$数字编号.class

    • 匿名内部类必须继承父类或实现接口

    • 匿名内部类只能有一个对象

    • 匿名内部类对象只能使用多态形式引用

    • 匿名内部类是特殊的局部内部类,局部内部类的所有限制对它都适用

    如何使用匿名内部类

    以接口举例,当你使用一个接口时,似乎得做如下几步操作:

    1. 定义接口实现类
    2. 重写接口中的方法
    3. 创建子类对象
    4. 调用重写后的方法

    我们的目的,最终只是为了调用方法,那么能不能简化一下,把以上四步合成一步呢?

    案例需求:

    定义笔记本电脑类,电脑有USB接口,通过插入鼠标、键盘等不同设备,实现各自不同功能。

    传统方式:

    定义接口:

    public interface USB {
        // 使用USB设备的方法
        public void use();
    }
    

    定义笔记本类,定义鼠标类、键盘类分别实现USB接口:

    class Mouse implements USB {
        @Override
        public void use() {
            System.out.println("点击鼠标操控电脑...");
        }
    }
    
    class KeyBoard implements USB {
        @Override
        public void use() {
            System.out.println("键盘输入数据...");
        }
    }
    
    public class NoteBook {
        // USB设备插入笔记本电脑的方法,要求传递的对象要实现USB接口
        public void plugIn(USB usb) {
            usb.use();
        }
    }
    

    测试类:

    public class AnonymousClassTest {
        public static void main(String[] args) {
            NoteBook noteBook = new NoteBook();
    
            USB mouse = new Mouse();
            noteBook.plugIn(mouse);
    
            USB keyBoard = new KeyBoard();
            noteBook.plugIn(keyBoard);
        }
    }
    

    匿名内部类方式:

    定义接口:

    public interface USB {
        public void use();
    }
    

    定义笔记本电脑类:

    public class NoteBook {
        // 要求传递的对象要实现USB接口
        public void plugIn(USB usb) {
            usb.use();
        }
    }
    

    测试类:

    public class AnonymousClassTest {
        public static void main(String[] args) {
            
            NoteBook noteBook = new NoteBook();
    
            // 下面这段代码,声明了实现USB接口的匿名内部类,也创建了它的对象
            // 但是这个对象既没有赋值给一个变量,也没有直接调用方法,无法直接使用
            new USB() {
                @Override
                public void use() {
                    System.out.println("实现了USB接口");
                }
            };
    
            // 使用方式一:
            // 把创建的对象赋值给一个变量,然后调用重写的use方法
            // 多态引用
            USB mouse = new USB() {
                @Override
                public void use() {
                    System.out.println("点击鼠标操控电脑...");
                }
            };
            mouse.use();
    
            // 使用方式二:
            // 用创建的对象直接调用重写的use方法
            new USB() {
                @Override
                public void use() {
                    System.out.println("键盘输入数据...");
                }
            }.use();
    
            // 使用方式三:
            // 把创建的对象作为方法实参
            noteBook.plugIn(new USB() {
                @Override
                public void use() {
                    System.out.println("U盘传输数据...");
                }
            });
        }
    }
    

    测试结果:

    点击鼠标操控电脑…
    键盘输入数据…
    U盘传输数据…

    展开全文
  • 分四种:成员内部类、局部内部类、静态内部类和匿名内部类。 1、成员内部类: 即作为外部类的一个成员存在,与外部类的属性、方法并列。 注意:成员内部类中不能定义静态变量,但可以访问外部类的所有成员。 public ...
    Java 内部类 
    分四种:成员内部类、局部内部类、静态内部类和匿名内部类。 
    1、成员内部类: 即作为外部类的一个成员存在,与外部类的属性、方法并列。
    注意:成员内部类中不能定义静态变量,但可以访问外部类的所有成员。
    public class Outer{
    private static int i = 1;
    private int j=10;
    private int k=20;
    public static void outer_f1(){
        //do more something
    }
    public void out_f2(){
        //do more something
    }
    
    //成员内部类
    class Inner{
    //static int inner_i =100; //内部类中不允许定义静态变量
    int j=100;//内部类中外部类的实例变量可以共存
    int inner_i=1;
    void inner_f1(){
        System.out.println(i);//外部类的变量如果和内部类的变量没有同名的,则可以直接用变量名访问外部类的变量
        System.out.println(j);//在内部类中访问内部类自己的变量直接用变量名
        System.out.println(this.j);//也可以在内部类中用"this.变量名"来访问内部类变量
        //访问外部类中与内部类同名的实例变量可用"外部类名.this.变量名"。
        System.out.println(k);//外部类的变量如果和内部类的变量没有同名的,则可以直接用变量名访问外部类的变量
        outer_f1();
        outer_f2();
    }
    }
    //外部类的非静态方法访问成员内部类
    public void outer_f3(){
        Inner inner = new Inner();
        inner.inner_f1();
    }
    
    //外部类的静态方法访问成员内部类,与在外部类外部访问成员内部类一样
    public static void outer_f4(){
        //step1 建立外部类对象
        Outer out = new Outer();
        //***step2 根据外部类对象建立内部类对象***
        Inner inner=out.new Inner();
        //step3 访问内部类的方法
        inner.inner_f1();
    }
    
    public static void main(String[] args){
        outer_f4();
    }
    }
    成员内部类的优点:
    ⑴ 内部类作为外部类的成员,可以访问外部类的私有成员或属性。(即使将外部类声明为PRIVATE,但是对于处于其内部的内部类还是可见的。)
    ⑵ 用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。
    注意:内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。
    2、局部内部类: 即在方法中定义的内部类,与局部变量类似,在局部内部类前不加修饰符public或private,其范围为定义它的代码块。
    注意:局部内部类中不可定义静态变量,可以访问外部类的局部变量(即方法内的变量),但是变量必须是final的。
    public class Outer {
     private int s = 100;
     private int out_i = 1;
     public void f(final int k){
      final int s = 200;
      int i = 1;
      final int j = 10;
      class Inner{ //定义在方法内部
       int s = 300;//可以定义与外部类同名的变量
       //static int m = 20;//不可以定义静态变量
       Inner(int k){
        inner_f(k);
       }
       int inner_i = 100;
       void inner_f(int k){
        System.out.println(out_i);//如果内部类没有与外部类同名的变量,在内部类中可以直接访问外部类的实例变量
        System.out.println(k);//*****可以访问外部类的局部变量(即方法内的变量),但是变量必须是final的*****
    //    System.out.println(i);
        System.out.println(s);//如果内部类中有与外部类同名的变量,直接用变量名访问的是内部类的变量
        System.out.println(this.s);//用"this.变量名" 访问的也是内部类变量
        System.out.println(Outer.this.s);//用外部"外部类类名.this.变量名" 访问的是外部类变量
       }
      }
      new Inner(k);
     }
    
     public static void main(String[] args) {
     //访问局部内部类必须先有外部类对象
      Outer out = new Outer();
      out.f(3);
     }
    
    }
    
    注意:
    在类外不可直接生成局部内部类(保证局部内部类对外是不可见的)。要想使用局部内部类时需要生成对象,对象调用方法,在方法中才能调用其局部内部类。通过内部类和接口达到一个强制的弱耦合,用局部内部类来实现接口,并在方法中返回接口类型,使局部内部类不可见,屏蔽实现类的可见性。
    
    3、静态内部类: 静态内部类定义在类中,任何方法外,用static定义。
    注意:静态内部类中可以定义静态或者非静态的成员
    public class Outer {
     private static int i = 1;
     private int j = 10;
     public static void outer_f1(){
     
     }
     public void outer_f2(){
     
     }
    // 静态内部类可以用public,protected,private修饰
    // 静态内部类中可以定义静态或者非静态的成员
     static class Inner{
      static int inner_i = 100;
      int inner_j = 200;
      static void inner_f1(){
       System.out.println("Outer.i"+i);//静态内部类只能访问外部类的静态成员
       outer_f1();//包括静态变量和静态方法
      }
      void inner_f2(){
    //   System.out.println("Outer.i"+j);//静态内部类不能访问外部类的非静态成员
    //   outer_f2();//包括非静态变量和非静态方法
      } 
     
     }
     
     public void outer_f3(){
    //  外部类访问内部类的静态成员:内部类.静态成员
      System.out.println(Inner.inner_i);
      Inner.inner_f1();
    //  外部类访问内部类的非静态成员:实例化内部类即可
      Inner inner = new Inner();
      inner.inner_f2();
     
     }
     public static void main(String[] args) {
      new Outer().outer_f3();
     }
    
    }
    
    注意:*******生成(new)一个静态内部类不需要外部类成员:这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成:
    Outer.Inner in=new Outer.Inner();
    而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。静态内部类不可用private来进行定义。*******
    
    例子:
    对于两个类,拥有相同的方法:
    class People
    {
      run();
    }
    class Machine{
       run();
    }
    此时有一个robot类:
    class Robot extends People implement Machine.
    此时run()不可直接实现。
    注意:当类与接口(或者是接口与接口)发生方法命名冲突的时候,此时必须使用内部类来实现。用接口不能完全地实现多继承,用接口配合内部类才能实现真正的多继承。
    
    4、匿名内部类 
    匿名内部类是一种特殊的局部内部类,它是通过匿名类实现接口。
    IA被定义为接口。
    IA I=new IA(){};
    
    匿名内部类的特点:
    
    1,一个类用于继承其他类或是实现接口,并不需要增加额外的方法,只是对继承方法的事先或是覆盖。
    2,只是为了获得一个对象实例,不需要知道其实际类型。
    3,类名没有意义,也就是不需要使用到。
    
    public class Outer {
     private static int i = 1;
     private int j = 10;
     public static void outer_f1(){
     
     }
     public void outer_f2(){
     
     }
    // 静态内部类可以用public,protected,private修饰
    // 静态内部类中可以定义静态或者非静态的成员
     static class Inner{
      static int inner_i = 100;
      int inner_j = 200;
      static void inner_f1(){
       System.out.println("Outer.i"+i);//静态内部类只能访问外部类的静态成员
       outer_f1();//包括静态变量和静态方法
      }
      void inner_f2(){
    //   System.out.println("Outer.i"+j);//静态内部类不能访问外部类的非静态成员
    //   outer_f2();//包括非静态变量和非静态方法
      }
     }
     
     public void outer_f3(){
    //  外部类访问内部类的静态成员:内部类.静态成员
      System.out.println(Inner.inner_i);
      Inner.inner_f1();
    //  外部类访问内部类的非静态成员:实例化内部类即可
      Inner inner = new Inner();
      inner.inner_f2();
     
     }
     public static void main(String[] args) {
      new Outer().outer_f3();
     }
    
    }
    
    注:一个匿名内部类一定是在new的后面,用其隐含实现一个接口或实现一个类,没有类名,根据多态,我们使用其父类名。因他是局部内部类,那么局部内部类的所有限制都对其生效。匿名内部类是唯一一种无构造方法类。大部分匿名内部类是用于接口回调用的。匿名内部类在编译的时候由系统自动起名Out$1.class。如果一个对象编译时的类型是接口,那么其运行的类型为实现这个接口的类。因匿名内部类无构造方法,所以其使用范围非常的有限。当需要多个对象时使用局部内部类,因此局部内部类的应用相对比较多。匿名内部类中不能定义构造方法。如果一个对象编译时的类型是接口,那么其运行的类型为实现这个接口的类。
    
    ________________________________________________________________________________
    
    内部类总结:
    1.首先,把内部类作为外部类的一个特殊的成员来看待,因此它有类成员的封闭等级:private ,protected,默认(friendly),public
                                                          它有类成员的修饰符:   static,final,abstract
    2.非静态内部类nested inner class,内部类隐含有一个外部类的指针this,因此,它可以访问外部类的一切资源(当然包括private)
      外部类访问内部类的成员,先要取得内部类的对象,并且取决于内部类成员的封装等级。
      非静态内部类不能包含任何static成员.
    3.静态内部类:static inner class,不再包含外部类的this指针,并且在外部类装载时初始化.
      静态内部类能包含static或非static成员.
      静态内部类只能访问外部类static成员.
      外部类访问静态内部类的成员,循一般类法规。对于static成员,用类名.成员即可访问,对于非static成员,只能
        用对象.成员进行访问
    
    4.对于方法中的内部类或块中内部类只能访问块中或方法中的final变量。
    
    类成员有两种static , non-static,同样内部类也有这两种
    non-static 内部类的实例,必须在外部类的方法中创建或通过外部类的实例来创建(OuterClassInstanceName.new innerClassName(ConstructorParameter)),并且可直接访问外部类的信息,外部类对象可通过OuterClassName.this来引用
    static 内部类的实例, 直接创建即可,没有对外部类实例的引用。
    内部类不管static还是non-static都有对外部类的引用
    non-static 内部类不允许有static成员
    
    方法中的内部类只允许访问方法中的final局部变量和方法的final参数列表,所以说方法中的内部类和内部类没什麽区别。但方法中的内部类不能在方法以外访问,方法中不可以有static内部类
    匿名内部类如果继承自接口,必须实现指定接口的方法,且无参数 
    匿名内部类如果继承自类,参数必须按父类的构造函数的参数传递
    展开全文
  • 包括实例内部类、匿名内部类、静态内部类和局部内部类的特点和使用方法 1. 实例内部类 成员内部类的一种,没有static修饰,实例内部类具有以下特点 在创建实例内部类的实例时,外部类的实例必须已经存在,想创建...
  • 局部内部类的特点:1.可以直接访问外部类的成员。2.在局部位置,可以创建内部类对象,通过对象调用内部类方法,来使用局部内部类功能。3.局部内部类访问局部变量必须用final修饰,原因是:主要是局部变量和对象的...
  • 内部类:在一个类里面类 分类:根据内部类所在位置不同: (1)成员内部类:外部类中方法外 1.有static修饰:静态内部类 2.无static修饰:成员内部类 【修饰符】 class 外部类 【extends 父类】【implements ...
  • java局部内部类

    2017-05-06 11:21:00
    java中局部内部类的特点:  1.定义在代码块、方法体的内的类叫做局部内部类  2.局部内部类访问外部类的属性和方法使用“外部类名.this.属性名”和“外部类名.this.方法名(参数)”的形式  3.对外部世界完全...
  • 分四种:成员内部类、局部内部类、静态内部类和匿名内部类。 1、成员内部类: 即作为外部类的一个成员存在,与外部类的属性、方法并列。 注意:成员内部类中不能定义静态变量,但可以访问外部类的所有成员。 public ...
  • 1.不可以被成员修饰符修饰 2.可以直接访问外部类中成员,...(局部内部类中访问局部变量,局部变量需要定义为final) package test; class Outer { private int x = 1; void method() { final int y = 4;
  • 外部类要访问内部类的成员,必须创建对象。 分类:按照内部类的位置分类分成 a. 成员位置(在成员位置定义的类,与方法平行;在测试类中访问成员内部类的格式为 ‘‘外部类名.内部类名 对象名 = 外部类对象.内部类...
  • 内部类 把一个类定义到另一个类的内部,我们就称之为内部类; 比如把类A定义在类B的内部,我们就把类A称为内部类,把类B称为外部类; 内部类的分类 内部类根据定义的位置不同,分为成员内部类和...内部类的访问特点
  • 广泛意义上的内部类一般来说包括这四种:成员内部类、局部内部类、匿名内部类和静态内部类。下面就先来了解一下这四种内部类的用法。 1.成员内部类 内部类定义在外部类的成员位置 特点: 具有类的特性: 继承父类,...
  • 内部类 为什么要有内部类? 1.提高类的安全性 2.防止外界创建对象 什么情况下可以不让外界创建对象? 1.抽象类 2.接口 3.内部类 4.构造方法私有 内部类概念: 在类中定义一个类就...内部类的特点: 1.外部类也可以直...
  • 局部内部类 成员内部类 2 成员内部类 2.1 访问特点: 内部类可以直接访问外部类的成员,包括私有的 外部类要访问内部类的成员,必须创建对象。 2.2 创建外部类对象的内部类对象 格式:外部类名.内部类名 对象名 ...
  • 局部内部类

    2019-08-02 19:03:25
    局部内部类可以直接访问外部类的成员,也可以访问方法中局部变量 局部内部类不可以直接访问,需要在方法中创建对象 测试 //局部内部类可以直接访问外部类的成员,也可以访问方法中局部变量 public class Out { int...
  • 2.内部类的访问特点 (1)内部类可以直接访问外部类的成员,包括私有的; (2)外部类要想访问内部类的成员,必须先创建对象。 3.内部类的位置 * 成员位置:在成员位置定义类,被称为成员内部类; * 局部位置:在...
  • 局部内部类特点: 1.定义在代码块、方法体内的类叫局部内部类 2.局部内部类访问外部类的属性和方法使用“外部类名.this.属性名”和“外部类名.this.方法名(参数)”的形式 3.对外部世界完全隐藏,只能在作用域内...
  • 内部类与局部内部类

    2018-08-19 08:31:22
    内部类与局部内部类 1、什么是内部类 将一个类A定义在另一个类B里面,里面那个类A就称为内部类,B则称为外部类。 1.成员内部类 :定义在类中方法外类。 定义格式:  class 外部类 {  class内部类{ } ...
  • JAVASE基础模块十二(成员内部类 局部内部类 匿名内部类) 内部类 内部类 将类A定义到类B中 那么这个类称之为内部类 类B称之为外部类 根据内部类定义位置分为 成员内部类和局部内部类 成员内部类:就是把内部...
  • 局部内部类的特点:(1)可以直接调用外部类成员<即使private>(2)在局部位置(方法体之内,内部类以外)可以创建内部类对象,调用内部方法。是不是有点像主函数里的行为?(3)局部内部类中的局部...
  • 1.17 局部内部类

    2020-09-30 13:12:31
    局部内部类是指在一个方法中定义内部类。示例代码如下: public class Test { public void method() { class Inner { // 局部内部类 } } } 局部内部类有如下特点局部内部类与局部变量一样,不能使用访问...
  • 文章目录:一、 内部类的分类:成员内部类的特点一方面作为外部类的成员:另一方面,作为一个类成员内部类VS 局部内部类 如何定义实战例子:二、 如何实例化成员内部类的对象例子演示结果输出三、例子 一、 内部类的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 654
精华内容 261
关键字:

局部内部类的特点