final
- final关键字可以修饰类,此时这个类无子类,所有的成员方法都无法进行覆盖重写
public final class 类名称{}
- final关键字修饰方法时,这个方法就是最终方法,不能被覆盖重写,但是此时这个类可以有子类。
public final void method(参数列表){方法体}
- final修饰局部变量,这个变量就不能进行更改,
final int num=200;
修改不了 - 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;
}
}