final关键字的使用
final:不可改变的,最终的。可以用于修饰类、方法和变量(局部变量,成员变量)。
- 被修饰的类不能被继承
- 被修饰的方法不能被重写
- 被修饰的变量,不能被重新赋值
1、被final所修饰的局部变量只能够进行一次赋值操作,随后不能改变
2、引用类型的局部变量被final修饰后,只能指向同一个对象,地址值不能发生改变
3、final对成员变量的初始化的两种方法
class User{
//第一种初始化数变量方法
final String NAME="张三";
/*第二种初始化则在构造函数里面
final String NAME;
public User(String name){
this.NAME = name;
}*/
public void run(){
System.out.println("run");
}
}
public class FinalUsing {
public static void main(String[] args) {
final int a = 10;
//a=20; // 报错,被final修饰的变量不能进行二次赋值
System.out.println(a);
//引用类型的局部变量被final修饰后,只能指向同一个对象,地址值不能发生改变
final User u = new User();
//下面这行新创建了一个相同对象,但是地址值不一样
//User u = new User(); 报错
u.run();
}
}
static关键字的使用
Static使用方法:
- 当static修饰成员变量时,该变量为类变量(习惯称为静态变量)。每个对象都共用一个类变量,
即任何对象都可以改变类变量的值。被其修饰的成员可以作为共享数据。
注意:被static修饰的成员,属于类,不属于对象
static修饰的成员在进入内存的时候,会优先于对象存在
public class Stu {
String stuName;
int age;
static String classRoom;
//...get set 方法
}
public class Test {
public static void main(String[] args) {
Stu.classRoom ="魔法学院001";
//对于同一个班的学生 教室都是一致的
Stu stu =new Stu();
stu.setStuName("小红");
stu.setAge(20);
System.out.println(stu.getStuName());
System.out.println(stu.getAge());
System.out.println(stu.getClassRoom());
Stu stu1 =new Stu();
stu1.setStuName("小白");
stu1.setAge(19);
System.out.println(stu1.getStuName());
System.out.println(stu1.getAge());
System.out.println(stu1.getClassRoom());
}
}
- 当static修饰成员方法时,该方法为类方法(习惯称为静态方法)。该方法的调用不需要创建对象, 直接类名加方法名就可以调用。
访问静态方法的特点:
1、静态的不能直接访问非静态的(因为静态属于类,非静态输入对象,类一旦加载,那么静态的就会跟着类直接进入内存,是优先于对象存在的)
2、静态可以访问静态的
3、非静态的可以访问静态的
public class Test {
public static void main(String[] args) {
method();//报错
/* //非静态调用,创建对象然后调用
Test test = new Test();
test.method();
test.method3();*/
method1();
}
public void method() {
System.out.println("非静态方法");
}
public static void method1(){
System.out.println("静态方法");
}
//非静态方法访问静态方法
public void method3(){
method();
}
}
- static静态代码块,在类的加载中首先执行的就是静态代码块里面的指令,优先于main方法 便于初始化数据等作用,且只加载一次
public class Static {
static{
System.out.println("我是静态代码块");
}
public static void main(String[] args) {
}
}
内部类的认识及其使用
1、内部类即类中方法体外包含的其他类
2、内部类可以随意掉用外部类的方法以及成员变量
3、外部类如果要调用内部类方法或者成员变量的话
创建内部类对象格式:
外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
注意:
内部类可以直接使用外部类的成员
外部类不能直接使用内部类的成员
class A{
public int a = 10;
public void run(){
System.out.println("外部类A的方法");
}
class B{
public int b= 20;
public void run1(){
System.out.println("内部类B的方法");
//内部类可以直接使用外部类的成员
System.out.println(a);
run();
}
}
public void test(){
//外部类不能直接使用内部类的成员
/*System.out.println(b);//报错
run1();//报错*/
}
}
public class NBlei {
public static void main(String[] args) {
//外部类创建对象并调用方法
A a = new A();
a.run();
//内部类创建对象并调用方法
A.B b = new A().new B();
b.run1();
//等效于上面的创建内部类对象
A.B b1 = a.new B();
b1.run1();
}
}
匿名内部类:
使用场景:一个抽象类或者一个接口中的方法只调用一次
格式1: new 父类/接口(){
重写方法;}.重写方法名
格式2:类名 对象名 = new 类名(){
重写方法}
对象名.重写方法名
abstract class A {
abstract void run();
}
public class NMlei {
public static void main(String[] args) {
//格式一
/* new A(){
@Override
void run() {
System.out.println("方法");
}
}.run();*/
//格式二
A a = new A(){
@Override
void run() {
System.out.println("方法");
}
};
a.run();
}
}