final，static关键字

Posted 2020-12-11 dingxiang2020

final，static关键字

final

是用于修饰 类、方法、局部变量、成员变量

final 修饰类

public final class Person

特点：被final 修饰的类不能够被继承

final 修饰方法

格式：
修饰符 final 返回值类型 方法名(参数){

? 方法体
? 返回值

}

特点：被final修饰的方法不能够被重写

public class Animal{
	public final void eat(){//被final 修饰的方法不能够被重写
		system.out.println("动物要吃饭");
	}
}

final 修饰局部变量

格式
final 数据类型 变量名=值
特点： 被final修饰的局部变量一旦被初始化，那么不能被二次赋值

final 修饰一个对象

格式
final 类名 对象名=new 类名();

特点：
被final修饰的对象名，地址值不能改变，但是对象中的属性可以改变

public class Var_Test02{
	public static void main(String[] args){
		Person p=new Person("岳"，36);//给p分配的是地址值
        system.out.println(p);
        p=new Person("涛"，28);//重新附地址值给对象
        
        //final修饰对象
        final Person p1=new Person("岳"，36);//给p1分配的是地址值
        system.out.println(p1);
        //p1=new Person("涛"，28);//此时不能给final 修饰的对象重新赋给地址值
        //但是可以给final修饰的对象改变属性
        p1.setName("涛");
	}
}

final 修饰成员变量

格式：
final 数据类型 变量名

特点：被final修饰的成员变量不能被二次赋值

权限修饰符

public>protected>default>private

	public	protected	default	private
同类	Y	Y	Y	Y
同包不同类	Y	Y	Y	N
不同包子类	Y	Y	N	N
不同包非子类	Y	N	N	N

Static

static修饰成员变量

1.被static 修饰的成员可以作为共享对象(根据这个static所在的类创建出来的对象，都可以共享这static的成员)
2.被static 的修饰的成员，属于类而不属于对象，所以我们在调用static 修饰的成员的时候，就不用new对象，直接类名调用
3.static 修饰的成员在进入内存的时候，会优先于对象

public class Student {
    String name;
    int age;
    static String classRoom;

    public Student() {

    }

    public Student(String name, int age, String classRoom) {
        this.name = name;
        this.age = age;
        this.classRoom = classRoom;
    }

    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 String getClassRoom() {
        return classRoom;
    }

    public void setClassRoom(String classRoom) {
        this.classRoom = classRoom;
    }
}

/*
   static:
      1.被static修饰的成员属于类 ,不属于对象
      2.被static修饰的成员优先于对象存在的
      3.被static修饰的成员可以作为共享数据(根据static所在的类创建出来的对象都可以共享这个static的成员)
 */
public class Test {
    public static void main(String[] args) {
        Student.classRoom = "金燕龙202";//类名直接调用static修饰的成员
        Student student = new Student();
        student.setName("老顽童");
        student.setAge(80);
       /* student.setClassRoom("201教室");*/
        System.out.println(student.getName());
        System.out.println(student.getAge());
        //System.out.println(Student.classRoom);
        System.out.println(Student.classRoom);



        Student student1 = new Student();
        student1.setName("杨过");
        student1.setAge(18);
        //student1.setClassRoom("201教室");
        System.out.println(student1.getName());
        System.out.println(student1.getAge());
        //System.out.println(Student.classRoom);
        System.out.println(student1.getClassRoom());
    }
}

Static 修饰方法

方法方式：
1.new 对象后，对象调用
2.类名直接调用--->推荐使用

访问静态方法的特点:
1.静态的不能直接访问非静态的：静态的属于类，而非静态的属于方法，即静态的优先于对象的。如果要访问非静态的，要在静态方法中先创建对象在通过对象调用

2.静态能访问静态的：
同类中：可以直接调用静态方法；或者创建对象调用
非同类中：创建对象调用，或者类名直接调用

3.非静态的可以调用静态的：

只要是静态的访问非静态的就要new对象调用
只要是访问静态的：类名直接调用

Static 静态代码块

static {

? 代码

}

注意：静态代码块优先于构造方法执行；且静态代码块只执行一次

使用场景：
当我们初始化变量的时候，只要求我们初始化一次来供后面使用时，可以使用静态代码块

内部类

类中有类
格式：

Class A{

? Class B{

? }

}

注意：内部类可以直接使用外部类的成员；但是外部类不可以直接使用内部类的成员

public class Person {
    int num = 10;
	//内部类
   class Heart{
        int i = 20;

        public void method(){
            System.out.println("我是内部类的method方法");
            eat();
            System.out.println(num);
        }

    }

    public void eat(){
        //System.out.println(i);
        System.out.println("人要吃饭");
       // method();外部类不可以直接使用内部类的成员
    }
}

访问内部类：

1.先创建外部类的对象
2.根据外部类的对象去创建内部类的对象
3.调用内部类的成员

? 格式:
? 外部类名.内部类名 对象名 = new 外部类型().new 内部类型()

/*
   1.先创建外部类的对象
   2.根据外部类的对象去创建内部类的对象
   3.调用内部类的成员

   格式:
      外部类名.内部类名 对象名 = new 外部类型().new 内部类型()

 */
public class Test {
    public static void main(String[] args) {
        /*Person person = new Person();
        System.out.println(person.num);*/

        Person.Heart heart = new Person().new Heart();
        heart.method();
        System.out.println(heart.i);

    }
}

匿名内部类：
格式：
new 父类/接口(){

? 重写的方法

}.重写的方法

public abstract class Animal {
    public abstract void eat();
}

public class Test {
    public static void main(String[] args) {
        new Animal(){
            @Override
            public void eat() {
                System.out.println("人要吃饭");
            }
        }.eat();

        System.out.println("---------------");

        Animal animal = new Animal() {
            @Override
            public void eat() {
                System.out.println("人吃肉");
            }
        };
        animal.eat();
    }
}

使用场景：如果一个抽象类或者一个接口中调用一次，我们就没有必要去单独创建子类，一般用于抽象类和接口