JAVA_内部类和代码块

JAVA内部类各种姿态和代码块

在JAVA中一般内部类分为四种：成员内部类、静态内部类、局部内部类、匿名内部类。
①成员内部类
1)在成员内部类中方法可以直接调用外部类的实例变量和方法。
2)在成员内部类中可以直接用内部类创建对象。
代码案例：

        class Out{
		int x = 0 ;
		public Out(int x ){
			this.x = x;
		}
		class Inner{
			int x = add();		//内部类可以无条件访问外部类所有成员属性和成员方法(包括私有和静态)
			system.out.println(Out.this.x);		//在访问与内部类同名方法或变量时，要指定访问的是对象的成员
		}
		private int add(){
			return x++;
		}
	}

这就是简单的成员内部类，虽然内部类可以无条件的访问外部类的成员，而外部类访问内部类的成员却不是那么随心所欲了，
必须先创建一个内部类的对象，再通过指向这个对象的引用来访问：
代码案例：

        class Out{
	       int x = 0;
		public void (int x){
			this.x = x;
		}
		public void say(){
			//持有外部类对象，然后创建一个内部类对象就可以调用
			new inner().readHello();
		}
		class Inner{
			public void  readHello(){
				system.out.println("say Hello");
			}
		}
		public inner getInner(){
            		return  new Inner();		      
		}
	}

内部类的存在是依附于外部类的，也就是说如果要创建内部类对象，前提是存在一个外部类对象。
成员内部类创建对象的一般格式如下：
//第一种方式
Inner inner = new Out().new Inner();
//第二种方式(在外部类中方法已经创建了一个内部类对象，通过访问外部类方法得到内部类对象)
Inner inner = new Out().getInner();
内部类的访问权限。
private：只能外部类去访问
protected: 同一个包下或继承外部类情况下可以访问
默认情况： 只能在同一包下访问。
②局部内部类

局部内部类是定义子一个方法或者一个作用域里的类，它和它的成员内部类的区别在于局部内部类的访问权限仅限于方法或者作用域内。

局部类中是不能有修饰符的，而且参数和方法中的变量必须是final。

外部方法中是不允许有修饰符的，因为修饰符使用来描述，类的属性和成员变量，而方法中定义的变量属于临时变量。

        class fu{}
	class Out{
		public fu getfu(final x){
			class inner extends fu{
				//局部内部类不能有权限
			}
			return new inner;
		}
	}

③匿名内部类
匿名内部类基本是Android中用的很多的，一般在写事件监听使用匿名内部类，方便代码维护。我也学过一段安卓，下面写一段Android中

Button的监听事件。调用一次使用匿名内部类。匿名内部类是唯一一个没有构造器的内部类。

       // 实现接口
	button.setOnClickListener(new View.OnClickListener(){
		public void onClick(View v){
			Log.d("TAG","你点击我了！！");		
		}
	});
	//实现类  
	abstract AbsDemo{
		public void say();	
		public void succes();
	}
	// AbsDemo d = new AbsDemo();          多态： 没有名字的子类对象
	new AbsDemo(){
		public void say(){
			System.out.print("haha");
		}
		public void succes(){
			System.out.print("succes");
		}
	}.say();

匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调。
匿名内部类在编译的时候由系统自动起名为Outter$1.class。一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，
只是对继承方法的实现或是重写。不能有访问权限和修饰符。
等于就是一个对象 实现接口中的方法，没有名字
④静态内部类
　　静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的
静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建
静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。

注意：

如果内部类中有静态成员，这个内部类必须声明为静态的。

如果外部类中静态方法访问内部类，内部类必须是静态的。

         public class Out{
		int a = 5;
		static int b = 10;
		static Inner{
			public void fangwen(){
				//system.out.println(a)		静态内部类只能访问外部类静态变量
				system.out.println(b);
			}
		}
	}

         public class Out{
		int a = 5;
		static int b = 10;
		static Inner{
			public void fangwen(){
				//system.out.println(a)		静态内部类只能访问外部类静态变量
				system.out.println(b);
			}
		}
	}

JAVA中的代码块分为三种：普通代码块、构造代码块、静态代码块。
执行顺序为(优先级从高到低): 静态代码块>main方法>构造代码块>构造方法
一.不同代码块
1 普通代码块：在方法或语句中出现的{}就称为普通代码块。普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定--
“先出现先执行”

2. 构造代码块：直接在类中定义且没有加static关键字的代码块称为{}构造代码块。构造代码块在创建对象时被调用，每次创建对象都会被调用，
并且构造代码块的执行次序优先于类构造函数。

        public class CodeBlock02{
			{
				system.out.println("第一个代码块");
			}
			public CodeBlock02(){
				system.out.println("构造方法");
			}
			{
				system.out.println("第二个代码块");
			}
			public static void main(String[] args){
				new CodeBlock02();
			} 
	}
	执行结果：
		第一个代码块	
		第二个代码块
		构造方法

3. 静态代码块:在java中使用static关键字声明的代码块。静态块用于初始化类，为类的属性初始化。每个静态代码块只会执行一次。由于JVM在
加载类时会执行静态代码块，所以静态代码块先于主方法执行。
如果类中包含多个静态代码块，那么将按照"先定义的代码先执行，后定义的代码后执行"。
注意：1 静态代码块不能存在于任何方法体内。
 2 静态代码块不能直接访问静态实例变量和实例方法，需要通过类的实例对象来访问。

           public class CodeBlock03{
			static{
				system.out.println("静态代码块");
			}
			public CodeBlock03(){
				system.out.println("构造方法");
			}
			{
				system.out.println("构造代码块");
			}
			public static void main(String[] args){
				system.out.println("main方法")
				new CodeBlock03();
			} 
	}
	执行结果：
		静态代码块
		main方法
		构造代码块
		构造方法

好了！今天就写到这里，睡觉觉吧~~~~