当前位置：网站首页>2022/07/27 学习笔记（day17）代码块和内部类

public class face_code_question {
    public static void main(String[] args) {
        System.out.println("我是主方法");
        //创建对象
        question s=new question();
        question s1=new question("Hallo Word");               			
        //主方法，在主方法类中的静态代码块执行之后执行
        {
            System.out.println("我是局部代码块");
        }
    }
    static {
        System.out.println("我是主方法类中的静态代码块");            
        //主方法类中的静态代码块优先于主方法执行
    }
}
class question {
    private String name;
    //无参构造
    public question() {
        System.out.println("我是无参构造");
    }
    //有参构造
    public question(String name) {
        this.name=name;
        System.out.println("我是有参构造");
    }
    {
        System.out.println("我是构造代码块");              		
        //随着对象的创建而加载，对象创建一次，构造代码块执行一次
    }
    static {
        System.out.println("我是静态代码块");              		
        //静态代码块，随着类的加载而加载，并且只执行一次
    }
}

测试结果：

不管是哪种方法，我们需要明确静态代码块的存在在类加载的时候就自动运行了

“依赖”可理解为如果不实例化对象（也就是不执行构造方法），构造代码块是不会执行的

4.代码块执行顺序：

代码块执行顺序：静态代码块——> 构造代码块 ——> 构造函数——> 普通代码块
继承中代码块执行顺序：父类静态块——>子类静态块——>父类代码块——>父类构造器——>子类代码块——>子类构造器

二.嵌套类和内部类：

1. 嵌套类分为两种类型：

静态嵌套类和非静态嵌套类。平常我们使用的最多的是非静态嵌套类，也就是被称为内部类，其中内部类又可以分为三种：

a.在一个类（外部类）中直接定义的内部类

b.在一个方法（外部类的方法）中定义的内部类

c.匿名内部类

2.在外部类中定义内部类：

对于内部类，通常在定义类的class关键字前，不加public或private等修饰词。内部类的成员只在内部类可见，若外部类或同层次的内部类需要访问，需要创建类的对象，不可以直接访问内部类的变量

public class Test2{  
	String name="galen";   
	class InnerOne{  
		public int a=1;
		private int b=2;  
		int c=3;  
		public void display(){  
			System.out.println("name:" +name);  
		} 
	}   
	void test(){  
		InnerOne ino = new InnerOne(); 
		ino.display();  
		//System.out.println("InnerOne a:"+a);		
		//在外层类中的某个方法里面不能直接访问内部内变量  ，必须通过对象来访问
		System.out.println("InnerOne a:"+ino.a);	//可以访问  
		System.out.println("InnerOne b:"+ino.b);	//可以访问  
		System.out.println("InnerOne c:"+ino.c);	//可以访问   
		InnerTwo it = new InnerTwo();  
		it.transfer();  
	}   
	class InnerTwo{  
		InnerOne ino = new InnerOne();  
		public void transfer(){  
			//System.out.println(a);	//不可访问Innter的y成员  
			//System.out.println(InnerOne.a);//不可直接访问Inner的任何成                                                                   员和方法  
			ino.display();		        //可以访问  
			System.out.println("sum="+(ino.a+ino.b+ino.c));	//可以访问  
		}  
	}   
	public static void main(String args[]){  
		Test2 ot = new Test2();  
		ot.test();  
	} 
}

3.在方法中定义内部类:

定义在方法中的内部类的可见性更小，它只在方法内部可见，在外部类及外部类的其它方法中都不可见。

它有一个特点，就是方法中的内部类连本方法的成员变量都不可访问，它只能访问本方法的final型成员

在方法中定义成员时，只允许使用final修饰词或不加修饰词

4.匿名内部类：

匿名内部类通常用在java的事件处理上，比如，在后续我们将学的窗体程序中，使用匿名内部类将很有用

public abstract class Eat {
 
	//能吃饭
	public void eatable();
}

public class Person {
 
	public void feed(Eat e){
		e.eatable();
	}
}

public class Test2{
	
	public static void main(String[] args) {
		Person mary = new Person();
		mary.feed(new Eat() {
			
			@Override
			public void eatable() {
				System.out.println("汉堡包");
			}
			
		});
	}
}