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);//30System.out.println(this.num);//20System.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() {@Overridepublic void method() {System.out.println("匿名内部类");}};	//这里有省略号 i.method();//匿名对象和匿名内部类结合new Interface() {@Overridepublic void method() {System.out.println("匿名内部类");}}.method;}}