Java基础09

代码块

1. 放在{ }中的代码
2. 分类：
	局部代码块
	静态代码块
	构造代码块
	同步代码块（线程）

局部代码块

1. 格式
	{

	}
2. 位置：在方法中
3. 作用：限定变量的生命周期和作用于，进队{}有用
	注意：
		如果在局部代码块中修改了局部代码块外声明的变量，
		局部代码块结束之后，并不会消除局部代码块对这个变量的影响

代码：

/**
 * 位置方法中，
 * 作用：限定变量的生命周期
 * 注意：如果在局部代码块中修改了局部代码块外声明的变量，
 * 局部代码块结束之后，并不会消除局部代码块对这个变量的影响
 * @author Administrator
 *
 */
public class 局部代码块 {
	public static void main(String[] args) {
		A a=new A();
		a.f();
	}
}

class A{
	public void f() {
		{
			int a=10;
			System.out.println("这是代码块里的a："+a);
		}
		int a=20;
		System.out.println("这是代码块外的a："+a);
		
	}
}

输出结果：

静态代码块

1. 格式：
	static{
	}
2. 位置：类中方法外，加static关键字
3. 静态代码块随着类的加载而加载，加载一次。多个情况，按照代码的顺序执行。
4. 用法：
	当类加载静态代码块就执行。

代码：

/**
 * 位置：类中方法外
 * 作用：用于给静态的成员变量初始化赋值
 * 		用于执行那些只需要执行一次的代码，例如驱动加载等
 * 执行特点：
 * 	随着类的加载而执行
 * 	静态代码块只执行一次
 * 	执行的时机最早：早于所有的对象相关内容
 * @author Administrator
 *
 */
public class 静态代码块 {
	public static void main(String[] args) {
		B.f();
	}
}

class B{
	static {
		int a=10;
		System.out.println("这是静态代码块");
	}
	
	public static void f() {
		System.out.println("这是静态方法");
	}
}

输出结果：

构造代码块

1. 格式：
	{
	}
2. 位置：
	类中方法外
3. 构造代码块随着构造函数的执行而执行，没调用一次构造函数，
就执行一次构造代码块。多次调用构造函数则按照代码的顺序执行。
4. 用法：
	抽取出构造方法中共性的代码，可以放在构造代码块中。
	

代码：

/**
 * 位置：类中方法外
 * 作用：用于给成员变量初始化赋值，可以执行不同构造函数的共同功能
 * 说明：
 * 	创建对象时执行，由JVM默认调用
 * 	在构造方法执行之前执行
 * 	任一构造方法前都执行一次
 *  Administrator
 *
 */
public class 构造代码块 {
	public static void main(String[] args) {
		C c=new C();
		C c1=new C(1);
	}
}

class C{
	{
		System.out.println("这是构造代码块");
	}
	
	public C() {
		System.out.println("这是无参构造函数");
	}
	
	public C(int a){
		System.out.println("这是有参构造函数");
	}
}

输出结果：

类的对象的加载顺序

1. 一个类的对象创建的历程：
		1》先加载静态成员。
		2》隐式三步：
			①super
			②显示初始化
			③构造代码块
			其中②③执行的顺序按照代码的顺序执行
		3》构造方法中的代码。
2. 如果有继承关系，先父类 后子类，静态非静态分开。

代码：

/**
     1.一个类的对象的创建过程：
        1》先加载静态的成员。
        2》 隐式三步：
            ① super
            ②显式初始化
            ③构造代码块
          其中 ②③按照代码的顺序执行。多个的情况下，也是如此  
         3》构造方法中的代码。
      2.如果有继承关系，先父类 后子类。静态/非静态分开。
 *
 */
public class Topic1 {
	public static void main(String[] args) {
		  new N(1);
	}
}
class  M {
	static{
		System.out.println("这是M的静态代码块。。。。。6");
	}
	  {
		  System.out.println("这是M的构造代码块。。。。8");
	  }
}
class N extends M{
	static{
		System.out.println("这是N的静态代码块。。。。1");
	}
	{
		System.out.println("这是一个构造代码块。。。。2");
	}
	int a=setN();
	public N(int a) {
		this();
		System.out.println("这是N的有参构造。。。。4");
	}
	public N() {
		System.out.println("这是N的无参构造。。。。3");
	}
	public int setN() {
		System.out.println("这是a的赋值。。。。。5");
		return 1;
	}
	
}

输出结果：

内部类

1. 内部类：类中的类
2. 内部类的种类
		①成员内部类：类中方法外
			一般成员内部类
			静态成员内部类
			私有成员内部类
		局部内部类：方法中
3. 内部类的命名规则：
		外部类的名称$内部类的名称。

一般成员内部类

1. 位置：类中方法外
2. 在外部类中不能直接使用内部类的成员，想要使用，需要创建内部类对象才能调用
3. 在内部类中能直接调用外部类的成员
4. 一般成员内部类创建对象的格式
		外部类名称.内部类名称 对象名=new 外部类名称（参数）.new 内部类名称（参数）
5. 一般成员内部类不能有静态方法。静态方法只能存在静态内部成员类或外部类。

代码：

/**
 * 1.位置 ：类中方法外。
    2.在外部类中不能直接使用内部类的成员，要想使用，需要创建内部类的对象，才能调用。
    3.在内部类中可以直接使用外部类的成员
    4.一般成员内部类：对象创建：
    格式：
       外部类的名称.内部类的名称  对象的名称= new 外部类的名称(参数).new 内部类的名称(参数)
 * @author Administrator
 *
 */
public class 一般成员内部类 {
	public static void main(String[] args) {
		OuterC.InnerC inner=new OuterC().new InnerC();
		inner.fun();
		System.out.println(inner.a);
	}
}

class OuterC{
	int f=20;
	public void outerFun() {
		System.out.println("这是外部类的一个方法");
		/*InnerC in=new InnerC();
		in.a=10;
		in.fun();*/
	}
	
	class InnerC{
		int a=19;
		public void fun() {
			/*outerFun();
			f=10;*/
			System.out.println("这是一个内部类");
		}
	}
}

输出结果：

静态成员内部类

1. 位置：类中方法外。多了一个static
2. 外部类不能直接调用内部类的成员，如果是静态则类名.成员名称进行调用，如果是非静态成员则需创建对象。
3. 静态成员内部类的成员可以调用外部类的成员：
		①外部类成员是静态时，直接调用。
		②外部类成员是非静态时，创建对象再调用。
4. 对象的创建：
	格式：
		外部类名称.内部类名称 对象名=new 外部类名称.内部类名称（）

代码：

/**
     1.位置： 类中方法外。多了一个关键字static
     2.外部类不能直接调用静态成员内部类的成员，对于静态成员来说，类名.成员进行调用，如果是静态成员内部类的非静态成员，需要创建对象，再调用。
     3.静态成员内部类的成员可以调用外部类的成员:
          ① 外部类的成员是静态成员时，直接调用。
          ②外部类的成员是非静态成员时，创建对象，再进行调用。
      4.对象的创建：  
         格式：
          外部类的名称.内部类的名称  对象的名称=new 外部类的名称.内部类的名称()
 *
 */
public class 静态成员内部类 {
	public static void main(String[] args) {
		   OuterS.InnerS  inners=new OuterS.InnerS();
	}
}
class OuterS{
	int  a=10;
	static int b=20;
	public static void sf() {
		System.out.println(InnerS.d);
		InnerS.innerSF();
		
	}
	public void fun() {
		
	}
	//静态成员内部类
	static class InnerS{
		int  c=30;
		static int d=50;
		public void innerFun() {
			sf();
			System.out.println(b);
			System.out.println("这是一个静态成员内部类的方法");
			OuterS os=new OuterS();//对于外部类中的非静态成员，必须创建对象 保证存在
			os.fun();
		}
		public static void innerSF() {
			sf();
			System.out.println(b);
			System.out.println("这是一个静态成员内部类的静态方法。。。。。");
			OuterS os=new OuterS();//对于外部类中的非静态成员，必须创建对象 保证存在
			os.fun();
		}
	}
}

私有成员内部类

1. 位置：类中方法外，关键字private
2. 外部类不能直接调用私有成员内部类的成员：
	1>如果外部类的成员是静态成员，先创建外部类的对象，
	然后再创建私有成员内部类的对象，然后调用。
	2>如果外部类成员是非静态成员，直接创建内部类对象，然后调用。
3. 私有成员内部类直接调用外部类的成员。
4. 对象的创建：
	私有成员内部类，不能在外部类的外面创建对象。
5. 私有成员内部类没有静态方法。

代码：

public class 私有成员内部类{
	public static void main(String[] args){
	
	}
}

class OuterP {
	public static void sf() {
		// 为了保证内部类的必然存在，必须现有外部类，然后再有内部类的对象。
		InnerP innerP = new OuterP().new InnerP();
		innerP.funInner();
	}

	public void fun() {
		InnerP innerP = new InnerP();
	}

	// 私有成员内部类
	private class InnerP {
		// 只有静态成员内部类有静态方法。
		// public static void sfp() {}
		public void funInner() {
			fun();
			sf();
			System.out.println("这是一个内部类的方法。。。。。");
		}
	}
}

局部内部类

1. 局部内部类：
	位置：在方法中
2. 局部内部类要想运行，必须先调用该局部内部类所在的方法，并且在方法中，创建对象，调用局部
内部类中的方法，才能使用。

代码：

public class 局部内部类 {
	public static void main(String[] args) {
		OuterT ot = new OuterT();
		ot.fun();
	}
}

class OuterT {
	public void fun() {
		class InnerT {
			public void funT() {
				System.out.println("这是一个局部内部类。。。。");
			}
		}
		// 创建对象
		InnerT in = new InnerT();
		in.funT();
	}
}