Day8-2020-7-25 final 内部类

final

1. final关键字可以修饰类，此时这个类无子类，所有的成员方法都无法进行覆盖重写public final class 类名称{}
2. final关键字修饰方法时，这个方法就是最终方法，不能被覆盖重写，但是此时这个类可以有子类。public final void method（参数列表）{方法体}
3. final修饰局部变量，这个变量就不能进行更改，final int num=200； 修改不了
4. final修饰成员变量，变量不可变

注意：
修饰方法时，final 和 static 不能同时写
对基本数据来说，变量中的数据不变 ； 对引用类型来说，变量当中的地址值不可变
修饰成员变量：由于成员变量有默认值，使用final后要手动赋值，不会给默认值。
对于final的成员变量，要么直接赋值，要么构造方法赋值，二者选一
使用构造方法赋值时，必须保证类中所有重载的构造方法，都最终会对final 的成员变量赋值

内部类

权限修饰符规则
外部类：public , (default)
成员内部类：public / protected / （default）/ private
局部内部类：啥也不能写 直接就是 class

成员内部类

修饰符 class 外部类名称{ 修饰符 class 内部类名称 { } }
内用外随意使用，外用内需要内部类对象

使用成员内部类

• 间接使用：外部类方法调用内部类方法，实现外部类，运行外部类方法从而实现内部类
• 直接使用：外部类名称.内部类名称 对象名=new 外部类名称（）.new 内部类名称（）；

//外部类和内部类
public class Body {
	
	public class Heart{
		int num;
		public void methodHeart() {
			System.out.println("内部类方法");
		}
	}
	
	
	int age;
	
	public void methodBody() {
		System.out.println("外部类的方法");
		new Heart().methodHeart();
	}
	
	
	public Body(int age) {
		super();
		this.age = age;
	}

	

	public Body() {
	
	}



	public int getAge() {
		return age;
	}


	public void setAge(int age) {
		this.age = age;
	}


	
}

//主方法
public class BodMain {

	public static void main(String[] args) {
		//间接调用
		
		Body b=new Body();
		b.methodBody();
		
		System.out.println("-----------------------");
		
		//直接调用
		
		Body.Heart h=new Body().new Heart();
		h.methodHeart();
	}

}

内部类同名变量

外部类成员变量名：外部类名称.this.外部类成员变量名

//外部类内部类方法

public class Abs {
	
	int num=10; //外部类的成员变量
	
	public class Cds{
		
		int num=20;	//内部类的成员变量
		
		public void print() {
			int num=30;	//内部类的局部变量
			System.out.println(num);//30
			System.out.println(this.num);//20
			System.out.println(Abs.this.num);//10 
		}
	}
	
}

//主方法
public class AbsMain {

	public static void main(String[] args) {
		Abs.Cds c=new Abs().new Cds();
		c.print();
	}

}

局部内部类

一个类定义在方法内部，出了这个方法就不能使用
成员变量必须是final修饰，不可改变

//外部类和局部内部类
public class A {
	
	public void set() {
		class B{			//局部内部类
			int num =10;
			public void print() {
				System.out.println(num);
			}
		}	
		//在方法里面实现局部内部类，调用
		B b=new B();
		b.print();
	}
}

//主方法
public class AMain {

	public static void main(String[] args) {
		A a=new A();
		a.set();	//实现外部类方法间接实现局部内部类
	}

}

匿名内部类*

格式：接口名称 对象名=new 接口名称（）{覆盖抽象方法}
{} 中的东西才是匿名内部类
如果接口的实现类或者继承类只需要使用一次便不再使用，不需要单独写一个实现类，直接匿名内部类

注意：

• 匿名内部类在使用中只能使用一次
• 匿名内部类省略了子类名称/实现类，匿名对象省略了对象名称

//接口
public interface Interface {
	
	void method();
}

//主方法
public class InterfaceMain {

	public static void main(String[] args) {
		
		//匿名内部类
		Interface i= new Interface() {
			@Override
			public void method() {
				System.out.println("匿名内部类");
			}
		};	//这里有省略号 
		i.method();
		//匿名对象和匿名内部类结合
		new Interface() {
			@Override
			public void method() {
				System.out.println("匿名内部类");
			}
		}.method;
	}

}