JAVA基础知识学习笔记——final,static

一、final关键字

final修饰的类、方法、变量的特点

final修饰的类的特点：是一个最终类不能被继承
final修饰的方法的特点：是一个最终方法,可以被继承使用,但是不能被重写
final修饰的变量的特点：是一个常量,值不能改变

final修饰的类

public class Ye {
}

/*
    final修饰的类:是一个最终类,不能被继承;其他的使用方式不变(继承其他的类,创建对象使用...)
    
 */
public final class Fu extends Ye{
}

/*
    Cannot inherit from final 'com.itheima.demo01finalClass.Fu'
    被final修饰的类,不能被继承
 */
/*public class Zi extends Fu{
}*/

public class Demo01 {
    public static void main(String[] args) {
        Fu fu = new Fu();
    }
}

final修饰的方法

/*
    final修饰的方法:是一个最终方法,可以被继承使用,但是不能被重写
 */
public class Fu {
    public void show01(){
        System.out.println("Fu类没有被final修饰的show01方法");
    }

    public final void show02(){
        System.out.println("Fu类被final修饰的show02方法");
    }
}

public class Zi extends Fu{
    public void show01(){
        System.out.println("Zi类重写Fu类没有被final修饰的show01方法");
    }

    /*
        'show02()' cannot override 'show02()' in 'com.itheima.demo02finalMethod.Fu'; overridden method is final
        子类不能重写父类被final修饰的方法
     */
    /*public final void show02(){
        System.out.println("Fu类被final修饰的show02方法");
    }*/
}

public class Demo01 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.show01();//调用的是子类重写后的show01方法
        zi.show02();//调用子类继承自父类的final修饰的方法
    }
}

final修饰的变量

局部变量:是一个常量,值不能改变

//测试类
public class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    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;
    }
}

/*
    final修饰的变量:是一个常量,值不能改变
    局部变量:定义在方法中的变量(语句中for，while...)
    final修饰符是局部变量唯一的修饰符
 */
 public static void main(String[] args) {
        /*
            final修饰的局部变量:是一个常量,值不能改变
            基本数据类型(4类8种):值不能改变
         */
        final int a = 10;
        //a = 20;//Cannot assign a value to final variable 'a'

        /*
            引用数据类型(数组,类,集合...):地址值不能改变
            对象中的内容是可以改变的(成员变量的值,数组中的元素,集合中的元素...)
         */
        final Person p1 = new Person("张三",20);
        System.out.println(p1);//com.itheima.demo03finalVariable.Person@4554617c

        //p1 = new Person("李四",30);//Cannot assign a value to final variable 'p1'
        System.out.println(p1);//com.itheima.demo03finalVariable.Person@74a14482
        //p1 = null;//Cannot assign a value to final variable 'p1'

        p1.setAge(30);
        System.out.println(p1);//com.itheima.demo03finalVariable.Person@4554617c
    }

成员变量:必须在创建对象前赋值

/*
    final修饰的成员变量:是一个常量,值不能改变
    特点:特殊记忆
        final修饰的成员变量必须在创建对象前赋值(规定)
    注意:
        1.成员变量的默认值(String=>null,int==>0,doble=>0.0,boolean==>false),
        不是final修饰的成员变量的值,必须赋一个具体值
        2.赋值的方式:
            a.直接赋值:定义变量,直接给变量赋值
            b.使用构造方法赋值,构造方法是创建对象前执行
            无论哪种赋值方式,只能赋值一次
        3.常量的命名规则:一般都使用大写字母
            final int  AAA_BBB_CCC = 10;
 */
public class Student {
    //final int a;//Variable 'a' might not have been initialized

    //a.直接赋值:定义变量,直接给变量赋值
    final int b = 10;

    final int c;

    final String d = null;

    //b.使用构造方法赋值,构造方法是创建对象前执行
    public Student() {
        c = 20;
        //b = 100;//Cannot assign a value to final variable 'b' 无论哪种赋值方式,只能赋值一次
    }

    public Student(int e){
        c=e;
    }
}

二.static关键字

1.static关键字概述

static是静态修饰符，一般修饰成员。被static修饰的成员属于类，不属于单个这个类的某个对象。static修饰的成员被多个对象共享。static修饰的成员属于类，但是会影响每一个对象。被static修饰的成员又叫类成员，不叫对象的成员

2.static关键字的使用

/*
    定义每个学生特有的属性(非静态):姓名,年龄
    定义每个学生共享的属性(静态):国家
 */
public class Student {
    String name;
    int age;
    static String country = "中国";
}

public class Demo01Student {
    public static void main(String[] args) {
        //创建Student对象,给对象的属性赋值
        Student s1 = new Student();
        s1.name = "张三";
        s1.age = 18;
        System.out.println(s1.name+"\t"+s1.age);
        System.out.println(s1.country);

        Student s2 = new Student();
        s2.name = "李四";
        s2.age = 19;
        System.out.println(s2.name+"\t"+s2.age);
        System.out.println(s2.country);
        //改变country的值
        s2.country = "中华人民共和国";
        System.out.println(s1.country);
        System.out.println(s2.country);
    }
}

3.static修饰的静态成员的使用方式

/*
    定义每个学生特有的成员(非静态)
        只有一种使用方式:创建对象,访问属性,调用方法
    定义每个学生共享的成员(静态)
        有两种使用方式:
            1.创建对象,访问属性,调用方法(不推荐,占用内存,效率低)
            2.静态的成员属于类,所以我们可以通过类名直接使用
                类名.静态成员变量
                类名.静态的成员方法(参数);
 */
public class Student {
    //定义非静态的成员变量
    int a = 10;
    //定义静态成员变量
    static int b = 20;

    //定义非静态的成员方法
    public void show01(){
        System.out.println("Student类的非静态show01方法!");
    }

    //定义静态的成员方法
    public static void show02(){
        System.out.println("Student类的静态show02方法!");
    }
}

public class Demo01Student {
    public static void main(String[] args) {
        //创建Student对象
        Student s = new Student();
        System.out.println(s.a);
        System.out.println(s.b);
        s.show01();
        s.show02();
        //静态的成员,通过类名可以直接使用
        System.out.println(Student.b);
        Student.show02();
        Student.b = 200;
        System.out.println(Student.b);

        Demo01Student.method();
        //同一个类中,使用静态的成员,可以省略类名
        method();
    }

    public static void method(){
        System.out.println("静态的method方法!");
    }
}

静态方法调用的注意事项：
静态方法可以直接访问类变量和静态方法。
静态方法不能直接访问普通成员变量或成员方法，成员方法可以直接访问类变量或静态方法。
静态方法中，不能使用this关键字。