内部类、static关键字、final

内部类

在Java中，允许在一个类的内部定义类，这样的类称为内部类，内部类所在的类称为外部类。在实际开发中，根据内部类的位置、修饰符和定义方式的不同，内部类可分为成员内部类、局部内部类、静态内部类、匿名内部类4种。

成员内部类

在一个类中除了可以定义成员变量、成员方法外，还可以定义类，这样的类称为成员内部类。成员内部类可以访问外部类的所有成员。

class Outer {
	int m = 0; 
	void test1() {
		System.out.println("外部类成员方法test1()");
	}
	class Inner {
		int n=1;
		void show1() {
			System.out.println("外部成员变量m=" + m);
			test1();
		}
		void show2() {
			System.out.println("内部成员方法show2()");
		}
	}
	void test2() {
        //定义外部类方法，访问内部类变量和方法
		Inner inner = new Inner(); 
		System.out.println("内部成员变量n=" + inner.n);
		inner.show2();
	}
}

public class Test {
	public static void main(String[] args) {
		Outer outer = new Outer();
		Outer.Inner inner = outer.new Inner();
		inner.show1();     //在内部类中访问外部类的成员变量m和成员方法test1()
		outer.test2();      //在外部类中访问内部类的成员变量n和成员方法show2()

	}
}

运行结果:

外部成员变量m=0
外部类成员方法test1()
内部成员变量n=1
内部成员方法show2()

如果想通过外部类访问内部类，则需要通过外部类创建内部类对象，创建内部类对象的具体语法格式如下：外部类名.内部类名变量名=new外部类名().new内部类名()；

 局部内部类 

局部内部类，也称为方法内部类，是指定义在某个局部范围中的类，它与局部变量一样，都是在方法中定义的，有效范围只限于方法内部。

在局部内部类中，局部内部类可以访问外部类的所有成员变量和方法，而局部内部类中变量和方法只能在所属方法中访问。

class Outer {
	int m = 0; 
	void test1() {
		System.out.println("外部类成员方法test1()");
	}
	void test2() {
		class Inner {
			int n=1;
			void show() {
				 //在局部内部类的方法中访问外部类的成员变量
				System.out.println("外部成员变量m=" + m);
				test1();
			}
		}
		Inner inner = new Inner(); 
		System.out.println("内部成员变量n=" + inner.n);
		inner.show();
	}
}

public class Test {
	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.test2(); 
	}
}

运行结果:

内部成员变量n=1
外部成员变量m=0
外部类成员方法test1()

局部内部类Inner的show(   )方法中可以访问到外部成员变量m和外部成员方法testl()，而在外部访问不到局部内部类Inner中的变量和方法。

静态内部类

静态内部类，就是使用static关键字修饰的成员内部类。与成员内部类相比，在形式上，静态内部类只是在内部类前增加了static关键字，但在功能上，静态内部类只能访问外部类的静态成员，通过外部类访问静态内部类成员时，可以跳过外部类直接访问静态内部类。

创建静态内部类对象的基本语法格式如下：

外部类名.静态内部类名  变量名=new  外部类名.静态内部类名()；

class Outer {
	static int m = 0; 
	void test1() {
		System.out.println("外部类成员方法test1()");
	}
	static class Inner {
			int n=1;
			void show() {
				 //在局部内部类的方法中访问外部类的成员变量
				System.out.println("外部成员变量m=" + m);
			}
		}
}

public class Test {
	public static void main(String[] args) {
		Outer.Inner inner=new Outer.Inner();
		inner.show(); 
	}
}

运行结果:

外部成员变量m=0

匿名内部类

匿名内部类是没有名称的内部类。在Java中调用某个方法时，如果该方法的参数是接口类型，除了可以传一个接口实现类外，还可以使用实现接口的匿名内部类作为参数，在匿名内部类中直接完成方法的实现。创建匿名内部类的基本语法格式如下：

new  父接口(){
//匿名内部类实现部分
}

interface Animal {
	void shout();
}
public class Test {
	public static void main(String[] args) {
		String name = "小花";
		animalShout(new Animal() {
			@Override
			public void shout() {
				System.out.println(name + "喵喵……");
			}
		});
	}
	public static void animalShout(Animal an) {
		an.shout();
	}
}

运行结果: 小花喵喵……

Animal 接口的匿名内部类作为animalShout()方法的参数，并在匿名内部类中重写了Animal接口的shout()方法。

匿名内部类中访问了局部变量name，而局部变量name并没有使用final 修饰符修饰，程序也没有报错。这是JDK8的新增特性，允许在局部内部类、匿名内部类中访问非final修饰的局部变量，而在JDK8之前，局部变量前必须加final修饰符，否则程序编译时报错。

(1)在调用animalShout()方法时,在方法的参数位置写上new Animal(){},这相当于创建了一个实例对象，并将对象作为参数传给animalShout()方法。在new Animal()后面有一对大括号，表示创建的对象为Animal的子类实例，该子类是匿名的，具体代码如下：

animalShout  (new Animal  ()  {})  ;

(2)在大括号中编写匿名子类的实现代码，具体如下：

animalshout(new Animal(){
public void shout(){
System. out. println("喵喵⋯⋯");
))  ;

static关键字

在定义一个类时，只是在描述某事物的特征和行为，并没有产生具体的数据。只有通过new关键字创建该类的实例对象时，才会开辟栈内存和堆内存，在堆内存中每个对象会有自己的属性。如果希望某些属性被所有对象共享，就必须将其声明为static属性。如果属性使用了static关键字进行修饰，则该属性可以直接使用类名称进行调用。除了修饰属性， static关键字还可以修饰成员方法。

静态属性 

如果在Java程序中使用static修饰属性，则该属性称为静态属性(也称全局属性)，静态属性可以使用类名直接访问，访问格式如下：类名.属性名

class Student {
	String name; // 定义name属性
	int age; // 定义age属性
	String school = "家里蹲大学"; // 定义school属性
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public void info() {
		System.out.println("姓名:" + this.name + ",年龄:" + this.age + ",学校:" + school);
	}
}
public class Test {
	public static void main(String[] args) {
		Student stu1 = new Student("张三", 18); // 创建学生对象
		Student stu2 = new Student("李四", 19);
		Student stu3 = new Student("王五", 20);
		stu1.info();
		stu2.info();
		stu3.info();
	}
}

运行结果:

姓名:张三,年龄:18,学校:家里蹲大学
姓名:李四,年龄:19,学校:家里蹲大学
姓名:王五,年龄:20,学校:家里蹲大学

3名学生均来自于同一大学。下面考虑一种情况：假设A大学改名为了B大学，而且此Student 类已经产生了10万个学生对象，那么意味着，如果要修改这些学生对象的学校信息，就需要把这10万个对象中的学校属性全部修改，共修改10万遍，这样肯定是非常麻烦的。

为了解决上述问题，可以使用static关键字修饰school属性，将其变为公共属性。这样， school属性只会分配一块内存空间，被Student类的所有对象共享，只要某个对象进行了一次修改，全部学生对象的school 属性值都会发生变化。

class Student {
	String name; // 定义name属性
	int age; // 定义age属性
	static String school = "家里蹲大学"; // 定义school属性
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public void info() {
		System.out.println("姓名:" + this.name + ",年龄:" + this.age + ",学校:" + school);
	}
}
public class Test {
	public static void main(String[] args) {
		Student stu1 = new Student("张三", 18); // 创建学生对象
		Student stu2 = new Student("李四", 19);
		Student stu3 = new Student("王五", 20);
		stu1.info();
		stu2.info();
		stu3.info();
		stu1.school="清华大学";
		stu1.info();
		stu2.info();
		stu3.info();
	}
}

运行结果:

姓名:张三,年龄:18,学校:家里蹲大学
姓名:李四,年龄:19,学校:家里蹲大学
姓名:王五,年龄:20,学校:家里蹲大学
姓名:张三,年龄:18,学校:清华大学
姓名:李四,年龄:19,学校:清华大学
姓名:王五,年龄:20,学校:清华大学

使用static关键字修饰了school属性,使用stu1对象为school属性重新赋值。只修改了一个stul对象的学校属性， stul和stu2对象的school属性内容都发生了变化，说明使用static声明的属性是被所有对象共享的。

static关键字只能修饰成员变量，不能修饰局部变量

 静态方法

如果想要使用类中的成员方法，就需要先将这个类实例化，而在实际开发时，开发人员有时希望在不创建对象的情况下，通过类名就可以直接调用某个方法，要实现这样的效果，只需要在成员方法前加上static关键字，使用static关键字修饰的方法通常称为静态方法。

静态方法也可以通过类名和对象访问，具体如下：

类名.方法 或  实例对象名.方法

class Student {
	private String name; // 定义name属性
	private int age; // 定义age属性
	private static String school = "家里蹲大学"; // 定义school属性
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public static String getSchool() {
		return school;
	}
	public static void setSchool(String school) {
		Student.school = school;
	}
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public void info() {
		System.out.println("姓名:" + this.name + ",年龄:" + this.age + ",学校:" + school);
	}
}
public class Test {
	public static void main(String[] args) {
		Student stu1 = new Student("张三", 18); // 创建学生对象
		Student stu2 = new Student("李四", 19);
		Student stu3 = new Student("王五", 20);
		Student.setSchool("清华大学");
		stu1.info();
		stu2.info();
		stu3.info();
	}
}

Student类将所有的属性都进行了封装，所以想要更改属性就必须使用setter方法。school属性是使用static 声明的，所以可以直接使用类名Student进行调用。

静态方法只能访问静态成员，因为非静态成员需要先创建对象才能访问，即随着对象的创建，非静态成员才会被分配内存。而静态方法在被调用时可以不创建任何对象。

 静态代码块

在Java类中，用static关键字修饰的代码块称为静态代码块。当类被加载时，静态代码块会执行，由于类只加载一次，因此静态代码块只执行一次。在程序中，通常使用静态代码块对类的成员变量进行初始化。

class Student {
	{
		System.out.println("我是构造代码块");
	}
	static {
		System.out.println("我是静态代码块");
	}
	public Student() { // 构造方法
		System.out.println("我是Student类的构造方法");
	}
}

public class Test {
	public static void main(String[] args) {
		Student stu1 = new Student();
		Student stu2 = new Student();
		Student stu3 = new Student();
	}
}

运行结果:

我是静态代码块
我是构造代码块
我是Student类的构造方法
我是构造代码块
我是Student类的构造方法
我是构造代码块
我是Student类的构造方法

代码块的执行顺序为静态代码块、构造代码块、构造方法。static修饰的成员会随着class文件一同加载，其优先级最高。在main()方法中创建了3个Student对象，但在3次实例化对象的过程中，静态代码块中的内容只输出了一次，这就说明静态代码块在类第一次使用时才会被加载，并且只会加载一次。

final关键字

final的英文意思是“最终”。在Java中，可以使用final关键字声明类、属性、方法，在声明时需要注意以下几点。

(1)使用final修饰的类不能有子类。

(2)使用final修饰的方法不能被子类重写。

(3)使用final修饰的变量(成员变量和局部变量)是常量，常量不可修改。

final关键字修饰类

Java中的类被final关键字修饰后，该类将不可以被继承，即不能派生子类。

 由此可见，被final关键字修饰的类为最终类，不能被其他类继承。

final关键字修饰方法

当一个类的方法被final关键字修饰后，这个类的子类将不能重写该方法。

在Dog类中重写了父类Animal中的shout()方法，编译报错。这是因为Animal类的shout()方法被final修饰，而被final关键字修饰的方法为最终方法，子类不能对该方法进行重写。因此，当在父类中定义某个方法时，如果不希望被子类重写，就可以使用final关键字修饰该方法。

final关键字修饰变量

Java中被final修饰的变量为常量，常量只能在声明时被赋值一次，在后面的程序中，其值不能被改变。

 在使用final声明变量时，要求全部的字母大写。如果一个程序中的变量使用public static final声明，则此变量成为全局常量，如下面代码所示 

public static final int AGE=18;